From 03c79ae929eee23df007f7e97323c05dc23a2bd8 Mon Sep 17 00:00:00 2001
From: SuperJappie08 <36795178+SuperJappie08@users.noreply.github.com>
Date: Mon, 17 Mar 2025 15:15:23 +0100
Subject: [PATCH 1/4] Initial implementation of ScopedIncludeLaunchDescription

Signed-off-by: SuperJappie08 <36795178+SuperJappie08@users.noreply.github.com>
---
 launch/launch/actions/__init__.py             |   2 +
 .../include_scoped_launch_description.py      | 131 ++++++++++++++++++
 .../test_include_scoped_launch_description.py |  38 +++++
 3 files changed, 171 insertions(+)
 create mode 100644 launch/launch/actions/include_scoped_launch_description.py
 create mode 100644 launch/test/launch/actions/test_include_scoped_launch_description.py

diff --git a/launch/launch/actions/__init__.py b/launch/launch/actions/__init__.py
index 86d0bd9dd..65f773b13 100644
--- a/launch/launch/actions/__init__.py
+++ b/launch/launch/actions/__init__.py
@@ -23,6 +23,7 @@
 from .for_loop import ForLoop
 from .group_action import GroupAction
 from .include_launch_description import IncludeLaunchDescription
+from .include_scoped_launch_description import ScopedIncludeLaunchDescription
 from .log_info import LogInfo
 from .opaque_coroutine import OpaqueCoroutine
 from .opaque_function import OpaqueFunction
@@ -51,6 +52,7 @@
     'ForLoop',
     'GroupAction',
     'IncludeLaunchDescription',
+    'ScopedIncludeLaunchDescription',
     'LogInfo',
     'OpaqueCoroutine',
     'OpaqueFunction',
diff --git a/launch/launch/actions/include_scoped_launch_description.py b/launch/launch/actions/include_scoped_launch_description.py
new file mode 100644
index 000000000..eaf00226d
--- /dev/null
+++ b/launch/launch/actions/include_scoped_launch_description.py
@@ -0,0 +1,131 @@
+# Copyright 2025 Open Source Robotics Foundation, 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.
+
+"""Module for the ScopedIncludeLaunchDescription action."""
+
+# from typing import override # Available starting from Python3.12
+from typing import List
+from typing import Text
+# from itertools import zip_longest
+
+from .include_launch_description import IncludeLaunchDescription
+from .pop_environment import PopEnvironment
+from .pop_launch_configurations import PopLaunchConfigurations
+from .push_environment import PushEnvironment
+from .push_launch_configurations import PushLaunchConfigurations
+from .reset_environment import ResetEnvironment
+from .reset_launch_configurations import ResetLaunchConfigurations
+from .set_launch_configuration import SetLaunchConfiguration
+from ..frontend import expose_action
+from ..launch_context import LaunchContext
+from ..launch_description_entity import LaunchDescriptionEntity
+from ..utilities import normalize_to_list_of_substitutions
+from ..utilities import perform_substitutions
+
+
+@expose_action('scoped_include')
+class ScopedIncludeLaunchDescription(IncludeLaunchDescription):
+    # TODO(SuperJappie08) Propper Documentation
+
+    # NOTE(SuperJappie08) __init__ is not required since the function signature will be the same
+    # However maybe it is interresting for documentation purposes
+
+    def get_sub_entities(self):
+        """Get subentities."""
+        ret = super().get_sub_entities()
+        # TODO(SuperJappie08)? Do these internals need to be hidden?
+        return [
+            PushLaunchConfigurations(),
+            PushEnvironment(),
+            ResetEnvironment(),
+            # NOTE(SuperJappie08) Need weird remap, since AnySubstitution type can be a List which
+            #   is not Hashable.
+            ResetLaunchConfigurations({k[0]: v for k, v in self.launch_arguments})
+            * ret,
+            PopEnvironment(),
+            PopLaunchConfigurations(),
+        ]
+
+    def execute(self, context: LaunchContext) -> List[LaunchDescriptionEntity]:
+        """Execute the action."""
+        # NOTE(SuperJappie08) Originally this returend something based on the used actions
+        #   However after further consideration the context might not be correct that way.
+        context._push_launch_configurations()
+        context._push_environment()
+
+        context._reset_environment()
+
+        # Reset Launch Configuration
+        evaluated_configurations = {}
+        for k, v in self.launch_arguments:
+            evaluated_k = perform_substitutions(context, normalize_to_list_of_substitutions(k))
+            evaluated_v = perform_substitutions(context, normalize_to_list_of_substitutions(v))
+            evaluated_configurations[evaluated_k] = evaluated_v
+
+        context.launch_configurations.clear()
+        context.launch_configurations.update(evaluated_configurations)
+
+        launch_description = self.launch_description_source.get_launch_description(context)
+
+        # If the location does not exist, then it's likely set to '<script>' or something.
+        context.extend_locals({
+            'current_launch_file_path': self._get_launch_file(),
+        })
+        context.extend_locals({
+            'current_launch_file_directory': self._get_launch_file_directory(),
+        })
+
+        # Do best effort checking to see if non-optional, non-default declared arguments
+        # are being satisfied.
+        my_argument_names = [
+            perform_substitutions(context, normalize_to_list_of_substitutions(arg_name))
+            for arg_name, arg_value in self.launch_arguments
+        ]
+        try:
+            declared_launch_arguments = (
+                launch_description.get_launch_arguments_with_include_launch_description_actions())
+        except Exception as exc:
+            if hasattr(exc, 'add_note'):
+                exc.add_note(f'while executing {self.describe()}')  # type: ignore
+            raise
+        for argument, ild_actions in declared_launch_arguments:
+            if argument._conditionally_included or argument.default_value is not None:
+                continue
+            argument_names = my_argument_names
+            if ild_actions is not None:
+                for ild_action in ild_actions:
+                    argument_names.extend(ild_action._try_get_arguments_names_without_context())
+            if argument.name not in argument_names:
+                raise RuntimeError(
+                    "Included launch description missing required argument '{}' "
+                    "(description: '{}'), given: [{}]"
+                    .format(argument.name, argument.description, ', '.join(argument_names))
+                )
+
+        # Create actions to set the launch arguments into the launch configurations.
+        set_launch_configuration_actions = []
+        for name, value in self.launch_arguments:
+            set_launch_configuration_actions.append(SetLaunchConfiguration(name, value))
+
+        # Set launch arguments as launch configurations and then include the launch description.
+        return [
+            *set_launch_configuration_actions,
+            launch_description,
+            PopEnvironment(),
+            PopLaunchConfigurations(),
+        ]
+
+    def __repr__(self) -> Text:
+        """Return a description of this ScopedIncludeLaunchDescription as a string."""
+        return f'ScopedIncludeLaunchDescription({self.launch_description_source.location})'
diff --git a/launch/test/launch/actions/test_include_scoped_launch_description.py b/launch/test/launch/actions/test_include_scoped_launch_description.py
new file mode 100644
index 000000000..00529ece6
--- /dev/null
+++ b/launch/test/launch/actions/test_include_scoped_launch_description.py
@@ -0,0 +1,38 @@
+# Copyright 2025 Open Source Robotics Foundation, 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.
+
+"""Tests for the IncludeScopedLaunchDescription action class."""
+
+# from launch import LaunchContext
+from launch import LaunchDescription
+from launch import LaunchDescriptionSource
+# from launch import LaunchService
+from launch.actions import IncludeScopedLaunchDescription
+
+# import pytest
+
+
+def test_include_launch_description_constructors():
+    """Test the constructors for IncludeLaunchDescription class."""
+    IncludeScopedLaunchDescription(LaunchDescriptionSource(LaunchDescription()))
+    IncludeScopedLaunchDescription(
+        LaunchDescriptionSource(LaunchDescription()),
+        launch_arguments={'foo': 'FOO'}.items())
+
+
+def test_correct_scoping():
+    """Test for verifying scoping behavior."""
+    NotImplemented()
+
+# TODO(SuperJappie08) Add tests to verify behavior

