Rename DbusSomething* to DbusMember*

dragomirecky · dragomirecky · commit 79695f3d7412 · 2024-12-13T13:10:59.000+01:00
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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],
