test RW multiple properties

Author: VigneshVSV

hololinked/client/abstractions.py

@@ -260,6 +260,22 @@ def observe(self, *callbacks: typing.Callable) -> None:
     def unobserve(self) -> None:
         """Stop observing property value changes"""
         raise NotImplementedError("implement property unobserve per protocol")
+    
+    def read_reply(self, message_id: str, timeout: float | int | None = None) -> typing.Any:
+        """
+        Read the reply of the action call
+        
+        Parameters
+        ----------
+        message_id: str
+            id of the request or message (UUID4 as string)
+        
+        Returns
+        -------
+        typing.Any
+            reply of the action call
+        """
+        raise NotImplementedError("implement action read_reply per protocol")
 
 
 class ConsumedThingEvent:

hololinked/client/factory.py

@@ -1,7 +1,7 @@
 import uuid
 
 from .abstractions import ConsumedThingAction, ConsumedThingProperty, ConsumedThingEvent
-from .zmq.consumed_interactions import ZMQAction, ZMQEvent, ZMQProperty
+from .zmq.consumed_interactions import ZMQAction, ZMQEvent, ZMQProperty, WriteMultipleProperties, ReadMultipleProperties
 from ..core.zmq import SyncZMQClient, AsyncZMQClient
 from ..core import Thing, Action
 from ..td.interaction_affordance import PropertyAffordance, ActionAffordance, EventAffordance
@@ -39,6 +39,7 @@ def zmq(self, server_id: str, thing_id: str, protocol: str, **kwargs):
             async_client=async_zmq_client,
         )
         TD = FetchTD(ignore_errors=True)
+        object_proxy.td = TD
         for name  in TD["properties"]:
             affordance = PropertyAffordance.from_TD(name, TD)
             consumed_property = ZMQProperty(
@@ -72,6 +73,16 @@ def zmq(self, server_id: str, thing_id: str, protocol: str, **kwargs):
                                     execution_timeout=object_proxy.execution_timeout,
                                 )
             self.add_event(object_proxy, consumed_event)
+        for opname, ophandler in zip(['_get_properties', '_set_properties'], [ReadMultipleProperties, WriteMultipleProperties]):
+            setattr(
+                object_proxy, 
+                opname,
+                ophandler(
+                    sync_client=sync_zmq_client, 
+                    async_client=async_zmq_client, 
+                    owner_inst=object_proxy
+                )
+            )
         return object_proxy
 
     @classmethod

hololinked/client/proxy.py