From 6220d1bc83cce1675c51176b0d502024efdb81b1 Mon Sep 17 00:00:00 2001
From: SuperJappie08 <36795178+SuperJappie08@users.noreply.github.com>
Date: Thu, 1 May 2025 11:08:53 +0200
Subject: [PATCH 2/4] Uncommitted test patches, before rework

Signed-off-by: SuperJappie08 <36795178+SuperJappie08@users.noreply.github.com>
---
 .../include_scoped_launch_description.py      |  37 +++++-
 .../test_include_scoped_launch_description.py | 114 ++++++++++++++++--
 2 files changed, 137 insertions(+), 14 deletions(-)

diff --git a/launch/launch/actions/include_scoped_launch_description.py b/launch/launch/actions/include_scoped_launch_description.py
index eaf00226d..d08a014f0 100644
--- a/launch/launch/actions/include_scoped_launch_description.py
+++ b/launch/launch/actions/include_scoped_launch_description.py
@@ -17,7 +17,6 @@
 # from typing import override # Available starting from Python3.12
 from typing import List
 from typing import Text
-# from itertools import zip_longest
 
 from .include_launch_description import IncludeLaunchDescription
 from .pop_environment import PopEnvironment
@@ -43,22 +42,52 @@ class ScopedIncludeLaunchDescription(IncludeLaunchDescription):
 
     def get_sub_entities(self):
         """Get subentities."""
-        ret = super().get_sub_entities()
+        # ret = super().get_sub_entities()
         # TODO(SuperJappie08)? Do these internals need to be hidden?
+        # print(self.launch_arguments)
         return [
             PushLaunchConfigurations(),
             PushEnvironment(),
             ResetEnvironment(),
             # NOTE(SuperJappie08) Need weird remap, since AnySubstitution type can be a List which
             #   is not Hashable.
-            ResetLaunchConfigurations({k[0]: v for k, v in self.launch_arguments})
-            * ret,
+            # ResetLaunchConfigurations({k: v for k, v in self.launch_arguments}),
+            # *ret,
+            ResetLaunchConfigurations(),
+            *[SetLaunchConfiguration(k, v) for k, v in self.launch_arguments],
+            *super().get_sub_entities(),
             PopEnvironment(),
             PopLaunchConfigurations(),
         ]
 
     def execute(self, context: LaunchContext) -> List[LaunchDescriptionEntity]:
         """Execute the action."""
