Preload launch extensions so there is no caveat about e.g. launch_ros

Signed-off-by: Emerson Knapp <[email protected]>

Author: emersonknapp

launch_frontend_py/__init__.py

@@ -12,31 +12,87 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, List
+from typing import Any, Callable, List
 
 from launch.frontend.parser import Parser
 from launch.launch_description import LaunchDescription
 
-from . import actions
-from .entity import Entity
+from .entity import Entity, make_valid_name
+
+__all__ = [
+    'launch',
+]
 
 
 def launch(actions: List[Entity]) -> LaunchDescription:
+    """Entrypoint of the launchfile, produces a LaunchDescription containing the listed entities."""
     parser = Parser()
     root_entity = Entity('launch', children=actions)
     return parser.parse_description(root_entity)
 
 
+def __make_action_factory(action_name: str) -> Callable[..., Any]:
+    """Create a factory function that constructs an Entity of the given action type."""
+    action_name = make_valid_name(action_name)
+
+    def fn(*args, **kwargs):
+        return Entity(action_name, *args, **kwargs)
+
+    fn.__doc__ = f'launch_frontend_py action: {action_name} (dynamically generated)'
+    fn.__name__ = action_name
+    fn.__qualname__ = action_name
+    fn.__module__ = __name__
+    globals()[action_name] = fn
+    __all__.append(action_name)
+    return fn
+
+
 def __getattr__(name: str) -> Any:
-    """Forward attribute access to the dynamic actions module."""
+    """
+    Dynamically create action factory functions on demand.
+
+    This is called in `from actions import <name>`, `getattr(actions, <name>)`, or `actions.<name>`
+    """
     import importlib
+    from launch.frontend import Parser
+    from launch.frontend.expose import action_parse_methods
 
     if name in __all__:
+        # It's already been loaded, just return it
         return importlib.import_module(f'.{name}', __name__)
 
-    return getattr(actions, name)
+    # Not loaded here yet, perhaps in an extension that wasn't imported yet
+    Parser.load_launch_extensions()
 
+    if name in action_parse_methods:
+        return __make_action_factory(name)
+    elif name.endswith('_'):
+        # The name has a trailing underscore, which we add to actions with reserved Python names
+        # Try again without the underscore
+        __getattr__(name[:-1])
+    else:
+        # It's not registered, raise the usual error
+        msg = f'module {__name__} has no attribute "{name}"'
+        if base_name != name:
+            msg += ' (or "{base_name}")'
+        raise AttributeError(msg)
 
-__all__ = [
-    'launch',
-]
+
+def __preseed_all_actions() -> None:
+    """
+    Pre-seed all available actions into this module.
+
+    This preloads all launch extensions and fills __all__ with available actions.
+
+    This is not necessary, since __getattr__ loads actions on demand,
+    but it allows tools and users to see all available actions in __all__.
+    """
+    from launch.frontend.expose import action_parse_methods
+    from launch.frontend import Parser
+    Parser.load_launch_extensions()
+
+    action_names = list(action_parse_methods.keys())
+    for action_name in action_names:
+        __getattr__(action_name)
+
+__preseed_all_actions()

launch_frontend_py/actions.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 
 """Module for launch_frontend_py Entity class."""
+import builtins
+import keyword
 from collections.abc import Iterable
 from typing import (
     List,
@@ -30,7 +32,26 @@
     is_instance_of,
 )
 
-from .util import is_reserved_identifier
+
+def is_reserved_identifier(name: str) -> bool:
+    """
+    Check if a name is a reserved identifier in Python.
+
+    Used to avoid naming issues in the launch DSL that overlap with Python reserved words.
+    """
+    return keyword.iskeyword(name) or name in dir(builtins)
+
+
+def make_valid_name(name: str) -> str:
+    """
+    Make a valid Python identifier for an action or attribute name.
+
+    If the name is a reserved identifier in Python, append an underscore to it.
+    """
+    if is_reserved_identifier(name):
+        return f'{name}_'
+    return name
+
 
 
 class Entity(BaseEntity):
@@ -108,9 +129,7 @@ def get_attr(  # type: ignore[override]
         See :py:meth:`launch.frontend.Entity.get_attr`.
         Does not apply type coercion, only checks if the read value is of the correct type.
         """
-        # Reserved identifiers are all suffixed with an underscore
-        if is_reserved_identifier(name):
-            name += '_'
+        name = make_valid_name(name)
 
         if name not in self.__attrs:
             if not optional: