From 79695f3d7412163009ffa50a59f1818542d0c44e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alan=20Dragomireck=C3=BD?= Date: Fri, 6 Dec 2024 13:11:16 +0100 Subject: [PATCH 1/2] Rename DbusSomething* to DbusMember* --- src/sdbus/dbus_common_elements.py | 14 ++++----- src/sdbus/dbus_proxy_async_interface_base.py | 30 ++++++++++---------- src/sdbus/dbus_proxy_async_method.py | 4 +-- src/sdbus/dbus_proxy_async_property.py | 4 +-- src/sdbus/dbus_proxy_async_signal.py | 4 +-- src/sdbus/dbus_proxy_sync_interface_base.py | 8 +++--- src/sdbus/dbus_proxy_sync_method.py | 4 +-- src/sdbus/dbus_proxy_sync_property.py | 4 +-- 8 files changed, 36 insertions(+), 36 deletions(-) diff --git a/src/sdbus/dbus_common_elements.py b/src/sdbus/dbus_common_elements.py index 7c8aa20..4c6fd69 100644 --- a/src/sdbus/dbus_common_elements.py +++ b/src/sdbus/dbus_common_elements.py @@ -49,16 +49,16 @@ T = TypeVar('T') -class DbusSomethingCommon: +class DbusMemberCommon: interface_name: str serving_enabled: bool -class DbusSomethingAsync(DbusSomethingCommon): +class DbusMemberAsync(DbusMemberCommon): ... -class DbusSomethingSync(DbusSomethingCommon): +class DbusMemberSync(DbusMemberCommon): ... @@ -83,7 +83,7 @@ def __new__(cls: Type[SelfMeta], name: str, ... for attr_name, attr in namespace.items(): - if not isinstance(attr, DbusSomethingCommon): + if not isinstance(attr, DbusMemberCommon): continue # TODO: Fix async metaclass copying all methods @@ -112,7 +112,7 @@ def __new__(cls: Type[SelfMeta], name: str, ) -class DbusMethodCommon(DbusSomethingCommon): +class DbusMethodCommon(DbusMemberCommon): def __init__( self, @@ -231,7 +231,7 @@ def _rebuild_args( return new_args_list -class DbusPropertyCommon(DbusSomethingCommon): +class DbusPropertyCommon(DbusMemberCommon): def __init__(self, property_name: Optional[str], property_signature: str, @@ -262,7 +262,7 @@ def __init__(self, self.flags = flags -class DbusSignalCommon(DbusSomethingCommon): +class DbusSignalCommon(DbusMemberCommon): def __init__(self, signal_name: Optional[str], signal_signature: str, diff --git a/src/sdbus/dbus_proxy_async_interface_base.py b/src/sdbus/dbus_proxy_async_interface_base.py index f13d162..bc60e3d 100644 --- a/src/sdbus/dbus_proxy_async_interface_base.py +++ b/src/sdbus/dbus_proxy_async_interface_base.py @@ -31,12 +31,12 @@ DbusClassMeta, DbusInterfaceMetaCommon, DbusLocalObjectMeta, + DbusMemberAsync, + DbusMemberCommon, + DbusMemberSync, DbusMethodOverride, DbusPropertyOverride, DbusRemoteObjectMeta, - DbusSomethingAsync, - DbusSomethingCommon, - DbusSomethingSync, ) from .dbus_common_funcs import get_default_bus from .dbus_proxy_async_method import DbusMethodAsync, DbusMethodAsyncLocalBind @@ -81,7 +81,7 @@ class DbusInterfaceMetaAsync(DbusInterfaceMetaCommon): def _process_dbus_method_override( override_attr_name: str, override: DbusMethodOverride[T], - mro_dbus_elements: Dict[str, DbusSomethingAsync], + mro_dbus_elements: Dict[str, DbusMemberAsync], ) -> DbusMethodAsync: try: original_method = mro_dbus_elements[override_attr_name] @@ -105,7 +105,7 @@ def _process_dbus_method_override( def _process_dbus_property_override( override_attr_name: str, override: DbusPropertyOverride[T], - mro_dbus_elements: Dict[str, DbusSomethingAsync], + mro_dbus_elements: Dict[str, DbusMemberAsync], ) -> DbusPropertyAsync[Any]: try: original_property = mro_dbus_elements[override_attr_name] @@ -137,11 +137,11 @@ def _check_collisions( cls, new_class_name: str, namespace: Dict[str, Any], - mro_dbus_elements: Dict[str, DbusSomethingAsync], + mro_dbus_elements: Dict[str, DbusMemberAsync], ) -> None: possible_collisions = namespace.keys() & mro_dbus_elements.keys() - new_overrides: Dict[str, DbusSomethingAsync] = {} + new_overrides: Dict[str, DbusMemberAsync] = {} for attr_name, attr in namespace.items(): if isinstance(attr, DbusMethodOverride): @@ -173,12 +173,12 @@ def _check_collisions( def _extract_dbus_elements( dbus_class: type, dbus_meta: DbusClassMeta, - ) -> Dict[str, DbusSomethingAsync]: - dbus_elements_map: Dict[str, DbusSomethingAsync] = {} + ) -> Dict[str, DbusMemberAsync]: + dbus_elements_map: Dict[str, DbusMemberAsync] = {} for attr_name in dbus_meta.python_attr_to_dbus_member.keys(): dbus_element = dbus_class.__dict__.get(attr_name) - if not isinstance(dbus_element, DbusSomethingAsync): + if not isinstance(dbus_element, DbusMemberAsync): raise TypeError( f"Expected async D-Bus element, got {dbus_element!r} " f"in class {dbus_class!r}" @@ -193,8 +193,8 @@ def _map_mro_dbus_elements( cls, new_class_name: str, base_classes: Iterable[type], - ) -> Dict[str, DbusSomethingAsync]: - all_python_dbus_map: Dict[str, DbusSomethingAsync] = {} + ) -> Dict[str, DbusMemberAsync]: + all_python_dbus_map: Dict[str, DbusMemberAsync] = {} possible_collisions: Set[str] = set() for c in base_classes: @@ -227,10 +227,10 @@ def _map_dbus_elements( meta: DbusClassMeta, interface_name: str, ) -> None: - if not isinstance(attr, DbusSomethingCommon): + if not isinstance(attr, DbusMemberCommon): return - if isinstance(attr, DbusSomethingSync): + if isinstance(attr, DbusMemberSync): raise TypeError( "Can't mix blocking methods in " f"async interface: {attr_name!r}" @@ -347,7 +347,7 @@ def export_to_dbus( interface_map: Dict[str, List[DbusBindedAsync]] = {} for key, value in getmembers(self): - assert not isinstance(value, DbusSomethingAsync) + assert not isinstance(value, DbusMemberAsync) if isinstance(value, DbusMethodAsyncLocalBind): interface_name = value.dbus_method.interface_name diff --git a/src/sdbus/dbus_proxy_async_method.py b/src/sdbus/dbus_proxy_async_method.py index d4c6138..46c7661 100644 --- a/src/sdbus/dbus_proxy_async_method.py +++ b/src/sdbus/dbus_proxy_async_method.py @@ -27,10 +27,10 @@ from .dbus_common_elements import ( DbusBindedAsync, + DbusMemberAsync, DbusMethodCommon, DbusMethodOverride, DbusRemoteObjectMeta, - DbusSomethingAsync, ) from .dbus_exceptions import DbusFailedError from .sd_bus_internals import DbusNoReplyFlag @@ -52,7 +52,7 @@ def get_current_message() -> SdBusMessage: return CURRENT_MESSAGE.get() -class DbusMethodAsync(DbusMethodCommon, DbusSomethingAsync): +class DbusMethodAsync(DbusMethodCommon, DbusMemberAsync): @overload def __get__( diff --git a/src/sdbus/dbus_proxy_async_property.py b/src/sdbus/dbus_proxy_async_property.py index b6ebdee..b293389 100644 --- a/src/sdbus/dbus_proxy_async_property.py +++ b/src/sdbus/dbus_proxy_async_property.py @@ -26,10 +26,10 @@ from .dbus_common_elements import ( DbusBindedAsync, + DbusMemberAsync, DbusPropertyCommon, DbusPropertyOverride, DbusRemoteObjectMeta, - DbusSomethingAsync, ) if TYPE_CHECKING: @@ -42,7 +42,7 @@ T = TypeVar('T') -class DbusPropertyAsync(DbusSomethingAsync, DbusPropertyCommon, Generic[T]): +class DbusPropertyAsync(DbusMemberAsync, DbusPropertyCommon, Generic[T]): def __init__( self, property_name: Optional[str], diff --git a/src/sdbus/dbus_proxy_async_signal.py b/src/sdbus/dbus_proxy_async_signal.py index 0aca3e7..43ff4fc 100644 --- a/src/sdbus/dbus_proxy_async_signal.py +++ b/src/sdbus/dbus_proxy_async_signal.py @@ -36,9 +36,9 @@ from .dbus_common_elements import ( DbusBindedAsync, DbusLocalObjectMeta, + DbusMemberAsync, DbusRemoteObjectMeta, DbusSignalCommon, - DbusSomethingAsync, ) from .dbus_common_funcs import get_default_bus @@ -52,7 +52,7 @@ T = TypeVar('T') -class DbusSignalAsync(DbusSomethingAsync, DbusSignalCommon, Generic[T]): +class DbusSignalAsync(DbusMemberAsync, DbusSignalCommon, Generic[T]): def __init__( self, diff --git a/src/sdbus/dbus_proxy_sync_interface_base.py b/src/sdbus/dbus_proxy_sync_interface_base.py index e749fb8..783256e 100644 --- a/src/sdbus/dbus_proxy_sync_interface_base.py +++ b/src/sdbus/dbus_proxy_sync_interface_base.py @@ -26,9 +26,9 @@ from .dbus_common_elements import ( DbusClassMeta, DbusInterfaceMetaCommon, + DbusMemberAsync, + DbusMemberCommon, DbusRemoteObjectMeta, - DbusSomethingAsync, - DbusSomethingCommon, ) from .dbus_proxy_sync_method import DbusMethodSync from .dbus_proxy_sync_property import DbusPropertySync @@ -109,10 +109,10 @@ def _map_dbus_elements( attr: Any, meta: DbusClassMeta, ) -> None: - if not isinstance(attr, DbusSomethingCommon): + if not isinstance(attr, DbusMemberCommon): return - if isinstance(attr, DbusSomethingAsync): + if isinstance(attr, DbusMemberAsync): raise TypeError( f"Can't mix async methods in sync interface: {attr_name!r}" ) diff --git a/src/sdbus/dbus_proxy_sync_method.py b/src/sdbus/dbus_proxy_sync_method.py index 4d4c487..4bf140e 100644 --- a/src/sdbus/dbus_proxy_sync_method.py +++ b/src/sdbus/dbus_proxy_sync_method.py @@ -25,8 +25,8 @@ from .dbus_common_elements import ( DbusBindedSync, + DbusMemberSync, DbusMethodCommon, - DbusSomethingSync, ) if TYPE_CHECKING: @@ -37,7 +37,7 @@ T = TypeVar('T') -class DbusMethodSync(DbusMethodCommon, DbusSomethingSync): +class DbusMethodSync(DbusMethodCommon, DbusMemberSync): def __get__(self, obj: DbusInterfaceBase, obj_class: Optional[Type[DbusInterfaceBase]] = None, diff --git a/src/sdbus/dbus_proxy_sync_property.py b/src/sdbus/dbus_proxy_sync_property.py index 6f4f303..4cbb5af 100644 --- a/src/sdbus/dbus_proxy_sync_property.py +++ b/src/sdbus/dbus_proxy_sync_property.py @@ -23,7 +23,7 @@ from types import FunctionType from typing import TYPE_CHECKING, Generic, TypeVar, cast -from .dbus_common_elements import DbusPropertyCommon, DbusSomethingSync +from .dbus_common_elements import DbusMemberSync, DbusPropertyCommon from .dbus_common_funcs import _check_sync_in_async_env if TYPE_CHECKING: @@ -35,7 +35,7 @@ T = TypeVar('T') -class DbusPropertySync(DbusPropertyCommon, DbusSomethingSync, Generic[T]): +class DbusPropertySync(DbusPropertyCommon, DbusMemberSync, Generic[T]): def __init__( self, property_name: Optional[str], From 1fbc7ce9f9f6e406dc7747783af6f3fa750627ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alan=20Dragomireck=C3=BD?= Date: Fri, 13 Dec 2024 13:13:45 +0100 Subject: [PATCH 2/2] Rename *Binded types to *Bound and their subclasses --- src/sdbus/dbus_common_elements.py | 4 ++-- src/sdbus/dbus_proxy_async_interface_base.py | 22 ++++++++++---------- src/sdbus/dbus_proxy_async_method.py | 12 +++++------ src/sdbus/dbus_proxy_async_property.py | 16 +++++++------- src/sdbus/dbus_proxy_async_signal.py | 16 +++++++------- src/sdbus/dbus_proxy_sync_method.py | 6 +++--- src/sdbus/unittest.py | 17 +++++++-------- 7 files changed, 45 insertions(+), 48 deletions(-) diff --git a/src/sdbus/dbus_common_elements.py b/src/sdbus/dbus_common_elements.py index 4c6fd69..725674e 100644 --- a/src/sdbus/dbus_common_elements.py +++ b/src/sdbus/dbus_common_elements.py @@ -291,11 +291,11 @@ def __init__(self, self.__annotations__ = original_method.__annotations__ -class DbusBindedAsync: +class DbusBoundAsync: ... -class DbusBindedSync: +class DbusBoundSync: ... diff --git a/src/sdbus/dbus_proxy_async_interface_base.py b/src/sdbus/dbus_proxy_async_interface_base.py index bc60e3d..9f48121 100644 --- a/src/sdbus/dbus_proxy_async_interface_base.py +++ b/src/sdbus/dbus_proxy_async_interface_base.py @@ -39,12 +39,12 @@ DbusRemoteObjectMeta, ) from .dbus_common_funcs import get_default_bus -from .dbus_proxy_async_method import DbusMethodAsync, DbusMethodAsyncLocalBind +from .dbus_proxy_async_method import DbusLocalMethodAsync, DbusMethodAsync from .dbus_proxy_async_property import ( + DbusLocalPropertyAsync, DbusPropertyAsync, - DbusPropertyAsyncLocalBind, ) -from .dbus_proxy_async_signal import DbusSignalAsync, DbusSignalAsyncLocalBind +from .dbus_proxy_async_signal import DbusLocalSignalAsync, DbusSignalAsync from .sd_bus_internals import SdBusInterface if TYPE_CHECKING: @@ -61,7 +61,7 @@ Union, ) - from .dbus_common_elements import DbusBindedAsync + from .dbus_common_elements import DbusBoundAsync from .sd_bus_internals import SdBus, SdBusSlot T = TypeVar('T') @@ -344,20 +344,20 @@ def export_to_dbus( local_object_meta.attached_bus = bus local_object_meta.serving_object_path = object_path # TODO: can be optimized with a single loop - interface_map: Dict[str, List[DbusBindedAsync]] = {} + interface_map: Dict[str, List[DbusBoundAsync]] = {} for key, value in getmembers(self): assert not isinstance(value, DbusMemberAsync) - if isinstance(value, DbusMethodAsyncLocalBind): + if isinstance(value, DbusLocalMethodAsync): interface_name = value.dbus_method.interface_name if not value.dbus_method.serving_enabled: continue - elif isinstance(value, DbusPropertyAsyncLocalBind): + elif isinstance(value, DbusLocalPropertyAsync): interface_name = value.dbus_property.interface_name if not value.dbus_property.serving_enabled: continue - elif isinstance(value, DbusSignalAsyncLocalBind): + elif isinstance(value, DbusLocalSignalAsync): interface_name = value.dbus_signal.interface_name if not value.dbus_signal.serving_enabled: continue @@ -375,7 +375,7 @@ def export_to_dbus( for interface_name, member_list in interface_map.items(): new_interface = SdBusInterface() for dbus_something in member_list: - if isinstance(dbus_something, DbusMethodAsyncLocalBind): + if isinstance(dbus_something, DbusLocalMethodAsync): new_interface.add_method( dbus_something.dbus_method.method_name, dbus_something.dbus_method.input_signature, @@ -385,7 +385,7 @@ def export_to_dbus( dbus_something.dbus_method.flags, dbus_something._dbus_reply_call, ) - elif isinstance(dbus_something, DbusPropertyAsyncLocalBind): + elif isinstance(dbus_something, DbusLocalPropertyAsync): getter = dbus_something._dbus_reply_get dbus_property = dbus_something.dbus_property @@ -405,7 +405,7 @@ def export_to_dbus( setter, dbus_property.flags, ) - elif isinstance(dbus_something, DbusSignalAsyncLocalBind): + elif isinstance(dbus_something, DbusLocalSignalAsync): new_interface.add_signal( dbus_something.dbus_signal.signal_name, dbus_something.dbus_signal.signal_signature, diff --git a/src/sdbus/dbus_proxy_async_method.py b/src/sdbus/dbus_proxy_async_method.py index 46c7661..d671df6 100644 --- a/src/sdbus/dbus_proxy_async_method.py +++ b/src/sdbus/dbus_proxy_async_method.py @@ -26,7 +26,7 @@ from weakref import ref as weak_ref from .dbus_common_elements import ( - DbusBindedAsync, + DbusBoundAsync, DbusMemberAsync, DbusMethodCommon, DbusMethodOverride, @@ -78,20 +78,20 @@ def __get__( if obj is not None: dbus_meta = obj._dbus if isinstance(dbus_meta, DbusRemoteObjectMeta): - return DbusMethodAsyncProxyBind(self, dbus_meta) + return DbusProxyMethodAsync(self, dbus_meta) else: - return DbusMethodAsyncLocalBind(self, obj) + return DbusLocalMethodAsync(self, obj) else: return self -class DbusMethodAsyncBaseBind(DbusBindedAsync): +class DbusBoundMethodAsyncBase(DbusBoundAsync): def __call__(self, *args: Any, **kwargs: Any) -> Any: raise NotImplementedError -class DbusMethodAsyncProxyBind(DbusMethodAsyncBaseBind): +class DbusProxyMethodAsync(DbusBoundMethodAsyncBase): def __init__( self, dbus_method: DbusMethodAsync, @@ -145,7 +145,7 @@ def __call__(self, *args: Any, **kwargs: Any) -> Any: return self._dbus_async_call(new_call_message) -class DbusMethodAsyncLocalBind(DbusMethodAsyncBaseBind): +class DbusLocalMethodAsync(DbusBoundMethodAsyncBase): def __init__( self, dbus_method: DbusMethodAsync, diff --git a/src/sdbus/dbus_proxy_async_property.py b/src/sdbus/dbus_proxy_async_property.py index b293389..9cac940 100644 --- a/src/sdbus/dbus_proxy_async_property.py +++ b/src/sdbus/dbus_proxy_async_property.py @@ -25,7 +25,7 @@ from weakref import ref as weak_ref from .dbus_common_elements import ( - DbusBindedAsync, + DbusBoundAsync, DbusMemberAsync, DbusPropertyCommon, DbusPropertyOverride, @@ -84,20 +84,20 @@ def __get__( self, obj: DbusInterfaceBaseAsync, obj_class: Type[DbusInterfaceBaseAsync], - ) -> DbusPropertyAsyncBaseBind[T]: + ) -> DbusBoundPropertyAsyncBase[T]: ... def __get__( self, obj: Optional[DbusInterfaceBaseAsync], obj_class: Optional[Type[DbusInterfaceBaseAsync]] = None, - ) -> Union[DbusPropertyAsyncBaseBind[T], DbusPropertyAsync[T]]: + ) -> Union[DbusBoundPropertyAsyncBase[T], DbusPropertyAsync[T]]: if obj is not None: dbus_meta = obj._dbus if isinstance(dbus_meta, DbusRemoteObjectMeta): - return DbusPropertyAsyncProxyBind(self, dbus_meta) + return DbusProxyPropertyAsync(self, dbus_meta) else: - return DbusPropertyAsyncLocalBind(self, obj) + return DbusLocalPropertyAsync(self, obj) else: return self @@ -126,7 +126,7 @@ def setter_private( self.property_setter_is_public = False -class DbusPropertyAsyncBaseBind(DbusBindedAsync, Awaitable[T]): +class DbusBoundPropertyAsyncBase(DbusBoundAsync, Awaitable[T]): def __await__(self) -> Generator[Any, None, T]: return self.get_async().__await__() @@ -137,7 +137,7 @@ async def set_async(self, complete_object: T) -> None: raise NotImplementedError -class DbusPropertyAsyncProxyBind(DbusPropertyAsyncBaseBind[T]): +class DbusProxyPropertyAsync(DbusBoundPropertyAsyncBase[T]): def __init__( self, dbus_property: DbusPropertyAsync[T], @@ -179,7 +179,7 @@ async def set_async(self, complete_object: T) -> None: await bus.call_async(new_set_message) -class DbusPropertyAsyncLocalBind(DbusPropertyAsyncBaseBind[T]): +class DbusLocalPropertyAsync(DbusBoundPropertyAsyncBase[T]): def __init__( self, dbus_property: DbusPropertyAsync[T], diff --git a/src/sdbus/dbus_proxy_async_signal.py b/src/sdbus/dbus_proxy_async_signal.py index 43ff4fc..8de4c25 100644 --- a/src/sdbus/dbus_proxy_async_signal.py +++ b/src/sdbus/dbus_proxy_async_signal.py @@ -34,7 +34,7 @@ from weakref import WeakSet from .dbus_common_elements import ( - DbusBindedAsync, + DbusBoundAsync, DbusLocalObjectMeta, DbusMemberAsync, DbusRemoteObjectMeta, @@ -85,20 +85,20 @@ def __get__( self, obj: DbusInterfaceBaseAsync, obj_class: Type[DbusInterfaceBaseAsync], - ) -> DbusSignalAsyncBaseBind[T]: + ) -> DbusBoundSignalAsyncBase[T]: ... def __get__( self, obj: Optional[DbusInterfaceBaseAsync], obj_class: Optional[Type[DbusInterfaceBaseAsync]] = None, - ) -> Union[DbusSignalAsyncBaseBind[T], DbusSignalAsync[T]]: + ) -> Union[DbusBoundSignalAsyncBase[T], DbusSignalAsync[T]]: if obj is not None: dbus_meta = obj._dbus if isinstance(dbus_meta, DbusRemoteObjectMeta): - return DbusSignalAsyncProxyBind(self, dbus_meta) + return DbusProxySignalAsync(self, dbus_meta) else: - return DbusSignalAsyncLocalBind(self, dbus_meta) + return DbusLocalSignalAsync(self, dbus_meta) else: return self @@ -131,7 +131,7 @@ async def catch_anywhere( ) -class DbusSignalAsyncBaseBind(DbusBindedAsync, AsyncIterable[T], Generic[T]): +class DbusBoundSignalAsyncBase(DbusBoundAsync, AsyncIterable[T], Generic[T]): async def catch(self) -> AsyncIterator[T]: raise NotImplementedError yield cast(T, None) @@ -150,7 +150,7 @@ def emit(self, args: T) -> None: raise NotImplementedError -class DbusSignalAsyncProxyBind(DbusSignalAsyncBaseBind[T]): +class DbusProxySignalAsync(DbusBoundSignalAsyncBase[T]): def __init__( self, dbus_signal: DbusSignalAsync[T], @@ -224,7 +224,7 @@ def emit(self, args: T) -> None: raise RuntimeError("Cannot emit signal from D-Bus proxy.") -class DbusSignalAsyncLocalBind(DbusSignalAsyncBaseBind[T]): +class DbusLocalSignalAsync(DbusBoundSignalAsyncBase[T]): def __init__( self, dbus_signal: DbusSignalAsync[T], diff --git a/src/sdbus/dbus_proxy_sync_method.py b/src/sdbus/dbus_proxy_sync_method.py index 4bf140e..82e2d71 100644 --- a/src/sdbus/dbus_proxy_sync_method.py +++ b/src/sdbus/dbus_proxy_sync_method.py @@ -24,7 +24,7 @@ from typing import TYPE_CHECKING, TypeVar, cast from .dbus_common_elements import ( - DbusBindedSync, + DbusBoundSync, DbusMemberSync, DbusMethodCommon, ) @@ -42,10 +42,10 @@ def __get__(self, obj: DbusInterfaceBase, obj_class: Optional[Type[DbusInterfaceBase]] = None, ) -> Callable[..., Any]: - return DbusMethodSyncBinded(self, obj) + return DbusLocalMethodSync(self, obj) -class DbusMethodSyncBinded(DbusBindedSync): +class DbusLocalMethodSync(DbusBoundSync): def __init__(self, dbus_method: DbusMethodSync, interface: DbusInterfaceBase): diff --git a/src/sdbus/unittest.py b/src/sdbus/unittest.py index 90702e8..8b9a2ba 100644 --- a/src/sdbus/unittest.py +++ b/src/sdbus/unittest.py @@ -33,10 +33,7 @@ from weakref import ref as weak_ref from .dbus_common_funcs import set_default_bus -from .dbus_proxy_async_signal import ( - DbusSignalAsyncLocalBind, - DbusSignalAsyncProxyBind, -) +from .dbus_proxy_async_signal import DbusLocalSignalAsync, DbusProxySignalAsync from .sd_bus_internals import SdBusMessage, sd_bus_open_user if TYPE_CHECKING: @@ -51,8 +48,8 @@ ) from .dbus_proxy_async_signal import ( + DbusBoundSignalAsyncBase, DbusSignalAsync, - DbusSignalAsyncBaseBind, ) from .sd_bus_internals import SdBus, SdBusSlot @@ -124,7 +121,7 @@ def __init__( self, timeout: Union[int, float], bus: SdBus, - remote_signal: DbusSignalAsyncProxyBind[Any], + remote_signal: DbusProxySignalAsync[Any], ): super().__init__(timeout) self._bus = bus @@ -156,7 +153,7 @@ class DbusSignalRecorderLocal(DbusSignalRecorderBase): def __init__( self, timeout: Union[int, float], - local_signal: DbusSignalAsyncLocalBind[Any], + local_signal: DbusLocalSignalAsync[Any], ): super().__init__(timeout) self._local_signal_ref: weak_ref[DbusSignalAsync[Any]] = ( @@ -240,13 +237,13 @@ async def asyncSetUp(self) -> None: def assertDbusSignalEmits( self, - signal: DbusSignalAsyncBaseBind[Any], + signal: DbusBoundSignalAsyncBase[Any], timeout: Union[int, float] = 1, ) -> AsyncContextManager[DbusSignalRecorderBase]: - if isinstance(signal, DbusSignalAsyncLocalBind): + if isinstance(signal, DbusLocalSignalAsync): return DbusSignalRecorderLocal(timeout, signal) - elif isinstance(signal, DbusSignalAsyncProxyBind): + elif isinstance(signal, DbusProxySignalAsync): return DbusSignalRecorderRemote(timeout, self.bus, signal) else: raise TypeError("Unknown or unsupported signal class.")