@@ -52,7 +52,7 @@ class ObjectProxy:
     _own_attrs = frozenset([
         '__annotations__',
         '_allow_foreign_attributes',
-        'id', 'logger', 
+        'id', 'logger', 'td', 
         'execution_timeout', 'invokation_timeout', '_execution_timeout', '_invokation_timeout', 
         '_events', 
         '_noblock_messages',
@@ -73,6 +73,7 @@ def __init__(self,
                         )
         self.invokation_timeout = kwargs.get("invokation_timeout", 5)
         self.execution_timeout = kwargs.get("execution_timeout", 5)
+        self.td = kwargs.get('td', dict()) # type: typing.Dict[str, typing.Any]
         # compose ZMQ client in Proxy client so that all sending and receiving is
         # done by the ZMQ client and not by the Proxy client directly. Proxy client only 
         # bothers mainly about __setattr__ and _getattr__
@@ -161,10 +162,10 @@ def set_execution_timeout(self, value : typing.Union[float, int]) -> None:
     )
 
     # @abstractmethod
-    def is_supported_interaction(self, td, name):
-        """Returns True if the any of the Forms for the Interaction
-        with the given name is supported in this Protocol Binding client."""
-        raise NotImplementedError()
+    # def is_supported_interaction(self, td, name):
+    #     """Returns True if the any of the Forms for the Interaction
+    #     with the given name is supported in this Protocol Binding client."""
+    #     raise NotImplementedError()
 
 
     def invoke_action(
@@ -568,18 +569,7 @@ def read_reply(self, message_id: str, timeout: typing.Optional[float] = 5000) ->
         if not obj:
             raise ValueError('given message id not a one way call or invalid.')
         return obj.read_reply(message_id=message_id, timeout=timeout)
-        # reply = obj.sync_zmq_client._.get(message_id, None)
-        if not reply: 
-            reply = self.zmq_client.recv_reply(message_id=message_id, timeout=timeout,
-                                    raise_client_side_exception=True)
-        if not reply:
-            raise ReplyNotArrivedError(f"could not fetch reply within timeout for message id '{message_id}'")
-        if isinstance(obj, ConsumedThingAction):
-            obj._last_zmq_response = reply 
-            return obj.last_return_value # note the missing underscore
-        elif isinstance(obj, ConsumedThingProperty):
-            obj._last_value = reply 
-            return obj.last_read_value
+        
 
     @property
     def properties(self) -> typing.List[ConsumedThingProperty]:
@@ -601,6 +591,20 @@ def events(self) -> typing.List[ConsumedThingEvent]:
         list of events in the server object
         """
         return [event for event in self.__dict__.values() if isinstance(event, ConsumedThingEvent)]
+    
+    @property
+    def thing_id(self) -> str:
+        """
+        id of the server object
+        """
+        return self.td.get("id", None)
+    
+    @property
+    def TD(self) -> typing.Dict[str, typing.Any]:
+        """
+        Thing description of the server object
+        """
+        return self.td
 
 
 __all__ = [

hololinked/client/zmq/consumed_interactions.py

@@ -4,8 +4,6 @@
 import threading
 import warnings
 import traceback
-from uuid import uuid4
-
 
 from ...utils import get_current_async_loop
 from ...constants import Operations
@@ -16,6 +14,8 @@
 from ...core.zmq.message import ResponseMessage
 from ...core.zmq.message import EMPTY_BYTE, REPLY, TIMEOUT, ERROR, INVALID_MESSAGE
 from ...core.zmq.brokers import SyncZMQClient, AsyncZMQClient, EventConsumer, AsyncEventConsumer
+from ...core import Thing, Action
+from ..exceptions import ReplyNotArrivedError
 
 
 
@@ -24,7 +24,7 @@
 
 class ZMQConsumedAffordanceMixin:
 
-    __slots__ = ['_resource', '_schema_validator', '__name__', '__qualname__', '__doc__',
+    __slots__ = ['_resource', '_schema_validator', '__name__', '__qualname__', '__doc__', '_owner_inst',
                 '_sync_zmq_client', '_async_zmq_client', '_invokation_timeout', '_execution_timeout',
                 '_thing_execution_context', '_last_zmq_response' ]  # __slots__ dont support multiple inheritance
 
@@ -64,9 +64,16 @@ def last_zmq_response(self) -> ResponseMessage:
         """
         return self._last_zmq_response
 
+    def read_reply(self, message_id: str, timeout: int = None) -> typing.Any:
+        if self._owner_inst._noblock_messages.get(message_id) != self:
+            raise RuntimeError(f"Message ID {message_id} does not belong to this property.")
+        self._last_zmq_response = self._sync_zmq_client.recv_response(message_id=message_id)
+        if not self._last_zmq_response:
+            raise ReplyNotArrivedError(f"could not fetch reply within timeout for message id '{message_id}'")
+        return ZMQConsumedAffordanceMixin.get_last_return_value(self, True)
+    
 
-
-class ZMQAction(ConsumedThingAction, ZMQConsumedAffordanceMixin):
+class ZMQAction(ZMQConsumedAffordanceMixin, ConsumedThingAction):
 
     # method call abstraction
     # Dont add doc otherwise __doc__ in slots will conflict with class variable
@@ -187,14 +194,9 @@ def noblock(self, *args, **kwargs) -> str:
         self._owner_inst._noblock_messages[msg_id] = self
         return msg_id
 
-    def read_reply(self, message_id, timeout = None):
-        if self._owner_inst._noblock_messages.get(message_id) != self:
-            raise RuntimeError(f"Message ID {message_id} does not belong to this action.")
-        self._last_zmq_response = self._sync_zmq_client.recv_response(message_id=message_id)
-        return ZMQConsumedAffordanceMixin.get_last_return_value(self, True)
 
 
-class ZMQProperty(ConsumedThingProperty, ZMQConsumedAffordanceMixin):
+class ZMQProperty(ZMQConsumedAffordanceMixin, ConsumedThingProperty):
 
     # property get set abstraction
     # Dont add doc otherwise __doc__ in slots will conflict with class variable
@@ -337,9 +339,9 @@ def noblock_set(self, value: typing.Any) -> None:
                                         )
         self._owner_inst._noblock_messages[msg_id] = self
         return msg_id
+    
+  
 
-
-
 class ZMQEvent(ConsumedThingEvent, ZMQConsumedAffordanceMixin):
 
     __slots__ = ['__name__', '__qualname__', '__doc__', 
@@ -442,6 +444,54 @@ def unsubscribe(self, join_thread: bool = True) -> None:
             self._thread = None
 
 
+
+class WriteMultipleProperties(ZMQAction):
+    """
+    Read and write multiple properties at once
+    """
+
+    def __init__(self, 
+                sync_client: SyncZMQClient, 
+                async_client: AsyncZMQClient | None = None,
+                owner_inst: typing.Optional[typing.Any] = None,
+                **kwargs
+            ) -> None:
+        action = Thing._set_properties # type: Action
+        resource = action.to_affordance(Thing)
+        resource._thing_id = owner_inst.thing_id
+        super().__init__(
+            resource=resource, 
+            sync_client=sync_client, 
+            async_client=async_client, 
+            owner_inst=owner_inst, 
+            **kwargs
+        )
+        
+
+class ReadMultipleProperties(ZMQAction):
+    """
+    Read multiple properties at once
+    """
+
+    def __init__(
+        self,
+        sync_client: SyncZMQClient,
+        async_client: AsyncZMQClient | None = None,
+        owner_inst: typing.Optional[typing.Any] = None,
+        **kwargs
+    ) -> None:
+        action = Thing._get_properties # type: Action
+        resource = action.to_affordance(Thing)
+        resource._thing_id = owner_inst.thing_id
+        super().__init__(
+            resource=resource,
+            sync_client=sync_client,
+            async_client=async_client,
+            owner_inst=owner_inst,
+            **kwargs
+        )
+    
+
 __all__ = [
     ZMQAction.__name__,
     ZMQProperty.__name__,

hololinked/core/meta.py

@@ -10,7 +10,7 @@
 from ..utils import getattr_without_descriptor_read
 from ..constants import JSON, JSONSerializable
 from ..serializers import Serializers
-from .actions import Action, BoundAction
+from .actions import Action, BoundAction, action
 from .property import Property
 from .events import Event, EventPublisher, EventDispatcher
 
@@ -754,6 +754,54 @@ def properties(self) -> PropertiesRegistry:
         """container for the property descriptors of the object."""
         return self._properties_registry
 
+    @action()
+    def _get_properties(self, **kwargs) -> typing.Dict[str, typing.Any]:
+        """
+        """
+        return self.properties.get(**kwargs)
+
+    @action()
+    def _set_properties(self, **values : typing.Dict[str, typing.Any]) -> None:
+        """ 
+        set properties whose name is specified by keys of a dictionary
+        
+        Parameters
+        ----------
+        values: Dict[str, Any]
+            dictionary of property names and its values
+        """
+        return self.properties.set(**values) # returns None
+
+    @action()
+    def _get_properties_in_db(self) -> typing.Dict[str, JSONSerializable]:
+        """
+        get all properties in the database
+        
+        Returns
+        -------
+        Dict[str, JSONSerializable]
+            dictionary of property names and their values
+        """
+        return self.properties.get_from_DB()
+
+    @action()
+    def _add_property(self, name: str, prop: JSON) -> None:
+        """
+        add a property to the object
+        
+        Parameters
+        ----------
+        name: str
+            name of the property
+        prop: Property
+            property object
+        """
+        raise NotImplementedError("this method will be implemented properly in a future release")
+        prop = Property(**prop)
+        self.properties.add(name, prop)
+        self._prepare_resources()
+        # instruct the clients to fetch the new resources
+    
 
 class RemoteInvokable:
     """

hololinked/core/thing.py

@@ -25,7 +25,7 @@ class Thing(Propertized, RemoteInvokable, EventSource, metaclass=ThingMeta):
     actions to instruct the object to perform tasks and events to get notified of any relevant information. State Machines
     can be used to contrain operations on properties and actions.  
     
-    [UML Diagram](http://localhost:8000/UML/PDF/Thing.pdf)
+    [UML Diagram](https://docs.hololinked.dev/UML/PDF/Thing.pdf)
     """
 
     # local properties

hololinked/td/metadata.py

@@ -4,7 +4,6 @@
 from .base import Schema
 
 
-
 class Link(Schema):
     href : str
     anchor: typing.Optional[str]  

hololinked/td/security_definitions.py

@@ -6,7 +6,6 @@
 from .base import Schema
 
 
-
 class SecurityScheme(Schema):
     """
     create security scheme.