iris-pex-embedded-python 3.2.1b3__py3-none-any.whl → 3.3.0__py3-none-any.whl

iop/_async_request.py

@@ -0,0 +1,62 @@
+import asyncio
+import iris
+from typing import Any, Optional, Union
+from iop._dispatch import dispatch_deserializer, dispatch_serializer
+from iop._message import _Message as Message
+
+class AsyncRequest(asyncio.Future):
+    _message_header_id: int = 0
+    _queue_name: str = ""
+    _end_time: int = 0
+    _response: Any = None
+    _done: bool = False
+
+    def __init__(self, target: str, request: Union[Message, Any], 
+                 timeout: int = -1, description: Optional[str] = None, host: Optional[Any] = None) -> None:
+        super().__init__()
+        self.target = target
+        self.request = request
+        self.timeout = timeout
+        self.description = description
+        self.host = host
+        self._iris_handle = host.iris_handle
+        asyncio.create_task(self.send())
+
+    async def send(self) -> None:
+        # init parameters
+        message_header_id = iris.ref()
+        queue_name = iris.ref()
+        end_time = iris.ref()
+        request = dispatch_serializer(self.request)
+
+        # send request
+        self._iris_handle.dispatchSendRequestAsyncNG(
+            self.target, request, self.timeout, self.description,
+            message_header_id, queue_name, end_time)
+        
+        # get byref values
+        self._message_header_id = message_header_id.value
+        self._queue_name = queue_name.value
+        self._end_time = end_time.value
+
+        while not self._done:
+            await asyncio.sleep(0.1)
+            self.is_done()
+
+        self.set_result(self._response)
+
+    def is_done(self) -> None:
+        response = iris.ref()
+        status = self._iris_handle.dispatchIsRequestDone(self.timeout, self._end_time,
+                                                       self._queue_name, self._message_header_id,
+                                                       response)
+        
+        self._response = dispatch_deserializer(response.value)
+
+        if status == 2: # message found
+            self._done = True
+        elif status == 1: # message not found
+            pass
+        else:
+            self._done = True
+            self.set_exception(RuntimeError(iris.system.Status.GetOneStatusText(status)))

iop/_business_host.py

@@ -1,25 +1,13 @@
-import abc
-import asyncio
-import base64
-import codecs
-import datetime
-import decimal
-import importlib
-import inspect
-import iris
-import json
-import pickle
-import uuid
-from dataclasses import dataclass
-from functools import wraps
-from inspect import getsource, signature
-from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple, Type, Union
+from inspect import getsource
+from typing import Any,List, Optional, Tuple, Union
 
-from dacite import Config, from_dict
+import iris
 
 from iop._common import _Common
 from iop._message import _Message as Message