+        # FIXME(SuperJappie08): Temporary Test to see if behavior works out
+
+        # print(self.launch_description_source.get_launch_description(context).entities)
+        # FIXME(SuperJappie08): This breaks the PushRosNameSpace Action (Cannot push a namespace in)
+
+        evaluated_configurations = {}
+        for k, v in self.launch_arguments:
+            evaluated_k = perform_substitutions(context, normalize_to_list_of_substitutions(k))
+            evaluated_v = perform_substitutions(context, normalize_to_list_of_substitutions(v))
+            evaluated_configurations[evaluated_k] = evaluated_v
+
+        return [
+            PushLaunchConfigurations(),
+            PushEnvironment(),
+            ResetEnvironment(),
+            ResetLaunchConfigurations(evaluated_configurations),
+            # Does this reset do anything?
+            # ResetLaunchConfigurations(evaluated_configurations),
+            # *super().execute(context),
+            IncludeLaunchDescription(
+                                     launch_description_source=self.launch_description_source,
+                                     launch_arguments=self.launch_arguments,
+                                     condition=self.condition),
+            PopEnvironment(),
+            PopLaunchConfigurations()
+        ]
         # NOTE(SuperJappie08) Originally this returend something based on the used actions
         #   However after further consideration the context might not be correct that way.
         context._push_launch_configurations()
