Added setter_private decorator to async properties

igo95862 · igo95862 · commit d9f283d42d0b · 2023-01-15T22:22:15.000+06:00
This creates a setter that can only be called localy.
Properties changed signal will be emitted to D-Bus if the
setter is called localy.

This is useful for properties that should be read-only from
the outsude but emit signals when changed localy.
diff --git a/docs/asyncio_api.rst b/docs/asyncio_api.rst
@@ -344,7 +344,17 @@ Decorators
         Defines the setter function.
         This makes the property read/write instead of read-only.
 
-        See example on how to use. 
+        See example on how to use.
+
+    .. py:decoratormethod:: setter_private(set_function)
+
+        Defines the private setter function.
+        The setter can be called locally but property
+        will be read-only from D-Bus.
+
+        Calling the setter locally will emit
+        :py:attr:`properties_changed <DbusInterfaceCommonAsync.properties_changed>`
+        signal to D-Bus.
 
     .. py:method:: get_async()
         :async:
diff --git a/src/sdbus/dbus_proxy_async_interface_base.py b/src/sdbus/dbus_proxy_async_interface_base.py
@@ -238,18 +238,23 @@ def export_to_dbus(
                     )
                 elif isinstance(dbus_something, DbusPropertyAsyncBinded):
                     getter = dbus_something._reply_get_sync
+                    dbus_property = dbus_something.dbus_property
 
-                    setter = (dbus_something._reply_set_sync
-                              if dbus_something.dbus_property.property_setter
-                              is not None
-                              else None)
+                    if (
+                        dbus_property.property_setter is not None
+                        and
+                        dbus_property.property_setter_is_public
+                    ):
+                        setter = dbus_something._reply_set_sync
+                    else:
+                        setter = None
 
                     new_interface.add_property(
-                        dbus_something.dbus_property.property_name,
-                        dbus_something.dbus_property.property_signature,
+                        dbus_property.property_name,
+                        dbus_property.property_signature,
                         getter,
                         setter,
-                        dbus_something.dbus_property.flags,
+                        dbus_property.flags,
                     )
                 elif isinstance(dbus_something, DbusSignalBinded):
                     new_interface.add_signal(
diff --git a/src/sdbus/dbus_proxy_async_property.py b/src/sdbus/dbus_proxy_async_property.py
@@ -74,6 +74,7 @@ def __init__(
         self.property_setter: Optional[
             Callable[[DbusInterfaceBaseAsync, T],
                      None]] = property_setter
+        self.property_setter_is_public: bool = True
 
         self.__doc__ = property_getter.__doc__
 
@@ -86,13 +87,27 @@ def __get__(self,
     def setter(self,
                new_set_function: Callable[
                    [Any, T],
-                   None]
+                   None],
                ) -> None:
+        assert self.property_setter is None, "Setter already defined"
         assert not iscoroutinefunction(new_set_function), (
             "Property setter can't be coroutine",
         )
         self.property_setter = new_set_function
 
+    def setter_private(
+        self,
+        new_set_function: Callable[
+            [Any, T],
+            None],
+    ) -> None:
+        assert self.property_setter is None, "Setter already defined"
+        assert not iscoroutinefunction(new_set_function), (
+            "Property setter can't be coroutine",
+        )
+        self.property_setter = new_set_function
+        self.property_setter_is_public = False
+
 
 class DbusPropertyAsyncBinded(DbusBindedAsync):
     def __init__(self,
@@ -186,6 +201,24 @@ async def set_async(self, complete_object: T) -> None:
             self.dbus_property.property_setter(
                 interface, complete_object)
 
+            try:
+                properties_changed = getattr(interface, 'properties_changed')
+            except AttributeError:
+                ...
+            else:
+                properties_changed.emit(
+                    (
+                        self.dbus_property.interface_name,
+                        {
+                            self.dbus_property.property_name: (
+                                self.dbus_property.property_signature,
+                                complete_object,
+                            ),
+                        },
+                        []
+                    )
+                )
+
             return
 
         assert interface._attached_bus is not None
diff --git a/test/test_sd_bus_async.py b/test/test_sd_bus_async.py
@@ -30,6 +30,7 @@
 from sdbus.exceptions import (
     DbusFailedError,
     DbusFileExistsError,
+    DbusPropertyReadOnlyError,
     DbusUnknownObjectError,
     SdBusLibraryError,
     SdBusUnmappedMessageError,
@@ -96,6 +97,7 @@ def __init__(self) -> None:
         self.test_string = 'test_property'
         self.test_string_read = 'read'
         self.test_no_reply_string = 'no'
+        self.property_private = 100
         self.no_reply_sync = Event()
 
     @dbus_method_async("s", "s")
@@ -132,6 +134,14 @@ def test_property_set(self, new_property: str) -> None:
     def test_property_read_only(self) -> str:
         return self.test_string_read
 
+    @dbus_property_async("x")
+    def test_property_private(self) -> int:
+        return self.property_private
+
+    @test_property_private.setter_private
+    def test_private_setter(self, new_value: int) -> None:
+        self.property_private = new_value
+
     @dbus_method_async("sb", "s")
     async def kwargs_function(
             self,
@@ -864,3 +874,32 @@ async def set_property() -> None:
         )
         self.assertIsNone(
             parsed_dict_with_invalidation['invalidated_property'])
+
+    async def test_property_private_setter(self) -> None:
+        test_object, test_object_connection = initialize_object()
+
+        new_value = 200
+        self.assertNotEqual(
+            await test_object_connection.test_property_private,
+            new_value
+        )
+
+        with self.assertRaises(DbusPropertyReadOnlyError):
+            await test_object_connection.test_property_private.set_async(
+                new_value)
+
+        q = await test_object_connection.properties_changed._get_dbus_queue()
+
+        await test_object.test_property_private.set_async(new_value)
+
+        self.assertEqual(
+            await test_object_connection.test_property_private,
+            new_value
+        )
+
+        changed_properties = cast(
+            DBUS_PROPERTIES_CHANGED_TYPING,
+            (await q.get()).get_contents(),
+        )
+
+        self.assertIn('TestPropertyPrivate', changed_properties[1])