-from iop._utils import _Utils
+from iop._decorators import input_serializer_param, output_deserializer
+from iop._dispatch import dispatch_serializer, dispatch_deserializer
+from iop._async_request import AsyncRequest
 
 class _BusinessHost(_Common):
     """Base class for business components that defines common methods.
@@ -31,102 +19,8 @@ class _BusinessHost(_Common):
     buffer: int = 64000
     DISPATCH: List[Tuple[str, str]] = []
 
-    def input_serialzer(fonction: Callable) -> Callable:
-        """Decorator that serializes input arguments before passing to function.
-        
-        Args:
-            fonction: Function to decorate
-            
-        Returns:
-            Decorated function that handles serialization
-        """
-        def dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
-            # Handle positional arguments using list comprehension
-            serialized = [self._dispatch_serializer(param) for param in params]
-            
-            # Handle keyword arguments using dictionary comprehension
-            param2 = {key: self._dispatch_serializer(value) for key, value in param2.items()}
-            
-            return fonction(self, *serialized, **param2)
-        return dispatch_serializer
-    
-    def input_serialzer_param(position: int, name: str) -> Callable:
-        """Decorator that serializes specific parameter by position or name.
-        
-        Args:
-            position: Position of parameter to serialize
-            name: Name of parameter to serialize
-            
-        Returns:
-            Decorator function
-        """
-        def input_serialzer_param(fonction: Callable) -> Callable:
-            @wraps(fonction)
-            def dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
-                # Handle positional arguments using list comprehension
-                serialized = [
-                    self._dispatch_serializer(param) if i == position else param
-                    for i, param in enumerate(params)
-                ]
-                
-                # Handle keyword arguments using dictionary comprehension
-                param2 = {
-                    key: self._dispatch_serializer(value) if key == name else value
-                    for key, value in param2.items()
-                }
-                
-                return fonction(self, *serialized, **param2)
-            return dispatch_serializer
-        return input_serialzer_param
-
-    def output_deserialzer(fonction: Callable) -> Callable:
-        """Decorator that deserializes output of function.
-        
-        Args:
-            fonction: Function to decorate
-            
-        Returns:
-            Decorated function that handles deserialization
-        """
-        def dispatch_deserializer(self, *params: Any, **param2: Any) -> Any:
-            return self._dispatch_deserializer(fonction(self, *params, **param2))
-            
-        return dispatch_deserializer
-
-    def input_deserialzer(fonction: Callable) -> Callable:
-        """Decorator that deserializes input arguments before passing to function.
-        
-        Args:
-            fonction: Function to decorate
-            
-        Returns:
-            Decorated function that handles deserialization
-        """
-        def dispatch_deserializer(self, *params: Any, **param2: Any) -> Any:
-            # Handle positional arguments using list comprehension
-            serialized = [self._dispatch_deserializer(param) for param in params]
-            
-            # Handle keyword arguments using dictionary comprehension
-            param2 = {key: self._dispatch_deserializer(value) for key, value in param2.items()}
-            
-            return fonction(self, *serialized, **param2)
-        return dispatch_deserializer
-
-    def output_serialzer(fonction: Callable) -> Callable:
-        """Decorator that serializes output of function.
-        
-        Args:
-            fonction: Function to decorate
-            
-        Returns:
-            Decorated function that handles serialization
-        """
-        def dispatch_serializer(self, *params: Any, **param2: Any) -> Any:
-            return self._dispatch_serializer(fonction(self, *params, **param2))
-        return dispatch_serializer
-
-    @input_serialzer_param(1, 'request')
-    @output_deserialzer
+    @input_serializer_param(1, 'request')
+    @output_deserializer
     def send_request_sync(self, target: str, request: Union[Message, Any], 
                          timeout: int = -1, description: Optional[str] = None) -> Any:
         """Send message synchronously to target component.
@@ -145,7 +39,7 @@ class _BusinessHost(_Common):
         """
         return self.iris_handle.dispatchSendRequestSync(target, request, timeout, description)
 
-    @input_serialzer_param(1, 'request')
+    @input_serializer_param(1, 'request')
     def send_request_async(self, target: str, request: Union[Message, Any], 
                           description: Optional[str] = None) -> None:
         """Send message asynchronously to target component.
@@ -173,10 +67,10 @@ class _BusinessHost(_Common):
         Returns:
             Response from target component
         """
-        return await _send_request_async_ng(target, request, timeout, description, self)
+        return await AsyncRequest(target, request, timeout, description, self)
 
     def send_multi_request_sync(self, target_request: List[Tuple[str, Union[Message, Any]]], 
-                                timeout: int = -1, description: Optional[str] = None) -> List[Tuple[str, Union[Message, Any], Any, int]]:
+                               timeout: int = -1, description: Optional[str] = None) -> List[Tuple[str, Union[Message, Any], Any, int]]:
         """Send multiple messages synchronously to target components.
         
         Args:
@@ -186,255 +80,39 @@ class _BusinessHost(_Common):
             
         Returns:
             List of tuples (target, request, response, status)
-        """
-        # create a list of iris.Ens.CallStructure for each target_request
-        call_list = []
-        # sanity check
-        if not isinstance(target_request, list):
-            raise TypeError("The target_request parameter must be a list")
-        if len(target_request) == 0:
-            raise ValueError("The target_request parameter must not be empty")
-        # check if the target_request is a list of tuple of 2 elements
-        if not all(isinstance(item, tuple) and len(item) == 2 for item in target_request):
-            raise TypeError("The target_request parameter must be a list of tuple of 2 elements")
-
-        for target, request in target_request:
-            call = iris.cls("Ens.CallStructure")._New()
-            call.TargetDispatchName = target
-            call.Request = self._dispatch_serializer(request)
-            call_list.append(call)
-        # call the dispatchSendMultiRequestSync method
-        response_list = self.iris_handle.dispatchSendRequestSyncMultiple(call_list, timeout)
-        # create a list of tuple (target, request, response, status)
-        result = []
-        for i in range(len(target_request)):
-            result.append(
-                (target_request[i][0],
-                 target_request[i][1],
-                 self._dispatch_deserializer(response_list[i].Response),
-                 response_list[i].ResponseCode
-                ))
-        return result
-
-
-    def _serialize_pickle_message(self, message: Any) -> iris.cls:
-        """Converts a python dataclass message into an iris iop.message.
-
-        Args:
-            message: The message to serialize, an instance of a class that is a subclass of Message.
-
-        Returns:
-            The message in json format.
-        """
-        pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
-        module = message.__class__.__module__
-        classname = message.__class__.__name__
-
-        msg = iris.cls('IOP.PickleMessage')._New()
-        msg.classname = module + "." + classname
-
-        stream = _Utils.string_to_stream(pickle_string)
-        msg.jstr = stream
-
-        return msg
-
-
-    def _dispatch_serializer(self, message: Any) -> Any:
-        """Serializes the message based on its type.
-        
-        Args:
-            message: The message to serialize
-            
-        Returns:
-            The serialized message
             
         Raises:
