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

iop/_dispatch.py

@@ -0,0 +1,219 @@
+import codecs
+import importlib
+from inspect import signature
+import json
+import pickle
+from typing import Any, Dict, List, Type
+
+import iris
+from dacite import Config, from_dict
+
+from iop._utils import _Utils
+from iop._serialization import IrisJSONEncoder, IrisJSONDecoder
+from iop._message_validator import is_message_instance, is_pickle_message_instance, is_iris_object_instance
+
+def serialize_pickle_message(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(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
+    """
+    if message is not None:
+        if is_message_instance(message):
+            return serialize_message(message)
+        elif is_pickle_message_instance(message):
+            return serialize_pickle_message(message)
+        elif is_iris_object_instance(message):
+            return message
+
+    if message == "" or message is None:
+        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(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(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(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 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 deserialize_pickle_message(serial)
+    else:
+        return serial
+
+def deserialize_message(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)
+    return dataclass_from_dict(msg, jdict)
+
+def dataclass_from_dict(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))
+    
+    try:
+        fieldtypes = klass.__annotations__
+    except Exception as e:
+        fieldtypes = []
+    
+    for key, val in dikt.items():
+        if key not in fieldtypes:
+            setattr(ret, key, val)
+    return ret
+
+def dispach_message(host, request: Any) -> Any:
+    """Dispatches the message to the appropriate method.
+    
+    Args:
+        request: The request object
+        
+    Returns:
+        The response object
+    """
+    call = 'on_message'
+
+    module = request.__class__.__module__
+    classname = request.__class__.__name__
+
+    for msg, method in host.DISPATCH:
+        if msg == module + "." + classname:
+            call = method
+
+    return getattr(host, call)(request)
+
+def create_dispatch(host) -> 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(host.DISPATCH) == 0:
+        method_list = [func for func in dir(host) if callable(getattr(host, func)) and not func.startswith("_")]
+        for method in method_list:
+            try:
+                param = signature(getattr(host, method)).parameters
+            except ValueError as e:
+                param = ''
+            if (len(param) == 1):
+                annotation = str(param[list(param)[0]].annotation)
+                i = annotation.find("'")
+                j = annotation.rfind("'")
+                if j == -1:
+                    j = None
+                classname = annotation[i+1:j]
+                host.DISPATCH.append((classname, method))
+    return

iop/_log_manager.py

@@ -46,6 +46,23 @@ class IRISLogHandler(logging.Handler):
         self.method_name = method_name
         self.to_console = to_console
 
+        # Map Python logging levels to IRIS logging methods
+        self.level_map = {
+            logging.DEBUG: iris.cls("Ens.Util.Log").LogTrace,
+            logging.INFO: iris.cls("Ens.Util.Log").LogInfo,
+            logging.WARNING: iris.cls("Ens.Util.Log").LogWarning,
+            logging.ERROR: iris.cls("Ens.Util.Log").LogError,
+            logging.CRITICAL: iris.cls("Ens.Util.Log").LogAlert,
+        }
+        # Map Python logging levels to IRIS logging Console level
+        self.level_map_console = {
+            logging.DEBUG: -1,
+            logging.INFO: 0,
+            logging.WARNING: 1,
+            logging.ERROR: 2,
+            logging.CRITICAL: 3,
+        }
+
     def format(self, record: logging.LogRecord) -> str:
         """Format the log record into a string.
         
@@ -55,8 +72,6 @@ class IRISLogHandler(logging.Handler):
         Returns:
             Formatted log message
         """
-        if self.to_console:
-            return f"{record}"
         return record.getMessage()
 
     def emit(self, record: logging.LogRecord) -> None:
@@ -65,17 +80,10 @@ class IRISLogHandler(logging.Handler):
         Args:
             record: The logging record to emit
         """
-        # Map Python logging levels to IRIS logging methods
-        level_map = {
-            logging.DEBUG: iris.cls("Ens.Util.Log").LogTrace,
-            logging.INFO: iris.cls("Ens.Util.Log").LogInfo,
-            logging.WARNING: iris.cls("Ens.Util.Log").LogWarning,
-            logging.ERROR: iris.cls("Ens.Util.Log").LogError,
-            logging.CRITICAL: iris.cls("Ens.Util.Log").LogAlert,
-        }
 
-        log_func = level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
+        log_func = self.level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
         if self.to_console or (hasattr(record, "to_console") and record.to_console):
-            iris.cls("%SYS.System").WriteToConsoleLog(self.format(record),0,0,"IoP.Log")
+            iris.cls("%SYS.System").WriteToConsoleLog(self.format(record),
+                0,self.level_map_console.get(record.levelno, 0),record.name)
         else:
             log_func(self.class_name, self.method_name, self.format(record))

iop/_message_validator.py

@@ -0,0 +1,41 @@
+import dataclasses
+from typing import Any, Type
+
+
+def is_message_instance(obj: Any) -> bool:
+    """Check if object is a valid Message instance."""
+    if is_message_class(type(obj)):
+        if not dataclasses.is_dataclass(obj):
+            raise TypeError(f"{type(obj).__module__}.{type(obj).__qualname__} must be a dataclass")
+        return True
+    return False
+
+
+def is_pickle_message_instance(obj: Any) -> bool:
+    """Check if object is a PickleMessage instance."""
+    if is_pickle_message_class(type(obj)):
+        return True
+    return False
+
+
+def is_iris_object_instance(obj: Any) -> bool:
+    """Check if object is an IRIS persistent object."""
+    return (obj is not None and 
+            type(obj).__module__.startswith('iris') and 
+            obj._IsA("%Persistent"))
+
+
+def is_message_class(klass: Type) -> bool:
+    """Check if class is a Message type."""
+    name = f"{klass.__module__}.{klass.__qualname__}"
+    if name in ("iop.Message", "grongier.pex.Message"): 
+        return True
+    return any(is_message_class(c) for c in klass.__bases__)
+
+
+def is_pickle_message_class(klass: Type) -> bool:
+    """Check if class is a PickleMessage type."""
+    name = f"{klass.__module__}.{klass.__qualname__}"
+    if name in ("iop.PickleMessage", "grongier.pex.PickleMessage"):
+        return True
+    return any(is_pickle_message_class(c) for c in klass.__bases__)

iop/_private_session_duplex.py

@@ -1,5 +1,6 @@
 import importlib
 from iop._business_host import _BusinessHost
+from iop._decorators import input_deserializer, input_serializer_param, output_serializer, input_serializer, output_deserializer
 
 class _PrivateSessionDuplex(_BusinessHost):
     
@@ -21,8 +22,8 @@ class _PrivateSessionDuplex(_BusinessHost):
         """
         pass
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_message(self, request):
         """ For internal use only. """
         return self._dispach_message(request)
@@ -38,8 +39,8 @@ class _PrivateSessionDuplex(_BusinessHost):
         self.Adapter = self.adapter = handle_partner
         return
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_process_input(self, request):
         """ For internal use only. """
         return self.on_process_input(request)
@@ -55,8 +56,8 @@ class _PrivateSessionDuplex(_BusinessHost):
         """
         return 
 
-    @_BusinessHost.input_serialzer_param(0,'document')
-    @_BusinessHost.output_deserialzer
+    @input_serializer_param(0,'document')
+    @output_deserializer
     def send_document_to_process(self, document):
         """ Send the specified message to the target business process or business operation synchronously.
             
@@ -75,8 +76,8 @@ class _PrivateSessionDuplex(_BusinessHost):
 
         return self.iris_handle.dispatchSendDocumentToProcess(document)
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_private_session_started(self, source_config_name,self_generated):
         """ For internal use only. """
 
@@ -87,8 +88,8 @@ class _PrivateSessionDuplex(_BusinessHost):
     def on_private_session_started(self,source_config_name,self_generated):
         pass
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_private_session_stopped(self, source_config_name,self_generated,message):
         """ For internal use only. """
 

iop/_private_session_process.py

@@ -1,10 +1,10 @@
 from iop._business_process import _BusinessProcess
-from iop._business_host import _BusinessHost
+from iop._decorators import input_deserializer, output_serializer, input_serializer, output_deserializer
 
 class _PrivateSessionProcess(_BusinessProcess):
     
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_document(self, host_object,source_config_name, request):
         """ For internal use only. """
         self._restore_persistent_properties(host_object)
@@ -16,8 +16,8 @@ class _PrivateSessionProcess(_BusinessProcess):
         pass
 
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_private_session_started(self, host_object, source_config_name,self_generated):
         """ For internal use only. """
         self._restore_persistent_properties(host_object)
@@ -28,8 +28,8 @@ class _PrivateSessionProcess(_BusinessProcess):
     def on_private_session_started(self,source_config_name,self_generated):
         pass
 
-    @_BusinessHost.input_deserialzer
-    @_BusinessHost.output_serialzer
+    @input_deserializer
+    @output_serializer
     def _dispatch_on_private_session_stopped(self, host_object, source_config_name,self_generated,message):
         """ For internal use only. """
         self._restore_persistent_properties(host_object)

iop/_serialization.py

@@ -0,0 +1,196 @@
+import base64
+import codecs
+import datetime
+import decimal
+import importlib
+import json
+import pickle
+import uuid
+from typing import Any, Dict, Type
+
+from dacite import Config, from_dict
+import iris
+
+from iop._utils import _Utils
+
+class IrisJSONEncoder(json.JSONEncoder):
+    """JSONEncoder that handles dates, decimals, UUIDs, etc."""
+    
+    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__
+        return super().default(o)
+
+class IrisJSONDecoder(json.JSONDecoder):
+    """JSONDecoder that handles special type annotations."""
+    
+    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]
+                val = value[i+1:]
+                ret[key] = self._convert_typed_value(typ, val)
+            else:
+                ret[key] = value
+        return ret
+                
+    def _convert_typed_value(self, typ: str, val: str) -> Any:
+        if typ == 'datetime':
+            return datetime.datetime.fromisoformat(val)
+        elif typ == 'date':
+            return datetime.date.fromisoformat(val)
+        elif typ == 'time':
+            return datetime.time.fromisoformat(val)
+        elif typ == 'dataframe':
+            module = importlib.import_module('pandas')
+            return module.read_json(val, orient="table")
+        elif typ == 'decimal':
+            return decimal.Decimal(val)
+        elif typ == 'uuid':
+            return uuid.UUID(val)
+        elif typ == 'bytes':
+            return base64.b64decode(val.encode("UTF-8"))
+        return val
+
+
+def serialize_pickle_message(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 serialize_message(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(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 deserialize_message(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 = dataclass_from_dict(msg, jdict)
+    return msg
+
+def dataclass_from_dict(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))
+    
+    try:
+        fieldtypes = klass.__annotations__
+    except Exception as e:
+        fieldtypes = []
+    
+    for key, val in dikt.items():
+        if key not in fieldtypes:
+            setattr(ret, key, val)
+    return ret

iop/_utils.py

@@ -436,23 +436,31 @@ class _Utils():
         return stream
     
     @staticmethod
-    def guess_path(module,path):
-        if "." in module:
-            if module.startswith("."):
-                # count the number of dots at the beginning of the module name
-                dots = 0
-                for c in module:
-                    if c == ".":
-                        dots += 1
-                    else:
-                        break
-                # remove the dots from the beginning of the module name
-                module = module[dots:]
-                # go to the parent directory dots times
-                for i in range(dots)-1:
-                    path = os.path.dirname(path)
-                return os.path.join(path, module.replace(".", os.sep) + ".py")
-            else:
-                return os.path.join(path, module.replace(".", os.sep) + ".py")
+    def guess_path(module: str, path: str) -> str:
+        """Determines the full file path for a given module.
+        
+        Args:
+            module: Module name/path (e.g. 'foo.bar' or '.foo.bar')
+            path: Base directory path
+            
+        Returns:
+            Full path to the module's .py file
+        """
+        if not module:
+            raise ValueError("Module name cannot be empty")
+            
+        if module.startswith("."):
+            # Handle relative imports
+            dot_count = len(module) - len(module.lstrip("."))
+            module = module[dot_count:]
+            
+            # Go up directory tree based on dot count
+            for _ in range(dot_count - 1):
+                path = os.path.dirname(path)
+                
+        # Convert module path to file path
+        if module.endswith(".py"):
+            module_path = module.replace(".", os.sep)
         else:
-            return os.path.join(path, module + ".py")
+            module_path = module.replace(".", os.sep) + ".py"
+        return os.path.join(path, module_path)

iop/cls/IOP/Common.cls

@@ -193,7 +193,12 @@ ClassMethod OnGetConnections(
 	pItem As Ens.Config.Item)
 {
     // finds any settings of type Ens.DataType.ConfigName
-    do ..GetPropertyConnections(.pArray,pItem)
+    Try {
+        do ..GetPropertyConnections(.pArray,pItem)
+    }
+    Catch ex {
+    }
+
 
     // Get settings
     do pItem.GetModifiedSetting("%classpaths", .tClasspaths)

iop/cls/IOP/Message.cls

@@ -467,6 +467,7 @@ ClassMethod HandleProperty(
     }
     
     If type = "array" Set key = key_"()"
+    Set pContents = idx
     Set pContents(idx,"name") = key
     Set pContents(idx,"alias") = key
 }

{iris_pex_embedded_python-3.2.1b2.dist-info → iris_pex_embedded_python-3.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iris_pex_embedded_python
-Version: 3.2.1b2
+Version: 3.3.0
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License