Launch description initial (#2)

Initial functionality pass

- Apply linters properly
- Edit entity class to actually apply to this frontend's logic
- Produce launchdescription using base parser
- It can be launched with ros2 launch! at least for one simple example

Author: emersonknapp

.gitignore

@@ -0,0 +1 @@
+__pycache__/

launch_py/__init__.py

@@ -12,21 +12,41 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from launch import LaunchDescription
+import importlib
+from typing import Any, List
+
 from launch.frontend.expose import action_parse_methods
+from launch.frontend.parser import Parser
+from launch.launch_description import LaunchDescription
+
+from .entity import Entity
+
+
+def launch(actions: List[Entity]) -> LaunchDescription:
+    parser = Parser()
+    root_entity = Entity('launch', {'children': actions})
+    return parser.parse_description(root_entity)
 
-launch = LaunchDescription
 
 def make_action(action_name):
-    def impl():
-        return f'Action: {action_name}'
+    def impl(**kwargs):
+        return Entity(action_name, kwargs)
     globals()[action_name] = impl
     return impl
 
+
 exposed_actions = [
     make_action(key) for key in action_parse_methods.keys()
 ]
 
 __all__ = [
     'launch',
 ] + exposed_actions
+
+
+def __getattr__(name: str) -> Any:
+    # This is a workaround to silence mypy complaint about attributes that are created dynamically
+    try:
+        return importlib.import_module(f'.{name}', __name__)
+    except ModuleNotFoundError as e:
+        raise AttributeError(f'module {__name__} has no attribute {name}') from e

launch_py/entity.py

@@ -13,35 +13,39 @@
 # limitations under the License.
 
 """Module for launch_py Entity class."""
+from typing import (
+    List,
+    Optional,
+    Set,
+    Text,
+    Union,
+)
 
-from typing import List
-from typing import Optional
-from typing import Text
-from typing import Union
-
-from launch.frontend import Entity as BaseEntity
+from launch.frontend.entity import Entity as BaseEntity
 from launch.frontend.type_utils import check_is_list_entity
-from launch.utilities.type_utils import AllowedTypesType
-from launch.utilities.type_utils import AllowedValueType
-from launch.utilities.type_utils import is_instance_of
+from launch.utilities.type_utils import (
+    AllowedTypesType,
+    AllowedValueType,
+    is_instance_of,
+)
 
 
 class Entity(BaseEntity):
-    """Single item in the intermediate YAML front_end representation."""
+    """Single item in the intermediate front_end representation."""
 
     def __init__(
-        self,
-        element: dict,
-        type_name: Text = None,
-        *,
-        parent: 'Entity' = None
-    ) -> Text:
+            self,
+            type_name: Text,
+            kwargs: dict,
+            *,
+            parent: Optional['Entity'] = None,
+    ) -> None:
         """Create an Entity."""
         self.__type_name = type_name
-        self.__element = element
+        self.__kwargs = kwargs
         self.__parent = parent
-        self.__read_keys = set()
         self.__children_called = False
+        self.__read_keys: Set[Text] = set()
 
     @property
     def type_name(self) -> Text:
@@ -54,48 +58,31 @@ def parent(self) -> Optional['Entity']:
         return self.__parent
 
     @property
-    def children(self) -> List['Entity']:
+    def children(self) -> List[BaseEntity]:
         """Get the Entity's children."""
         self.__children_called = True
-        if not isinstance(self.__element, (dict, list)):
+        if not isinstance(self.__kwargs, (dict)):
             raise TypeError(
-                f'Expected a dict or list, got {type(self.element)}:'
-                f'\n---\n{self.__element}\n---'
+                f'Expected a dict, got {type(self.__kwargs)}:'
+                f'\n---\n{self.__kwargs}\n---'
             )
-        if isinstance(self.__element, dict):
-            if 'children' not in self.__element:
-                raise ValueError(
-                    f'Expected entity `{self.__type_name}` to have children entities.'
-                    f'That can be a list of subentities or a dictionary with a `children` '
-                    'list element')
-            self.__read_keys.add('children')
-            children = self.__element['children']
-        else:
-            children = self.__element
-        entities = []
-        for child in children:
-            if len(child) != 1:
-                raise RuntimeError(
-                    'Subentities must be a dictionary with only one key'
-                    ', which is the entity type')
-            type_name = list(child.keys())[0]
-            entities.append(Entity(child[type_name], type_name))
-        return entities
+
+        if 'children' not in self.__kwargs:
+            raise ValueError(
+                f'Expected entity `{self.__type_name}` to have children entities.')
+        self.__read_keys.add('children')
+
+        children: List[BaseEntity] = self.__kwargs['children']
+        return children
 
     def assert_entity_completely_parsed(self):
-        if isinstance(self.__element, list):
-            if not self.__children_called:
-                raise ValueError(
-                    f'Unexpected nested entity(ies) found in `{self.__type_name}`: '
-                    f'{self.__element}')
-            return
-        unparsed_keys = set(self.__element.keys()) - self.__read_keys
+        unparsed_keys = set(self.__kwargs.keys()) - self.__read_keys
         if unparsed_keys:
             raise ValueError(
                 f'Unexpected key(s) found in `{self.__type_name}`: {unparsed_keys}'
             )
 
-    def get_attr(
+    def get_attr(  # type: ignore[override]
         self,
         name: Text,
         *,
@@ -113,18 +100,18 @@ def get_attr(
         `launch_yaml` does not apply type coercion,
         it only checks if the read value is of the correct type.
         """
-        if name not in self.__element:
+        if name not in self.__kwargs:
             if not optional:
                 raise AttributeError(
                     "Can not find attribute '{}' in Entity '{}'".format(
                         name, self.type_name))
             else:
                 return None
         self.__read_keys.add(name)
-        data = self.__element[name]
+        data = self.__kwargs[name]
         if check_is_list_entity(data_type):
             if isinstance(data, list) and isinstance(data[0], dict):
-                return [Entity(child, name) for child in data]
+                return [Entity(name, child) for child in data]
             raise TypeError(
                 "Attribute '{}' of Entity '{}' expected to be a list of dictionaries.".format(
                     name, self.type_name
@@ -137,3 +124,7 @@ def get_attr(
                 )
             )
         return data
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Entity."""
+        return f'Entity(type_name={self.__type_name}, kwargs={self.__kwargs})'

launch_py/mypy.ini

@@ -0,0 +1,2 @@
+[mypy-launch_py]
+disable_error_code = attr-defined

package.xml

@@ -14,11 +14,9 @@
   <depend>launch</depend>
 
   <test_depend>ament_copyright</test_depend>
-  <test_depend>ament_flake8</test_depend>
-  <test_depend>ament_pep257</test_depend>
-  <test_depend>ament_mypy</test_depend>
   <test_depend>ament_lint_auto</test_depend>
-  <test_depend>ament_xmllint</test_depend>
+  <test_depend>ament_lint_common</test_depend>
+  <test_depend>ament_cmake_mypy</test_depend>
   <test_depend>python3-pytest</test_depend>
 
   <member_of_group>launch_frontend_packages</member_of_group>

test/basic_launch.py

@@ -0,0 +1,20 @@
+# Copyright 2025 Polymath Robotics, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from launch_py import executable, launch
+
+
+def generate_launch_description():
+    return launch([
+        executable(cmd='echo hello launch_py world!', output='screen')
+    ])