-            TypeError: If message is invalid type
+            TypeError: If target_request is not a list of tuples
+            ValueError: If target_request is empty
         """
-        if message is not None:
-            if self._is_message_instance(message):
-                return self._serialize_message(message)
-            elif self._is_pickle_message_instance(message):
-                return self._serialize_pickle_message(message)
-            elif self._is_iris_object_instance(message):
-                return message
-
-        if message == "" or message is None:
-            return message
-
-        # todo : decorator takes care of all the parameters, so this should never happen
-        # return message
-        raise TypeError("The message must be an instance of a class that is a subclass of Message or IRISObject %Persistent class.")
-
-    def _serialize_message(self, message: Any) -> iris.cls:
-        """Converts a python dataclass message into an iris iop.message.
-
-        Args:
-            message: The message to serialize, an instance of a class that is a subclass of Message.
-
-        Returns:
-            The message in json format.
-        """
-        json_string = json.dumps(message, cls=IrisJSONEncoder, ensure_ascii=False)
-        module = message.__class__.__module__
-        classname = message.__class__.__name__
-
-        msg = iris.cls('IOP.Message')._New()
-        msg.classname = module + "." + classname
-
-        if hasattr(msg, 'buffer') and len(json_string) > msg.buffer:
-            msg.json = _Utils.string_to_stream(json_string, msg.buffer)
-        else:
-            msg.json = json_string
-
-        return msg
-
-    def _deserialize_pickle_message(self, serial: iris.cls) -> Any:
-        """Converts an iris iop.message into a python dataclass message.
-        
-        Args:
-            serial: The serialized message
-            
-        Returns:
-            The deserialized message
-        """
-        string = _Utils.stream_to_string(serial.jstr)
-
-        msg = pickle.loads(codecs.decode(string.encode(), "base64"))
-        return msg
-
-    def _dispatch_deserializer(self, serial: Any) -> Any:
-        """Deserializes the message based on its type.
-        
-        Args:
-            serial: The serialized message
-            
-        Returns:
-            The deserialized message
-        """
-        if (
-            serial is not None
-            and type(serial).__module__.startswith('iris')
-            and (
-                serial._IsA("IOP.Message")
-                or serial._IsA("Grongier.PEX.Message")
-            )
-        ):
-            return self._deserialize_message(serial)
-        elif (
-            serial is not None
-            and type(serial).__module__.startswith('iris')
-            and (
-                serial._IsA("IOP.PickleMessage")
-                or serial._IsA("Grongier.PEX.PickleMessage")
-            )
-        ):
-            return self._deserialize_pickle_message(serial)
-        else:
-            return serial
-
-    def _deserialize_message(self, serial: iris.cls) -> Any:
-        """Converts an iris iop.message into a python dataclass message.
-        
-        Args:
-            serial: The serialized message
-            
-        Returns:
-            The deserialized message
-        """
-        if (serial.classname is None):
-            raise ValueError("JSON message malformed, must include classname")
-        classname = serial.classname
-
-        j = classname.rindex(".")
-        if (j <= 0):
-            raise ValueError("Classname must include a module: " + classname)
-        try:
-            module = importlib.import_module(classname[:j])
-            msg = getattr(module, classname[j+1:])
-        except Exception:
-            raise ImportError("Class not found: " + classname)
-
-        string = ""
-        if (serial.type == 'Stream'):
-            string = _Utils.stream_to_string(serial.json)
-        else:
-            string = serial.json
-
-        jdict = json.loads(string, cls=IrisJSONDecoder)
-        msg = self._dataclass_from_dict(msg, jdict)
-        return msg
-
-    def _dataclass_from_dict(self, klass: Type, dikt: Dict) -> Any:
-        """Converts a dictionary to a dataclass instance.
-        
-        Args:
-            klass: The dataclass to convert to
-            dikt: The dictionary to convert to a dataclass
-            
-        Returns:
-            A dataclass object with the fields of the dataclass and the fields of the dictionary.
-        """
-        ret = from_dict(klass, dikt, Config(check_types=False))
+        self._validate_target_request(target_request)
         
-        try:
-            fieldtypes = klass.__annotations__
-        except Exception as e:
-            fieldtypes = []
+        call_list = [self._create_call_structure(target, request) 
+                    for target, request in target_request]
         
-        for key, val in dikt.items():
-            if key not in fieldtypes:
-                setattr(ret, key, val)
-        return ret
-
-    def _dispach_message(self, request: Any) -> Any:
-        """Dispatches the message to the appropriate method.
+        response_list = self.iris_handle.dispatchSendRequestSyncMultiple(call_list, timeout)
         