diff --git a/launch/test/launch/actions/test_include_scoped_launch_description.py b/launch/test/launch/actions/test_include_scoped_launch_description.py
index 00529ece6..9d855d447 100644
--- a/launch/test/launch/actions/test_include_scoped_launch_description.py
+++ b/launch/test/launch/actions/test_include_scoped_launch_description.py
@@ -12,27 +12,121 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Tests for the IncludeScopedLaunchDescription action class."""
+"""Tests for the ScopedIncludeLaunchDescription action class."""
 
-# from launch import LaunchContext
+import os
+
+from launch import LaunchContext
 from launch import LaunchDescription
 from launch import LaunchDescriptionSource
 # from launch import LaunchService
-from launch.actions import IncludeScopedLaunchDescription
+from launch.actions import DeclareLaunchArgument
+from launch.actions import PopEnvironment, PopLaunchConfigurations
+from launch.actions import PushEnvironment, PushLaunchConfigurations
+from launch.actions import ResetEnvironment, ResetLaunchConfigurations
+from launch.actions import ScopedIncludeLaunchDescription
 
-# import pytest
+import pytest
 
 
 def test_include_launch_description_constructors():
-    """Test the constructors for IncludeLaunchDescription class."""
-    IncludeScopedLaunchDescription(LaunchDescriptionSource(LaunchDescription()))
-    IncludeScopedLaunchDescription(
+    """Test the constructors for ScopedIncludeLaunchDescription class."""
+    ScopedIncludeLaunchDescription(LaunchDescriptionSource(LaunchDescription()))
+    ScopedIncludeLaunchDescription(
         LaunchDescriptionSource(LaunchDescription()),
         launch_arguments={'foo': 'FOO'}.items())
 
 
-def test_correct_scoping():
-    """Test for verifying scoping behavior."""
-    NotImplemented()
+# TODO(SuperJappie08) Is this test necessary, my idea was check if filelocation does not leak
+@pytest.mark.skip(reason='Not finished')
+def test_scoped_include_launch_description_launch_file_location():
+    """Test the ability of ScopedIncludeLaunchDescription to set the launch file location."""
+    ld = LaunchDescription()
+    action = ScopedIncludeLaunchDescription(LaunchDescriptionSource(ld, '<script>'))
+    assert 'ScopedIncludeLaunchDescription' in action.describe()
+    assert isinstance(action.describe_sub_entities(), list)
+    assert isinstance(action.describe_conditional_sub_entities(), list)
+    lc1 = LaunchContext()
+    # Result should only contain the launch description as there are no launch arguments.
+    assert action.visit(lc1) == [ld]
+    assert lc1.locals.current_launch_file_directory == '<script>'
+    assert action.get_asyncio_future() is None
+
+    this_file = os.path.abspath(__file__)
+    ld2 = LaunchDescription()
+    action2 = ScopedIncludeLaunchDescription(LaunchDescriptionSource(ld2, this_file))
+    assert 'ScopedIncludeLaunchDescription' in action2.describe()
+    assert isinstance(action2.describe_sub_entities(), list)
+    assert isinstance(action2.describe_conditional_sub_entities(), list)
+    lc2 = LaunchContext()
+    # Result should only contain the launch description as there are no launch arguments.
+    assert action2.visit(lc2) == [ld2]
+    assert lc2.locals.current_launch_file_directory == os.path.dirname(this_file)
+    assert action2.get_asyncio_future() is None
+
+
+def test_scoped_include_launch_description_scoping():
+    """Test for verifying scoping behavior of ScopedIncludeLaunchDescription."""
+    ld_empty = LaunchDescription()
+    action = ScopedIncludeLaunchDescription(LaunchDescriptionSource(ld_empty, '<script>'))
+    assert 'ScopedIncludeLaunchDescription' in action.describe()
+
+    # Verify the sub entity list
+    sub_entities = action.describe_sub_entities()
+    assert isinstance(sub_entities, list)
+    assert len(sub_entities) == 7
+    assert isinstance(sub_entities[0], PushLaunchConfigurations)
+    assert isinstance(sub_entities[1], PushEnvironment)
+    assert isinstance(sub_entities[2], ResetEnvironment)
+    assert isinstance(sub_entities[3], ResetLaunchConfigurations)
+    assert sub_entities[3]._ResetLaunchConfigurations__launch_configurations == {}
+    assert isinstance(sub_entities[4], LaunchDescription)
+    assert sub_entities[4] == ld_empty
+    assert isinstance(sub_entities[5], PopEnvironment)
+    assert isinstance(sub_entities[6], PopLaunchConfigurations)
+
+    assert isinstance(action.describe_conditional_sub_entities(), list)
+    lc1 = LaunchContext()
+
+    # Empty inner into Empty outer
+    # TODO(SuperJappie08): Update Comment
+    # Result should only contain the launch description as there are no launch arguments.
+
+    # lc1_pre_env = list(lc1.environment.items())
+    # assert list(lc1.environment.items()) == lc1_pre_env
+    res1 = action.visit(lc1)
+    assert len(res1) == 3
+
+    assert isinstance(res1[0], LaunchDescription)
+    assert res1[0] == ld_empty
+    assert res1[0].get_launch_arguments_with_include_launch_description_actions() == []
+
+    assert isinstance(res1[1], PopEnvironment)
+    assert isinstance(res1[2], PopLaunchConfigurations)
+
+    # Non Empty Inner into empty outer
+    inner_declare_argument = DeclareLaunchArgument('some_name', default_value='some_value')
+    ld_non_empty = LaunchDescription([inner_declare_argument])
+    action = ScopedIncludeLaunchDescription(LaunchDescriptionSource(ld_non_empty, '<script>'))
+    assert 'ScopedIncludeLaunchDescription' in action.describe()
+
+    # Verify the sub entity list
+    sub_entities = action.describe_sub_entities()
+    assert isinstance(sub_entities, list)
+    assert len(sub_entities) == 7
+    assert isinstance(sub_entities[0], PushLaunchConfigurations)
+    assert isinstance(sub_entities[1], PushEnvironment)
+    assert isinstance(sub_entities[2], ResetEnvironment)
+    assert isinstance(sub_entities[3], ResetLaunchConfigurations)
+    assert sub_entities[3]._ResetLaunchConfigurations__launch_configurations == {}
+    assert isinstance(sub_entities[4], LaunchDescription)
+    assert sub_entities[4] == ld_non_empty
+    assert isinstance(sub_entities[5], PopEnvironment)
+    assert isinstance(sub_entities[6], PopLaunchConfigurations)
+
+    assert isinstance(action.describe_conditional_sub_entities(), list)
+
+    lc2 = LaunchContext()
+    # TODO: Finish NotImplemented()
 
 # TODO(SuperJappie08) Add tests to verify behavior

From 472c5333f6714bb8e527367210b5db1a92613848 Mon Sep 17 00:00:00 2001
From: SuperJappie08 <36795178+SuperJappie08@users.noreply.github.com>
Date: Thu, 1 May 2025 14:27:42 +0200
Subject: [PATCH 3/4] Add global launch configuration protection set

Added a 'globals' launch configuration protection set, so things which
should not be scoped (such as `launch_ros` `PushRosNamespace`) can be
registered.

Signed-off-by: SuperJappie08 <36795178+SuperJappie08@users.noreply.github.com>
---
 launch/launch/actions/__init__.py             | 10 +++-
 .../include_scoped_launch_description.py      | 14 +++--
 .../register_global_launch_configuration.py   | 59 +++++++++++++++++++
 .../set_global_launch_configuration.py        | 47 +++++++++++++++
 .../unregister_global_launch_configuration.py | 53 +++++++++++++++++
 launch/launch/utilities/__init__.py           |  3 +
 .../utilities/global_launch_configurations.py | 39 ++++++++++++
 7 files changed, 219 insertions(+), 6 deletions(-)
 create mode 100644 launch/launch/actions/register_global_launch_configuration.py
 create mode 100644 launch/launch/actions/set_global_launch_configuration.py
 create mode 100644 launch/launch/actions/unregister_global_launch_configuration.py
 create mode 100644 launch/launch/utilities/global_launch_configurations.py

diff --git a/launch/launch/actions/__init__.py b/launch/launch/actions/__init__.py
index 65f773b13..13a79442f 100644
--- a/launch/launch/actions/__init__.py
+++ b/launch/launch/actions/__init__.py
@@ -32,13 +32,16 @@
 from .push_environment import PushEnvironment
 from .push_launch_configurations import PushLaunchConfigurations
 from .register_event_handler import RegisterEventHandler
+from .register_global_launch_configuration import RegisterGlobalLaunchConfiguration
 from .reset_environment import ResetEnvironment
 from .reset_launch_configurations import ResetLaunchConfigurations
 from .set_environment_variable import SetEnvironmentVariable
+from .set_global_launch_configuration import SetGlobalLaunchConfiguration
 from .set_launch_configuration import SetLaunchConfiguration
 from .shutdown_action import Shutdown
 from .timer_action import TimerAction
 from .unregister_event_handler import UnregisterEventHandler
+from .unregister_global_launch_configuration import UnregisterGlobalLaunchConfiguration
 from .unset_environment_variable import UnsetEnvironmentVariable
 from .unset_launch_configuration import UnsetLaunchConfiguration
 
@@ -52,7 +55,6 @@
     'ForLoop',
     'GroupAction',
     'IncludeLaunchDescription',
-    'ScopedIncludeLaunchDescription',
     'LogInfo',
     'OpaqueCoroutine',
     'OpaqueFunction',
@@ -60,14 +62,18 @@
     'PopLaunchConfigurations',
     'PushEnvironment',
     'PushLaunchConfigurations',
+    'RegisterEventHandler',
+    'RegisterGlobalLaunchConfiguration',
     'ResetEnvironment',
     'ResetLaunchConfigurations',
-    'RegisterEventHandler',
+    'ScopedIncludeLaunchDescription',
     'SetEnvironmentVariable',
+    'SetGlobalLaunchConfiguration',
     'SetLaunchConfiguration',
     'Shutdown',
     'TimerAction',
     'UnregisterEventHandler',
+    'UnregisterGlobalLaunchConfiguration',
     'UnsetEnvironmentVariable',
     'UnsetLaunchConfiguration',
 ]
diff --git a/launch/launch/actions/include_scoped_launch_description.py b/launch/launch/actions/include_scoped_launch_description.py
index d08a014f0..1005d1ec5 100644
--- a/launch/launch/actions/include_scoped_launch_description.py
+++ b/launch/launch/actions/include_scoped_launch_description.py
@@ -62,12 +62,18 @@ def get_sub_entities(self):
 
     def execute(self, context: LaunchContext) -> List[LaunchDescriptionEntity]:
         """Execute the action."""
-        # FIXME(SuperJappie08): Temporary Test to see if behavior works out
+        evaluated_configurations = {}
 
-        # print(self.launch_description_source.get_launch_description(context).entities)
-        # FIXME(SuperJappie08): This breaks the PushRosNameSpace Action (Cannot push a namespace in)
+        for name in getattr(context.locals, 'globals', set()):
+            expanded_name = perform_substitutions(
+                context,
+                normalize_to_list_of_substitutions(name)
+            )
+
+            if expanded_name in context.launch_configurations:
+                evaluated_configurations[expanded_name] = \
+                    context.launch_configurations[expanded_name]
 
-        evaluated_configurations = {}
         for k, v in self.launch_arguments:
             evaluated_k = perform_substitutions(context, normalize_to_list_of_substitutions(k))
             evaluated_v = perform_substitutions(context, normalize_to_list_of_substitutions(v))
diff --git a/launch/launch/actions/register_global_launch_configuration.py b/launch/launch/actions/register_global_launch_configuration.py
new file mode 100644
index 000000000..15247b629
--- /dev/null
+++ b/launch/launch/actions/register_global_launch_configuration.py
@@ -0,0 +1,59 @@
+# Copyright 2025 Open Source Robotics Foundation, 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.
+
+"""Module for the RegisterGlobalLaunchConfiguration."""
+
+from typing import List
+
+from ..action import Action
+from ..frontend import Entity
+from ..frontend import expose_action
+from ..frontend import Parser
+from ..launch_context import LaunchContext
+from ..some_substitutions_type import SomeSubstitutionsType
+from ..substitution import Substitution
+from ..utilities import normalize_to_list_of_substitutions
+from ..utilities import register_global
+
+
+@expose_action('register-global')
+@expose_action('register_global')
+class RegisterGlobalLaunchConfiguration(Action):
+    """
+    Action that add a launch configuration to the globals set by name.
+
+    This allows the configuration to be overscoped when including a scoped launch description.
+    """
+
+    def __init__(self, name: SomeSubstitutionsType, **kwargs) -> None:
+        """Create a RegisterGlobalLaunchConfiguration action."""
+        super().__init__(**kwargs)
+        self.__name = normalize_to_list_of_substitutions(name)
+
+    @classmethod
+    def parse(cls, entity: Entity, parser: Parser):
+        """Return `RegisterGlobalLaunchConfiguration` action and kwargs for constructing it."""
+        name = parser.parse_substitution(entity.get_attr('name'))
+        _, kwargs = super().parse(entity, parser)
+        kwargs['name'] = name
+        return cls, kwargs
+
+    @property
+    def name(self) -> List[Substitution]:
+        """Getter for self.__name."""
+        return self.__name
+
+    def execute(self, context: LaunchContext):
+        """Execute the action."""
+        register_global(context, self.name)
diff --git a/launch/launch/actions/set_global_launch_configuration.py b/launch/launch/actions/set_global_launch_configuration.py
new file mode 100644
index 000000000..00966eba9
--- /dev/null
+++ b/launch/launch/actions/set_global_launch_configuration.py
@@ -0,0 +1,47 @@
+# Copyright 2025 Open Source Robotics Foundation, 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.
+
+"""Module for the SetGlobalLaunchConfiguration action."""
+
+from .set_launch_configuration import SetLaunchConfiguration
+from ..frontend import expose_action
+from ..launch_context import LaunchContext
+from ..utilities import register_global
+
+
+@expose_action('global')
+class SetGlobalLaunchConfiguration(SetLaunchConfiguration):
+    """
+    Action that sets a global launch configuration by name.
+
+    Launch configurations can be accessed by the LaunchConfiguration
+    substitution and are accessible after being set, even in included
+    LaunchDescription's, but can be scoped with groups.
+
+    A global launch configuration is registered in the globals group
+    to allow to in scoped included launch descriptions.
+    """
+
+    def __init__(
+        self,
+        **kwargs
+    ) -> None:
+        """Create a SetGlobalLaunchConfiguration action."""
+        super().__init__(**kwargs)
+
+    def execute(self, context: LaunchContext):
+        """Execute the action."""
+        register_global(context, self.name)
+
+        super().execute(context)
diff --git a/launch/launch/actions/unregister_global_launch_configuration.py b/launch/launch/actions/unregister_global_launch_configuration.py
new file mode 100644
index 000000000..d6573dad5
--- /dev/null
+++ b/launch/launch/actions/unregister_global_launch_configuration.py
@@ -0,0 +1,53 @@
+# Copyright 2025 Open Source Robotics Foundation, 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.
+
+"""Module for the UnregisterGlobalLaunchConfiguration."""
+
+from typing import List
+
+from ..action import Action
+from ..frontend import Entity
+from ..frontend import expose_action
+from ..frontend import Parser
+from ..launch_context import LaunchContext
+from ..some_substitutions_type import SomeSubstitutionsType
+from ..substitution import Substitution
+from ..utilities import normalize_to_list_of_substitutions
+from ..utilities import unregister_global
+
+
+@expose_action('unregister-global')
+@expose_action('unregister_global')
+class UnregisterGlobalLaunchConfiguration(Action):
+    def __init__(self, name: SomeSubstitutionsType, **kwargs) -> None:
+        """Create a UnregisterGlobalLaunchConfiguration action."""
+        super().__init__(**kwargs)
+        self.__name = normalize_to_list_of_substitutions(name)
+
+    @classmethod
+    def parse(cls, entity: Entity, parser: Parser):
+        """Return `UnregisterGlobalLaunchConfiguration` action and kwargs for constructing it."""
+        name = parser.parse_substitution(entity.get_attr('name'))
+        _, kwargs = super().parse(entity, parser)
+        kwargs['name'] = name
+        return cls, kwargs
+
+    @property
+    def name(self) -> List[Substitution]:
+        """Getter for self.__name."""
+        return self.__name
+
+    def execute(self, context: LaunchContext):
+        """Execute the action."""
+        unregister_global(context, self.name)
diff --git a/launch/launch/utilities/__init__.py b/launch/launch/utilities/__init__.py
index 7af96ef36..6dd23826b 100644
--- a/launch/launch/utilities/__init__.py
+++ b/launch/launch/utilities/__init__.py
@@ -16,6 +16,7 @@
 
 from .class_tools_impl import is_a, is_a_subclass, isclassinstance
 from .ensure_argument_type_impl import ensure_argument_type
+from .global_launch_configurations import register_global, unregister_global
 from .normalize_to_list_of_entities_impl import normalize_to_list_of_entities
 from .normalize_to_list_of_substitutions_impl import normalize_to_list_of_substitutions
 from .perform_substitutions_impl import perform_substitutions
@@ -32,4 +33,6 @@
     'normalize_to_list_of_substitutions',
     'normalize_to_list_of_entities',
     'visit_all_entities_and_collect_futures',
+    'register_global',
+    'unregister_global'
 ]
diff --git a/launch/launch/utilities/global_launch_configurations.py b/launch/launch/utilities/global_launch_configurations.py
new file mode 100644
index 000000000..f8ce707f2
--- /dev/null
+++ b/launch/launch/utilities/global_launch_configurations.py
@@ -0,0 +1,39 @@
+# Copyright 2025 Open Source Robotics Foundation, 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 typing import Set
+from typing import Text
+
+from .normalize_to_list_of_substitutions_impl import normalize_to_list_of_substitutions
+from .perform_substitutions_impl import perform_substitutions
+from ..launch_context import LaunchContext
+from ..some_substitutions_type import SomeSubstitutionsType
+
+
+def register_global(context: LaunchContext, name: SomeSubstitutionsType) -> None:
+    """
+    Register a launch configuration to the globals set.
+
+    This allows it to be accessible in when scoped including a launch description.
+    """
+    globals_set: Set[Text] = getattr(context.locals, 'globals', {'globals'})
+    globals_set.add(perform_substitutions(context, normalize_to_list_of_substitutions(name)))
+    context.extend_locals({'globals': globals_set})
+
+
+def unregister_global(context: LaunchContext, name: SomeSubstitutionsType) -> None:
+    """Unregisters a launch configuration to the globals set."""
+    globals_set: Set[Text] = getattr(context.locals, 'globals', {'globals'})
+    globals_set.discard(perform_substitutions(context, normalize_to_list_of_substitutions(name)))
+    context.extend_locals({'globals': globals_set})

From 6f3188af94658ab3ed13999d6f43386ba6e0dbc4 Mon Sep 17 00:00:00 2001
From: SuperJappie08 <36795178+SuperJappie08@users.noreply.github.com>
Date: Thu, 1 May 2025 21:06:52 +0200
Subject: [PATCH 4/4] Clean up and test corrections for scoped include

Signed-off-by: SuperJappie08 <36795178+SuperJappie08@users.noreply.github.com>
---
 .../include_scoped_launch_description.py      | 75 ++-----------------
 .../unregister_global_launch_configuration.py |  2 +
 .../test_include_scoped_launch_description.py | 35 +++++----
 3 files changed, 29 insertions(+), 83 deletions(-)

diff --git a/launch/launch/actions/include_scoped_launch_description.py b/launch/launch/actions/include_scoped_launch_description.py
index 1005d1ec5..defc5a705 100644
--- a/launch/launch/actions/include_scoped_launch_description.py
+++ b/launch/launch/actions/include_scoped_launch_description.py
@@ -15,6 +15,7 @@
 """Module for the ScopedIncludeLaunchDescription action."""
 
 # from typing import override # Available starting from Python3.12
+from typing import Dict
 from typing import List
 from typing import Text
 
@@ -29,6 +30,7 @@
 from ..frontend import expose_action
 from ..launch_context import LaunchContext
 from ..launch_description_entity import LaunchDescriptionEntity
+from ..some_substitutions_type import SomeSubstitutionsType
 from ..utilities import normalize_to_list_of_substitutions
 from ..utilities import perform_substitutions
 
@@ -62,7 +64,7 @@ def get_sub_entities(self):
 
     def execute(self, context: LaunchContext) -> List[LaunchDescriptionEntity]:
         """Execute the action."""
-        evaluated_configurations = {}
+        evaluated_configurations: Dict[SomeSubstitutionsType, SomeSubstitutionsType] = {}
 
         for name in getattr(context.locals, 'globals', set()):
             expanded_name = perform_substitutions(
@@ -75,6 +77,8 @@ def execute(self, context: LaunchContext) -> List[LaunchDescriptionEntity]:
                     context.launch_configurations[expanded_name]
 
         for k, v in self.launch_arguments:
+            # Perform substitutions, since the required launch configurations might not be
+            # available in the inner scope.
             evaluated_k = perform_substitutions(context, normalize_to_list_of_substitutions(k))
             evaluated_v = perform_substitutions(context, normalize_to_list_of_substitutions(v))
             evaluated_configurations[evaluated_k] = evaluated_v
@@ -84,9 +88,6 @@ def execute(self, context: LaunchContext) -> List[LaunchDescriptionEntity]:
             PushEnvironment(),
             ResetEnvironment(),
             ResetLaunchConfigurations(evaluated_configurations),
-            # Does this reset do anything?
-            # ResetLaunchConfigurations(evaluated_configurations),
-            # *super().execute(context),
             IncludeLaunchDescription(
                                      launch_description_source=self.launch_description_source,
                                      launch_arguments=self.launch_arguments,
@@ -94,72 +95,6 @@ def execute(self, context: LaunchContext) -> List[LaunchDescriptionEntity]:
             PopEnvironment(),
             PopLaunchConfigurations()
         ]
-        # NOTE(SuperJappie08) Originally this returend something based on the used actions
-        #   However after further consideration the context might not be correct that way.
-        context._push_launch_configurations()
-        context._push_environment()
-
-        context._reset_environment()
-
-        # Reset Launch Configuration
-        evaluated_configurations = {}
-        for k, v in self.launch_arguments:
-            evaluated_k = perform_substitutions(context, normalize_to_list_of_substitutions(k))
-            evaluated_v = perform_substitutions(context, normalize_to_list_of_substitutions(v))
-            evaluated_configurations[evaluated_k] = evaluated_v
-
-        context.launch_configurations.clear()
-        context.launch_configurations.update(evaluated_configurations)
-
-        launch_description = self.launch_description_source.get_launch_description(context)
-
-        # If the location does not exist, then it's likely set to '<script>' or something.
-        context.extend_locals({
-            'current_launch_file_path': self._get_launch_file(),
-        })
-        context.extend_locals({
-            'current_launch_file_directory': self._get_launch_file_directory(),
-        })
-
-        # Do best effort checking to see if non-optional, non-default declared arguments
-        # are being satisfied.
-        my_argument_names = [
-            perform_substitutions(context, normalize_to_list_of_substitutions(arg_name))
-            for arg_name, arg_value in self.launch_arguments
-        ]
-        try:
-            declared_launch_arguments = (
-                launch_description.get_launch_arguments_with_include_launch_description_actions())
-        except Exception as exc:
-            if hasattr(exc, 'add_note'):
-                exc.add_note(f'while executing {self.describe()}')  # type: ignore
-            raise
-        for argument, ild_actions in declared_launch_arguments:
-            if argument._conditionally_included or argument.default_value is not None:
-                continue
-            argument_names = my_argument_names
-            if ild_actions is not None:
-                for ild_action in ild_actions:
-                    argument_names.extend(ild_action._try_get_arguments_names_without_context())
-            if argument.name not in argument_names:
-                raise RuntimeError(
-                    "Included launch description missing required argument '{}' "
-                    "(description: '{}'), given: [{}]"
-                    .format(argument.name, argument.description, ', '.join(argument_names))
-                )
-
-        # Create actions to set the launch arguments into the launch configurations.
-        set_launch_configuration_actions = []
-        for name, value in self.launch_arguments:
-            set_launch_configuration_actions.append(SetLaunchConfiguration(name, value))
-
-        # Set launch arguments as launch configurations and then include the launch description.
-        return [
-            *set_launch_configuration_actions,
-            launch_description,
-            PopEnvironment(),
-            PopLaunchConfigurations(),
-        ]
 
     def __repr__(self) -> Text:
         """Return a description of this ScopedIncludeLaunchDescription as a string."""
diff --git a/launch/launch/actions/unregister_global_launch_configuration.py b/launch/launch/actions/unregister_global_launch_configuration.py
index d6573dad5..8e6bc9f80 100644
--- a/launch/launch/actions/unregister_global_launch_configuration.py
+++ b/launch/launch/actions/unregister_global_launch_configuration.py
@@ -30,6 +30,8 @@
 @expose_action('unregister-global')
 @expose_action('unregister_global')
 class UnregisterGlobalLaunchConfiguration(Action):
+    """Action that add a launch configuration to the globals set by name."""
+
     def __init__(self, name: SomeSubstitutionsType, **kwargs) -> None:
         """Create a UnregisterGlobalLaunchConfiguration action."""
         super().__init__(**kwargs)
diff --git a/launch/test/launch/actions/test_include_scoped_launch_description.py b/launch/test/launch/actions/test_include_scoped_launch_description.py
index 9d855d447..07df21f35 100644
--- a/launch/test/launch/actions/test_include_scoped_launch_description.py
+++ b/launch/test/launch/actions/test_include_scoped_launch_description.py
@@ -19,11 +19,14 @@
 from launch import LaunchContext
 from launch import LaunchDescription
 from launch import LaunchDescriptionSource
-# from launch import LaunchService
 from launch.actions import DeclareLaunchArgument
-from launch.actions import PopEnvironment, PopLaunchConfigurations
-from launch.actions import PushEnvironment, PushLaunchConfigurations
-from launch.actions import ResetEnvironment, ResetLaunchConfigurations
+from launch.actions import IncludeLaunchDescription
+from launch.actions import PopEnvironment
+from launch.actions import PopLaunchConfigurations
+from launch.actions import PushEnvironment
+from launch.actions import PushLaunchConfigurations
+from launch.actions import ResetEnvironment
+from launch.actions import ResetLaunchConfigurations
 from launch.actions import ScopedIncludeLaunchDescription
 
 import pytest
@@ -46,6 +49,7 @@ def test_scoped_include_launch_description_launch_file_location():
     assert 'ScopedIncludeLaunchDescription' in action.describe()
     assert isinstance(action.describe_sub_entities(), list)
     assert isinstance(action.describe_conditional_sub_entities(), list)
+
     lc1 = LaunchContext()
     # Result should only contain the launch description as there are no launch arguments.
     assert action.visit(lc1) == [ld]
@@ -79,7 +83,7 @@ def test_scoped_include_launch_description_scoping():
     assert isinstance(sub_entities[1], PushEnvironment)
     assert isinstance(sub_entities[2], ResetEnvironment)
     assert isinstance(sub_entities[3], ResetLaunchConfigurations)
-    assert sub_entities[3]._ResetLaunchConfigurations__launch_configurations == {}
+    assert sub_entities[3]._ResetLaunchConfigurations__launch_configurations is None
     assert isinstance(sub_entities[4], LaunchDescription)
     assert sub_entities[4] == ld_empty
     assert isinstance(sub_entities[5], PopEnvironment)
@@ -95,14 +99,19 @@ def test_scoped_include_launch_description_scoping():
     # lc1_pre_env = list(lc1.environment.items())
     # assert list(lc1.environment.items()) == lc1_pre_env
     res1 = action.visit(lc1)
-    assert len(res1) == 3
+    assert len(res1) == 7
 
-    assert isinstance(res1[0], LaunchDescription)
-    assert res1[0] == ld_empty
-    assert res1[0].get_launch_arguments_with_include_launch_description_actions() == []
+    assert isinstance(sub_entities[0], PushLaunchConfigurations)
+    assert isinstance(sub_entities[1], PushEnvironment)
+    assert isinstance(sub_entities[2], ResetEnvironment)
+    assert isinstance(sub_entities[3], ResetLaunchConfigurations)
+
+    assert isinstance(res1[4], IncludeLaunchDescription)
+    assert res1[4].describe_sub_entities() == [ld_empty]
+    # assert res1[4].get_launch_arguments_with_include_launch_description_actions() == []
 
-    assert isinstance(res1[1], PopEnvironment)
-    assert isinstance(res1[2], PopLaunchConfigurations)
+    assert isinstance(res1[5], PopEnvironment)
+    assert isinstance(res1[6], PopLaunchConfigurations)
 
     # Non Empty Inner into empty outer
     inner_declare_argument = DeclareLaunchArgument('some_name', default_value='some_value')
@@ -118,7 +127,7 @@ def test_scoped_include_launch_description_scoping():
     assert isinstance(sub_entities[1], PushEnvironment)
     assert isinstance(sub_entities[2], ResetEnvironment)
     assert isinstance(sub_entities[3], ResetLaunchConfigurations)
-    assert sub_entities[3]._ResetLaunchConfigurations__launch_configurations == {}
+    assert sub_entities[3]._ResetLaunchConfigurations__launch_configurations is None
     assert isinstance(sub_entities[4], LaunchDescription)
     assert sub_entities[4] == ld_non_empty
     assert isinstance(sub_entities[5], PopEnvironment)
@@ -126,7 +135,7 @@ def test_scoped_include_launch_description_scoping():
 
     assert isinstance(action.describe_conditional_sub_entities(), list)
 
-    lc2 = LaunchContext()
+    # lc2 = LaunchContext()
     # TODO: Finish NotImplemented()
 
 # TODO(SuperJappie08) Add tests to verify behavior