Add More Test Typings (#1472)

Signed-off-by: Michael Carlstrom <[email protected]>

Author: InvincibleRMC

rclpy/rclpy/__init__.py

@@ -55,7 +55,7 @@
 from rclpy.signals import install_signal_handlers
 from rclpy.signals import SignalHandlerOptions
 from rclpy.signals import uninstall_signal_handlers
-from rclpy.task import Future
+from rclpy.task import Future as Future
 from rclpy.utilities import get_default_context as get_default_context
 from rclpy.utilities import get_rmw_implementation_identifier  # noqa: F401
 from rclpy.utilities import ok as ok  # noqa: F401 forwarding to this module
@@ -64,8 +64,8 @@
 
 # Avoid loading extensions on module import
 if TYPE_CHECKING:
-    from rclpy.executors import Executor  # noqa: F401
-    from rclpy.node import Node  # noqa: F401
+    from rclpy.executors import Executor
+    from rclpy.node import Node
 
 
 class InitContextManager:

rclpy/rclpy/executors.py

@@ -53,7 +53,9 @@
 from rclpy.subscription import Subscription
 from rclpy.task import Future
 from rclpy.task import Task
-from rclpy.timer import Timer, TimerInfo
+from rclpy.timer import Timer
+from rclpy.timer import TimerCallbackType
+from rclpy.timer import TimerInfo
 from rclpy.type_support import Msg
 from rclpy.utilities import get_default_context
 from rclpy.utilities import timeout_sec_to_nsec
@@ -431,8 +433,7 @@ def _take_timer(self, tmr: Timer) -> Optional[Callable[[], Coroutine[None, None,
                     actual_call_time=info['actual_call_time'],
                     clock_type=tmr.clock.clock_type)
 
-                def check_argument_type(callback_func: Union[Callable[[], None],
-                                                             Callable[[TimerInfo], None]],
+                def check_argument_type(callback_func: TimerCallbackType,
                                         target_type: Type[TimerInfo]) -> Optional[str]:
                     sig = inspect.signature(callback_func)
                     for param in sig.parameters.values():

rclpy/rclpy/experimental/__init__.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .events_executor import EventsExecutor  # noqa: F401
+from .events_executor import EventsExecutor as EventsExecutor  # noqa: F401

rclpy/rclpy/logging.py

@@ -17,7 +17,7 @@
 from typing import Union
 
 from rclpy.impl.implementation_singleton import rclpy_implementation as _rclpy
-from rclpy.impl.logging_severity import LoggingSeverity
+from rclpy.impl.logging_severity import LoggingSeverity as LoggingSeverity
 from rclpy.impl.rcutils_logger import RcutilsLogger
 
 

rclpy/rclpy/node.py

@@ -320,7 +320,7 @@ def executor(self) -> Optional[Executor]:
         return None
 
     @executor.setter
-    def executor(self, new_executor: Executor) -> None:
+    def executor(self, new_executor: Optional[Executor]) -> None:
         """Set or change the executor the node belongs to."""
         current_executor = self.executor
         if current_executor == new_executor:
@@ -1826,7 +1826,7 @@ def create_service(
     def create_timer(
         self,
         timer_period_sec: float,
-        callback: TimerCallbackType,
+        callback: Optional[TimerCallbackType],
         callback_group: Optional[CallbackGroup] = None,
         clock: Optional[Clock] = None,
         autostart: bool = True,

rclpy/rclpy/timer.py

@@ -67,15 +67,14 @@ def actual_call_time(self) -> Time:
 
 TimerCallbackType: TypeAlias = Union[Callable[[], None],
                                      Callable[[TimerInfo], None],
-                                     Callable[[], Coroutine[None, None, None]],
-                                     None]
+                                     Callable[[], Coroutine[None, None, None]]]
 
 
 class Timer:
 
     def __init__(
         self,
-        callback: TimerCallbackType,
+        callback: Optional[TimerCallbackType],
         callback_group: Optional[CallbackGroup],
         timer_period_ns: int,
         clock: Clock,

rclpy/test/test_callback_group.py

@@ -20,11 +20,19 @@
 import rclpy
 from rclpy.callback_groups import MutuallyExclusiveCallbackGroup
 from rclpy.callback_groups import ReentrantCallbackGroup
+from rclpy.client import Client
 import rclpy.context
 from rclpy.executors import MultiThreadedExecutor
+from rclpy.service import Service
 from rclpy.task import Future
 from test_msgs.msg import BasicTypes, Empty
 
+from typing_extensions import TypeAlias
+
+
+GetParametersClient: TypeAlias = Client[GetParameters.Request, GetParameters.Response]
+GetParametersService: TypeAlias = Service[GetParameters.Request, GetParameters.Response]
+
 
 class TestCallbackGroup(unittest.TestCase):
 
@@ -33,13 +41,13 @@ class TestCallbackGroup(unittest.TestCase):
         node: rclpy.node.Node
 
     @classmethod
-    def setUpClass(cls):
+    def setUpClass(cls) -> None:
         cls.context = rclpy.context.Context()
         rclpy.init(context=cls.context)
         cls.node = rclpy.create_node('TestCallbackGroup', namespace='/rclpy', context=cls.context)
 
     @classmethod
-    def tearDownClass(cls):
+    def tearDownClass(cls) -> None:
         cls.node.destroy_node()
         rclpy.shutdown(context=cls.context)
 
@@ -71,15 +79,15 @@ def test_reentrant_group_not_blocking(self) -> None:
 
             # This callback is used to check if a callback can be received while another
             # long running callback is being executed
-            def short_callback(msg):
+            def short_callback(msg: Empty) -> None:
                 nonlocal got_short_callback
                 # Set flag so signal that the callback has been received
                 got_short_callback = True
 
             # This callback is as a long running callback
             # It will be checking that the short callback can
             # run in parallel to this long running one
-            def long_callback(msg):
+            def long_callback(msg: Empty) -> None:
                 nonlocal received_short_callback_in_long_callback
                 nonlocal future_up
                 nonlocal future_down
@@ -170,17 +178,19 @@ def test_create_subscription_with_group(self) -> None:
         self.assertTrue(group.has_entity(sub2))
 
     def test_create_client_with_group(self) -> None:
-        cli1 = self.node.create_client(GetParameters, 'get/parameters')
+        cli1: GetParametersClient = self.node.create_client(GetParameters, 'get/parameters')
         group = ReentrantCallbackGroup()
-        cli2 = self.node.create_client(GetParameters, 'get/parameters', callback_group=group)
+        cli2: GetParametersClient = self.node.create_client(GetParameters, 'get/parameters',
+                                                            callback_group=group)
 
         self.assertFalse(group.has_entity(cli1))
         self.assertTrue(group.has_entity(cli2))
 
     def test_create_service_with_group(self) -> None:
-        srv1 = self.node.create_service(GetParameters, 'get/parameters', lambda req, res: None)
+        srv1: GetParametersService = self.node.create_service(GetParameters, 'get/parameters',
+                                                              lambda req, res: None)
         group = ReentrantCallbackGroup()
-        srv2 = self.node.create_service(
+        srv2: GetParametersService = self.node.create_service(
             GetParameters, 'get/parameters', lambda req, res: None, callback_group=group)
 
         self.assertFalse(group.has_entity(srv1))

rclpy/test/test_client.py

@@ -16,20 +16,35 @@
 import threading
 import time
 import traceback
+from typing import List
+from typing import Optional
+from typing import Tuple
 from typing import TYPE_CHECKING
 import unittest
 
 from rcl_interfaces.srv import GetParameters
 import rclpy
+from rclpy.client import Client
 import rclpy.context
 import rclpy.executors
 import rclpy.node
+from rclpy.service import Service
 from rclpy.utilities import get_rmw_implementation_identifier
 from test_msgs.srv import Empty
 
+from typing_extensions import TypeAlias
+
 # TODO(sloretz) Reduce fudge once wait_for_service uses node graph events
 TIME_FUDGE = 0.3
 
+ClientGetParameters: TypeAlias = Client[GetParameters.Request,
+                                        GetParameters.Response]
+
+ServiceGetParameters: TypeAlias = Service[GetParameters.Request,
+                                          GetParameters.Response]
+
+TestServiceName: TypeAlias = List[Tuple[str, Optional[str], Optional[List[str]], str]]
+
 
 class TestClient(unittest.TestCase):
 
@@ -38,26 +53,26 @@ class TestClient(unittest.TestCase):
         node: rclpy.node.Node
 
     @classmethod
-    def setUpClass(cls):
+    def setUpClass(cls) -> None:
         cls.context = rclpy.context.Context()
         rclpy.init(context=cls.context)
         cls.node = rclpy.create_node('TestClient', context=cls.context)
 
     @classmethod
-    def tearDownClass(cls):
+    def tearDownClass(cls) -> None:
         cls.node.destroy_node()
         rclpy.shutdown(context=cls.context)
 
     @classmethod
-    def do_test_service_name(cls, test_service_name_list):
+    def do_test_service_name(cls, test_service_name_list: TestServiceName) -> None:
         for service_name, ns, cli_args, target_service_name in test_service_name_list:
             node = rclpy.create_node(
                 node_name='node_name',
                 context=cls.context,
                 namespace=ns,
                 cli_args=cli_args,
                 start_parameter_services=False)
-            client = node.create_client(
+            client: Client[Empty.Request, Empty.Response] = node.create_client(
                 srv_type=Empty,
                 srv_name=service_name
             )
@@ -81,7 +96,7 @@ def _spin_rclpy_node(
 #        rclpy_node.destroy_node()
 
     def test_wait_for_service_5sec(self) -> None:
-        cli = self.node.create_client(GetParameters, 'get/parameters')
+        cli: ClientGetParameters = self.node.create_client(GetParameters, 'get/parameters')
         try:
             start = time.monotonic()
             self.assertFalse(cli.wait_for_service(timeout_sec=5.0))
@@ -92,7 +107,7 @@ def test_wait_for_service_5sec(self) -> None:
             self.node.destroy_client(cli)
 
     def test_wait_for_service_nowait(self) -> None:
-        cli = self.node.create_client(GetParameters, 'get/parameters')
+        cli: ClientGetParameters = self.node.create_client(GetParameters, 'get/parameters')
         try:
             start = time.monotonic()
             self.assertFalse(cli.wait_for_service(timeout_sec=0))
@@ -103,9 +118,9 @@ def test_wait_for_service_nowait(self) -> None:
             self.node.destroy_client(cli)
 
     def test_wait_for_service_exists(self) -> None:
-        cli = self.node.create_client(GetParameters, 'test_wfs_exists')
-        srv = self.node.create_service(GetParameters, 'test_wfs_exists',
-                                       lambda request, response: None)
+        cli: ClientGetParameters = self.node.create_client(GetParameters, 'test_wfs_exists')
+        srv: ServiceGetParameters = self.node.create_service(GetParameters, 'test_wfs_exists',
+                                                             lambda request, response: None)
         try:
             start = time.monotonic()
             self.assertTrue(cli.wait_for_service(timeout_sec=1.0))
@@ -117,8 +132,8 @@ def test_wait_for_service_exists(self) -> None:
             self.node.destroy_service(srv)
 
     def test_concurrent_calls_to_service(self) -> None:
-        cli = self.node.create_client(GetParameters, 'get/parameters')
-        srv = self.node.create_service(
+        cli: ClientGetParameters = self.node.create_client(GetParameters, 'get/parameters')
+        srv: ServiceGetParameters = self.node.create_service(
             GetParameters, 'get/parameters',
             lambda request, response: response)
         try:
@@ -138,8 +153,8 @@ def test_concurrent_calls_to_service(self) -> None:
         get_rmw_implementation_identifier() == 'rmw_connextdds' and platform.system() == 'Windows',
         reason='Source timestamp not implemented for Connext on Windows')
     def test_service_timestamps(self) -> None:
-        cli = self.node.create_client(GetParameters, 'get/parameters')
-        srv = self.node.create_service(
+        cli: ClientGetParameters = self.node.create_client(GetParameters, 'get/parameters')
+        srv: ServiceGetParameters = self.node.create_service(
             GetParameters, 'get/parameters',
             lambda request, response: response)
         try:
@@ -150,6 +165,7 @@ def test_service_timestamps(self) -> None:
                     result = srv.handle.service_take_request(srv.srv_type.Request)
                 if result != (None, None):
                     request, header = result
+                    assert header is not None
                     self.assertTrue(header is not None)
                     self.assertNotEqual(0, header.source_timestamp)
                     return
@@ -161,8 +177,8 @@ def test_service_timestamps(self) -> None:
             self.node.destroy_service(srv)
 
     def test_different_type_raises(self) -> None:
-        cli = self.node.create_client(GetParameters, 'get/parameters')
-        srv = self.node.create_service(
+        cli: ClientGetParameters = self.node.create_client(GetParameters, 'get/parameters')
+        srv: ServiceGetParameters = self.node.create_service(
             GetParameters, 'get/parameters',
             lambda request, response: 'different response type')
         try:
@@ -180,7 +196,7 @@ def test_different_type_raises(self) -> None:
             self.node.destroy_service(srv)
 
     def test_get_service_name(self) -> None:
-        test_service_name_list = [
+        test_service_name_list: TestServiceName = [
             # test_service_name, namespace, cli_args for remap, expected service name
             # No namespaces
             ('service', None, None, '/service'),
@@ -197,7 +213,7 @@ def test_get_service_name(self) -> None:
         TestClient.do_test_service_name(test_service_name_list)
 
     def test_get_service_name_after_remapping(self) -> None:
-        test_service_name_list = [
+        test_service_name_list: TestServiceName = [
             ('service', None, ['--ros-args', '--remap', 'service:=new_service'], '/new_service'),
             ('service', 'ns', ['--ros-args', '--remap', 'service:=new_service'],
              '/ns/new_service'),
@@ -209,9 +225,10 @@ def test_get_service_name_after_remapping(self) -> None:
         TestClient.do_test_service_name(test_service_name_list)
 
     def test_sync_call(self) -> None:
-        def _service(request, response):
+        def _service(request: GetParameters.Request,
+                     response: GetParameters.Response) -> GetParameters.Response:
             return response
-        cli = self.node.create_client(GetParameters, 'get/parameters')
+        cli: ClientGetParameters = self.node.create_client(GetParameters, 'get/parameters')
         srv = self.node.create_service(GetParameters, 'get/parameters', _service)
         try:
             self.assertTrue(cli.wait_for_service(timeout_sec=20))
@@ -231,10 +248,11 @@ def _service(request, response):
             self.node.destroy_service(srv)
 
     def test_sync_call_timeout(self) -> None:
-        def _service(request, response):
+        def _service(request: GetParameters.Request,
+                     response: GetParameters.Response) -> GetParameters.Response:
             time.sleep(1)
             return response
-        cli = self.node.create_client(GetParameters, 'get/parameters')
+        cli: ClientGetParameters = self.node.create_client(GetParameters, 'get/parameters')
         srv = self.node.create_service(GetParameters, 'get/parameters', _service)
         try:
             self.assertTrue(cli.wait_for_service(timeout_sec=20))
@@ -254,8 +272,10 @@ def _service(request, response):
             self.node.destroy_service(srv)
 
     def test_sync_call_context_manager(self) -> None:
-        def _service(request, response):
+        def _service(request: GetParameters.Request,
+                     response: GetParameters.Response) -> GetParameters.Response:
             return response
+        cli: ClientGetParameters
         with self.node.create_client(GetParameters, 'get/parameters') as cli:
             with self.node.create_service(GetParameters, 'get/parameters', _service):
                 self.assertTrue(cli.wait_for_service(timeout_sec=20))