-        Args:
-            request: The request object
-            
-        Returns:
-            The response object
-        """
-        call = 'on_message'
-
-        module = request.__class__.__module__
-        classname = request.__class__.__name__
-
-        for msg, method in self.DISPATCH:
-            if msg == module + "." + classname:
-                call = method
+        return [(target_request[i][0],
+                target_request[i][1], 
+                dispatch_deserializer(response_list[i].Response),
+                response_list[i].ResponseCode) 
+                for i in range(len(target_request))]
 
-        return getattr(self, call)(request)
+    def _validate_target_request(self, target_request: List[Tuple[str, Union[Message, Any]]]) -> None:
+        """Validate the target_request parameter structure."""
+        if not isinstance(target_request, list):
+            raise TypeError("target_request must be a list")
+        if not target_request:
+            raise ValueError("target_request must not be empty")
+        if not all(isinstance(item, tuple) and len(item) == 2 for item in target_request):
+            raise TypeError("target_request must contain tuples of (target, request)")
 
-    
-    def _create_dispatch(self) -> None:
-        """Creates a list of tuples, where each tuple contains the name of a class and the name of a method
-        that takes an instance of that class as its only argument.
-        """
-        if len(self.DISPATCH) == 0:
-            # get all function in current BO
-            method_list = [func for func in dir(self) if callable(getattr(self, func)) and not func.startswith("_")]
-            for method in method_list:
-                # get signature of current function
-                try:
-                    param = signature(getattr(self, method)).parameters
-                # Handle staticmethod
-                except ValueError as e:
-                    param = ''
-                # one parameter
-                if (len(param) == 1):
-                    # get parameter type
-                    annotation = str(param[list(param)[0]].annotation)
-                    # trim annotation format <class 'toto'>
-                    i = annotation.find("'")
-                    j = annotation.rfind("'")
-                    # if end is not found
-                    if j == -1:
-                        j = None
-                    classname = annotation[i+1:j]
-                    self.DISPATCH.append((classname, method))
-        return
+    def _create_call_structure(self, target: str, request: Union[Message, Any]) -> Any:
+        """Create an Ens.CallStructure object for the request."""
+        call = iris.cls("Ens.CallStructure")._New()
+        call.TargetDispatchName = target
+        call.Request = dispatch_serializer(request)
+        return call
 
     @staticmethod
     def OnGetConnections() -> Optional[List[str]]:
@@ -542,134 +220,3 @@ class _BusinessHost(_Common):
                     pass
 
         return targer_list
-
-# It's a subclass of the standard JSONEncoder class that knows how to encode date/time, decimal types,
-# and UUIDs.
-class IrisJSONEncoder(json.JSONEncoder):
-    """
-    JSONEncoder subclass that knows how to encode date/time, decimal types, and
-    UUIDs.
-    """
-
-    def default(self, o: Any) -> Any:
-        if o.__class__.__name__ == 'DataFrame':
-            return 'dataframe:' + o.to_json(orient="table")
-        elif isinstance(o, datetime.datetime):
-            r = o.isoformat()
-            if o.microsecond:
-                r = r[:23] + r[26:]
-            if r.endswith("+00:00"):
-                r = r[:-6] + "Z"
-            return 'datetime:' + r
-        elif isinstance(o, datetime.date):
-            return 'date:' + o.isoformat()
-        elif isinstance(o, datetime.time):
-            r = o.isoformat()
-            if o.microsecond:
-                r = r[:12]
-            return 'time:' + r
-        elif isinstance(o, decimal.Decimal): 
-            return 'decimal:' + str(o)
-        elif isinstance(o, uuid.UUID):
-            return 'uuid:' + str(o)
-        elif isinstance(o, bytes):
-            return 'bytes:' + base64.b64encode(o).decode("UTF-8")
-        elif hasattr(o, '__dict__'):
-            return o.__dict__
-        else:
-            return super().default(o)
-
-# It's a JSON decoder that looks for a colon in the value of a key/value pair. If it finds one, it
-# assumes the value is a string that represents a type and a value. It then converts the value to the
-# appropriate type
-class IrisJSONDecoder(json.JSONDecoder):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        json.JSONDecoder.__init__(
-            self, object_hook=self.object_hook, *args, **kwargs)
-
-    def object_hook(self, obj: Dict) -> Dict:
-        ret = {}
-        for key, value in obj.items():
-            i = 0
-            if isinstance(value, str):
-                i = value.find(":") 
-            if (i > 0):
-                typ = value[:i]
-                if typ == 'datetime':
-                    ret[key] = datetime.datetime.fromisoformat(value[i+1:])
-                elif typ == 'date':
-                    ret[key] = datetime.date.fromisoformat(value[i+1:])
-                elif typ == 'time':
-                    ret[key] = datetime.time.fromisoformat(value[i+1:])
-                elif typ == 'dataframe':
-                    module = importlib.import_module('pandas')
-                    ret[key] = module.read_json(value[i+1:], orient="table")
-                elif typ == 'decimal':
-                    ret[key] = decimal.Decimal(value[i+1:])
-                elif typ == 'uuid':
-                    ret[key] = uuid.UUID(value[i+1:])
-                elif typ == 'bytes':
-                    ret[key] = base64.b64decode((value[i+1:].encode("UTF-8")))
-                else:
-                    ret[key] = value
-            else:
-                ret[key] = value
-        return ret
-
-class _send_request_async_ng(asyncio.Future):
-
-    _message_header_id: int = 0
-    _queue_name: str = ""
-    _end_time: int = 0
-    _response: Any = None
-    _done: bool = False
-
-    def __init__(self, target: str, request: Union[Message, Any], 
-                 timeout: int = -1, description: Optional[str] = None, host: Optional[_BusinessHost] = None) -> None:
-        super().__init__()
-        self.target = target
-        self.request = request
-        self.timeout = timeout
-        self.description = description
-        self.host = host
-        self._iris_handle = host.iris_handle
-        asyncio.create_task(self.send())
-
-    async def send(self) -> None:
-        # init parameters
-        message_header_id = iris.ref()
-        queue_name = iris.ref()
-        end_time = iris.ref()
-        request = self.host._dispatch_serializer(self.request)
-
-        # send request
-        self._iris_handle.dispatchSendRequestAsyncNG(
-            self.target, request, self.timeout, self.description,
-            message_header_id, queue_name, end_time)
-        
-        # get byref values
-        self._message_header_id = message_header_id.value
-        self._queue_name = queue_name.value
-        self._end_time = end_time.value
-
-        while not self._done:
-            await asyncio.sleep(0.1)
-            self.is_done()
-
-        self.set_result(self._response)
-
-    def is_done(self) -> None:
-        response = iris.ref()
-        status = self._iris_handle.dispatchIsRequestDone(self.timeout, self._end_time,
-                                                         self._queue_name, self._message_header_id,
-                                                         response)
-        
-        self._response = self.host._dispatch_deserializer(response.value)
-
-        if status == 2: # message found
-            self._done = True
-        elif status == 1: # message not found
-            pass
-        else:
-            self._done = True
-            self.set_exception(RuntimeError(iris.system.Status.GetOneStatusText(status)))

iop/_business_operation.py

@@ -1,6 +1,8 @@
 import importlib
 from typing import Any, List, Optional, Union, Tuple
 from iop._business_host import _BusinessHost
+from iop._decorators import input_deserializer, output_serializer, input_serializer, output_deserializer
+from iop._dispatch import create_dispatch, dispach_message
 
 class _BusinessOperation(_BusinessHost):
     """Business operation component that handles outbound communication.
@@ -45,15 +47,15 @@ class _BusinessOperation(_BusinessHost):
 
     def _dispatch_on_init(self, host_object: Any) -> None:
         """For internal use only."""
-        self._create_dispatch()
+        create_dispatch(self)
         self.on_init()
         return
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_message(self, request: Any) -> Any:
         """For internal use only."""
-        return self._dispach_message(request)
+        return dispach_message(self,request)
 
     def OnMessage(self, request: Any) -> Any:
         """DEPRECATED : use on_message