iris-pex-embedded-python 3.3.1b1__tar.gz → 3.4.0__tar.gz

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 3.3.1b1
+Version: 3.4.0
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -44,12 +44,12 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Utilities
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: dacite>=1.6.0
+Requires-Dist: pydantic>=2.0.0
 Requires-Dist: xmltodict>=0.12.0
 Requires-Dist: iris-embedded-python-wrapper>=0.0.6
 Requires-Dist: setuptools>=40.8.0
-Requires-Dist: dc-schema>=0.0.8
 Requires-Dist: jsonpath-ng>=1.7.0
+Dynamic: license-file
 
 # IoP (Interoperability On Python)
 

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.3.1b1"
+version = "3.4.0"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [
@@ -27,11 +27,10 @@ classifiers = [
 ]
 
 dependencies = [
-    "dacite >=1.6.0",
+    "pydantic>=2.0.0",
     "xmltodict>=0.12.0",
     "iris-embedded-python-wrapper>=0.0.6",
     "setuptools>=40.8.0",
-    "dc-schema>=0.0.8",
     "jsonpath-ng>=1.7.0"
 ]
 
@@ -52,3 +51,6 @@ exclude = ["tests*"]
 
 [tool.setuptools.package-data]
 "*" = ["*.cls"]
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "class"

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/src/grongier/pex/__init__.py

@@ -6,7 +6,7 @@ from iop._business_operation import _BusinessOperation
 from iop._inbound_adapter import _InboundAdapter
 from iop._outbound_adapter import _OutboundAdapter
 from iop._message import _Message
-from iop._pickle_message import _PickleMessage
+from iop._message import _PickleMessage
 from iop._director import _Director
 from iop._utils import _Utils
 

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/src/iop/__init__.py

@@ -3,9 +3,8 @@ from iop._business_process import _BusinessProcess
 from iop._business_service import _BusinessService
 from iop._director import _Director
 from iop._inbound_adapter import _InboundAdapter
-from iop._message import _Message
+from iop._message import _Message, _PickleMessage, _PydanticMessage, _PydanticPickleMessage
 from iop._outbound_adapter import _OutboundAdapter
-from iop._pickle_message import _PickleMessage
 from iop._private_session_duplex import _PrivateSessionDuplex
 from iop._private_session_process import _PrivateSessionProcess
 from iop._utils import _Utils
@@ -21,4 +20,6 @@ class DuplexOperation(_PrivateSessionDuplex): pass
 class DuplexProcess(_PrivateSessionProcess): pass
 class Message(_Message): pass
 class PickleMessage(_PickleMessage): pass
+class PydanticMessage(_PydanticMessage): pass
+class PydanticPickleMessage(_PydanticPickleMessage): pass
 class Director(_Director): pass

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/src/iop/_common.py

@@ -17,7 +17,27 @@ class _Common(metaclass=abc.ABCMeta):
     INFO_URL: ClassVar[str]
     ICON_URL: ClassVar[str]
     iris_handle: Any = None
-    log_to_console: bool = False
+    _log_to_console: bool = False
+    _logger: logging.Logger = None
+
+    @property
+    def logger(self) -> logging.Logger:
+        if self._logger is None:
+            self._logger = LogManager.get_logger(self.__class__.__name__,self.log_to_console)
+        return self._logger
+    
+    @logger.setter
+    def logger(self, value: logging.Logger) -> None:
+        self._logger = value
+
+    @property
+    def log_to_console(self) -> bool:
+        return self._log_to_console
+    
+    @log_to_console.setter
+    def log_to_console(self, value: bool) -> None:
+        self._log_to_console = value
+        self.logger = LogManager.get_logger(self.__class__.__name__,value)
 
     # Lifecycle methods
     def on_init(self) -> None:
@@ -128,7 +148,10 @@ class _Common(metaclass=abc.ABCMeta):
                 if not member[0].startswith('_'):
                     # remove other methods and functions
                     if not inspect.ismethod(member[1]) and not inspect.isfunction(member[1]) and not inspect.isclass(member[1]):
-                        if member[0] not in ('INFO_URL','ICON_URL','PERSISTENT_PROPERTY_LIST') :
+                        if member[0] not in ('INFO_URL','ICON_URL','PERSISTENT_PROPERTY_LIST'
+                                             ,'log_to_console','logger','iris_handle'
+                                             ,'DISPATCH','adapter','Adapter','buffer'
+                                             ,'BusinessHost','business_host','business_host_python'):
                             name = member[0]
                             req = 0
                             cat = "Additional"
@@ -172,7 +195,7 @@ class _Common(metaclass=abc.ABCMeta):
         except:
             pass
         return ret
-    
+
     # Logging methods
     def _log(self) -> Tuple[str, Optional[str]]:
         """Get class and method name for logging.
@@ -189,15 +212,27 @@ class _Common(metaclass=abc.ABCMeta):
             pass
         return current_class, current_method
 
-    @property
-    def logger(self) -> logging.Logger:
-        """Get a logger instance for this component.
+    def _logging(self, message: str, level: int, to_console: Optional[bool] = None) -> None:
+        """Write log entry.
         
-        Returns:
-            Logger configured for IRIS integration
+        Args:
+            message: Message to log
+            level: Log level
+            to_console: If True, log to console instead of IRIS
         """
-        class_name, method_name = self._log()
-        return LogManager.get_logger(class_name, method_name, self.log_to_console)
+        current_class, current_method = self._log()
+        if to_console is None:
+            to_console = self.log_to_console
+        if level == logging.DEBUG:
+            self.logger.debug(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.INFO:
+            self.logger.info(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.CRITICAL:
+            self.logger.critical(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.WARNING:
+            self.logger.warning(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
+        elif level == logging.ERROR:
+            self.logger.error(message, extra={'to_console': to_console, 'class_name': current_class, 'method_name': current_method})
 
     def trace(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write trace log entry.
@@ -206,8 +241,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.debug(message, extra={'to_console': to_console})
-
+        self._logging(message, logging.DEBUG, to_console)
 
     def log_info(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write info log entry.
@@ -216,7 +250,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.info(message, extra={'to_console': to_console})
+        self._logging(message, logging.INFO, to_console)
 
     def log_alert(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write alert log entry.
@@ -225,7 +259,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.critical(message, extra={'to_console': to_console})
+        self._logging(message, logging.CRITICAL, to_console)
 
     def log_warning(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write warning log entry.
@@ -234,7 +268,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.warning(message, extra={'to_console': to_console})
+        self._logging(message, logging.WARNING, to_console)
 
     def log_error(self, message: str, to_console: Optional[bool] = None) -> None:
         """Write error log entry.
@@ -243,7 +277,7 @@ class _Common(metaclass=abc.ABCMeta):
             message: Message to log
             to_console: If True, log to console instead of IRIS
         """
-        self.logger.error(message, extra={'to_console': to_console})
+        self._logging(message, logging.ERROR, to_console)
 
     def log_assert(self, message: str) -> None:
         """Write a log entry of type "assert". Log entries can be viewed in the management portal.

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/src/iop/_director.py

@@ -6,7 +6,6 @@ import intersystems_iris.dbapi._DBAPI as irisdbapi
 import signal
 from dataclasses import dataclass
 
-from iop._business_host import _BusinessHost
 from iop._dispatch import dispatch_deserializer, dispatch_serializer
 from iop._utils import _Utils
 
@@ -278,7 +277,6 @@ class _Director():
                 else:
                     message.json = _Utils.string_to_stream("{}")
         # serialize the message
-        business_host = _BusinessHost()
         serial_message = dispatch_serializer(message)
         response = iris.cls('IOP.Utils').dispatchTestComponent(target,serial_message)
         try:

iris_pex_embedded_python-3.4.0/src/iop/_dispatch.py

@@ -0,0 +1,101 @@
+from inspect import signature
+from typing import Any
+
+from iop._serialization import serialize_message, serialize_pickle_message, deserialize_message, deserialize_pickle_message
+from iop._message_validator import is_message_instance, is_pickle_message_instance, is_iris_object_instance
+
+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 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 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

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/src/iop/_log_manager.py

@@ -1,3 +1,4 @@
+import traceback
 import iris
 import logging
 from typing import Optional, Tuple
@@ -6,7 +7,7 @@ class LogManager:
     """Manages logging integration between Python's logging module and IRIS."""
 
     @staticmethod
-    def get_logger(class_name: str, method_name: Optional[str] = None, to_console: bool = False) -> logging.Logger:
+    def get_logger(class_name: str, to_console: bool = False) -> logging.Logger:
         """Get a logger instance configured for IRIS integration.
         
         Args:
@@ -17,11 +18,11 @@ class LogManager:
         Returns:
             Logger instance configured for IRIS integration
         """
-        logger = logging.getLogger(f"{class_name}.{method_name}" if method_name else class_name)
+        logger = logging.Logger(f"{class_name}")
         
         # Only add handler if none exists
         if not logger.handlers:
-            handler = IRISLogHandler(class_name, method_name, to_console)
+            handler = IRISLogHandler(to_console=to_console)
             formatter = logging.Formatter('%(message)s')
             handler.setFormatter(formatter)
             logger.addHandler(handler)
@@ -33,17 +34,9 @@ class LogManager:
 class IRISLogHandler(logging.Handler):
     """Custom logging handler that routes Python logs to IRIS logging system."""
 
-    def __init__(self, class_name: str, method_name: Optional[str] = None, to_console: bool = False):
-        """Initialize the handler with context information.
-        
-        Args:
-            class_name: Name of the class logging the message
-            method_name: Optional name of the method logging the message
-            console: If True, log to the console instead of IRIS
-        """
+    def __init__(self, to_console: bool = False):
+        """Initialize the IRIS logging handler."""
         super().__init__()
-        self.class_name = class_name
-        self.method_name = method_name
         self.to_console = to_console
 
         # Map Python logging levels to IRIS logging methods
@@ -80,10 +73,11 @@ class IRISLogHandler(logging.Handler):
         Args:
             record: The logging record to emit
         """
-
-        log_func = self.level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
+        class_name = record.class_name if hasattr(record, "class_name") else record.name
+        method_name = record.method_name if hasattr(record, "method_name") else record.funcName
         if self.to_console or (hasattr(record, "to_console") and record.to_console):
             iris.cls("%SYS.System").WriteToConsoleLog(self.format(record),
-                0,self.level_map_console.get(record.levelno, 0),record.name)
+                0,self.level_map_console.get(record.levelno, 0),class_name+"."+method_name)
         else:
-            log_func(self.class_name, self.method_name, self.format(record))
+            log_func = self.level_map.get(record.levelno, iris.cls("Ens.Util.Log").LogInfo)
+            log_func(class_name, method_name, self.format(record))

iris_pex_embedded_python-3.4.0/src/iop/_message.py

@@ -0,0 +1,28 @@
+from typing import Any
+from pydantic import BaseModel
+
+class _Message:
+    """ The abstract class that is the superclass for persistent messages sent from one component to another.
+    This class has no properties or methods. Users subclass Message and add properties.
+    The IOP framework provides the persistence to objects derived from the Message class.
+    """
+    pass
+
+class _PickleMessage:
+    """ The abstract class that is the superclass for persistent messages sent from one component to another.
+    This class has no properties or methods. Users subclass Message and add properties.
+    The IOP framework provides the persistence to objects derived from the Message class.
+    """
+    pass
+
+class _PydanticMessage(BaseModel):
+    """Base class for Pydantic-based messages that can be serialized to IRIS."""
+    
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+
+class _PydanticPickleMessage(BaseModel):
+    """Base class for Pydantic-based messages that can be serialized to IRIS."""
+    
+    def __init__(self, **data: Any):
+        super().__init__(**data)

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/src/iop/_message_validator.py

@@ -1,9 +1,12 @@
 import dataclasses
 from typing import Any, Type
+from iop._message import _Message, _PickleMessage, _PydanticPickleMessage, BaseModel
 
 
 def is_message_instance(obj: Any) -> bool:
     """Check if object is a valid Message instance."""
+    if isinstance(obj, BaseModel):
+        return True
     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")
@@ -13,6 +16,8 @@ def is_message_instance(obj: Any) -> bool:
 
 def is_pickle_message_instance(obj: Any) -> bool:
     """Check if object is a PickleMessage instance."""
+    if isinstance(obj, _PydanticPickleMessage):
+        return True
     if is_pickle_message_class(type(obj)):
         return True
     return False
@@ -27,15 +32,16 @@ def is_iris_object_instance(obj: Any) -> bool:
 
 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"): 
+    if issubclass(klass, _Message):
         return True
-    return any(is_message_class(c) for c in klass.__bases__)
+    return False
+
 
 
 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"):
+    if issubclass(klass, _PickleMessage):
+        return True
+    if issubclass(klass, _PydanticPickleMessage):
         return True
-    return any(is_pickle_message_class(c) for c in klass.__bases__)
+    return False

iris_pex_embedded_python-3.4.0/src/iop/_serialization.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+import codecs
+import importlib
+import inspect
+import pickle
+import json
+from dataclasses import asdict, is_dataclass
+from typing import Any, Dict, Type
+
+import iris
+from pydantic import BaseModel, TypeAdapter, ValidationError
+
+from iop._message import _PydanticPickleMessage
+from iop._utils import _Utils
+
+class SerializationError(Exception):
+    """Exception raised for serialization errors."""
+    pass
+
+class TempPydanticModel(BaseModel):
+    model_config = {
+        'arbitrary_types_allowed' : True,
+        'extra' : 'allow'
+    }
+
+class MessageSerializer:
+    """Handles message serialization and deserialization."""
+
+    @staticmethod
+    def _convert_to_json_safe(obj: Any) -> Any:
+        """Convert objects to JSON-safe format."""
+        if isinstance(obj, BaseModel):
+            return obj.model_dump_json()
+        elif is_dataclass(obj):
+            return TempPydanticModel.model_validate(dataclass_to_dict(obj)).model_dump_json()
+        else:
+            raise SerializationError(f"Object {obj} must be a Pydantic model or dataclass")
+
+    @staticmethod
+    def serialize(message: Any, use_pickle: bool = False) -> iris.cls:
+        """Serializes a message to IRIS format."""
+        if isinstance(message, _PydanticPickleMessage) or use_pickle:
+            return MessageSerializer._serialize_pickle(message)
+        return MessageSerializer._serialize_json(message)
+
+    @staticmethod
+    def _serialize_json(message: Any) -> iris.cls:
+        json_string = MessageSerializer._convert_to_json_safe(message)
+        
+        msg = iris.cls('IOP.Message')._New()
+        msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
+        
+        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
+
+    @staticmethod
+    def deserialize(serial: iris.cls, use_pickle: bool = False) -> Any:
+        if use_pickle:
+            return MessageSerializer._deserialize_pickle(serial)
+        return MessageSerializer._deserialize_json(serial)
+
+    @staticmethod
+    def _deserialize_json(serial: iris.cls) -> Any:
+        if not serial.classname:
+            raise SerializationError("JSON message malformed, must include classname")
+        
+        try:
+            module_name, class_name = MessageSerializer._parse_classname(serial.classname)
+            module = importlib.import_module(module_name)
+            msg_class = getattr(module, class_name)
+        except Exception as e:
+            raise SerializationError(f"Failed to load class {serial.classname}: {str(e)}")
+
+        json_string = (_Utils.stream_to_string(serial.json) 
+                      if serial.type == 'Stream' else serial.json)
+        
+        try:
+            if issubclass(msg_class, BaseModel):
+                return msg_class.model_validate_json(json_string)
+            elif is_dataclass(msg_class):
+                return dataclass_from_dict(msg_class, json.loads(json_string))
+            else:
+                raise SerializationError(f"Class {msg_class} must be a Pydantic model or dataclass")
+        except Exception as e:
+            raise SerializationError(f"Failed to deserialize JSON: {str(e)}")
+
+    @staticmethod
+    def _serialize_pickle(message: Any) -> iris.cls:
+        pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
+        msg = iris.cls('IOP.PickleMessage')._New()
+        msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
+        msg.jstr = _Utils.string_to_stream(pickle_string)
+        return msg
+
+    @staticmethod
+    def _deserialize_pickle(serial: iris.cls) -> Any:
+        string = _Utils.stream_to_string(serial.jstr)
+        return pickle.loads(codecs.decode(string.encode(), "base64"))
+
+    @staticmethod
+    def _parse_classname(classname: str) -> tuple[str, str]:
+        j = classname.rindex(".")
+        if j <= 0:
+            raise SerializationError(f"Classname must include a module: {classname}")
+        return classname[:j], classname[j+1:]
+
+def dataclass_from_dict(klass: Type, dikt: Dict) -> Any:
+    """Converts a dictionary to a dataclass instance.
+    Handles non attended fields and nested dataclasses."""
+    
+    def process_field(value: Any, field_type: Type) -> Any:
+        if value is None:
+            return None
+        if is_dataclass(field_type):
+            return dataclass_from_dict(field_type, value)
+        if field_type != inspect.Parameter.empty:
+            try:
+                return TypeAdapter(field_type).validate_python(value)
+            except ValidationError:
+                return value
+        return value
+
+    # Get field definitions from class signature
+    fields = inspect.signature(klass).parameters
+    field_dict = {}
+
+    # Process each field
+    for field_name, field_info in fields.items():
+        if field_name not in dikt:
+            if field_info.default != field_info.empty:
+                field_dict[field_name] = field_info.default
+            continue
+        
+        field_dict[field_name] = process_field(dikt[field_name], field_info.annotation)
+
+    # Create instance
+    instance = klass(**field_dict)
+    
+    # Add any extra fields not in the dataclass definition
+    for key, value in dikt.items():
+        if key not in field_dict:
+            setattr(instance, key, value)
+    
+    return instance
+
+def dataclass_to_dict(instance: Any) -> Dict:
+    """Converts a class instance to a dictionary.
+    Handles non attended fields."""
+    dikt = asdict(instance)
+    # assign any extra fields
+    for k, v in vars(instance).items():
+        if k not in dikt:
+            dikt[k] = v
+    return dikt
+
+# Maintain backwards compatibility
+serialize_pickle_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=True)
+serialize_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=False)
+deserialize_pickle_message = lambda serial: MessageSerializer.deserialize(serial, use_pickle=True)
+deserialize_message = lambda serial: MessageSerializer.deserialize(serial, use_pickle=False)

{iris_pex_embedded_python-3.3.1b1 → iris_pex_embedded_python-3.4.0}/src/iop/_utils.py

@@ -6,8 +6,10 @@ import inspect
 import xmltodict
 import pkg_resources
 import importlib
+import importlib.util
 import json
-from dc_schema import get_schema
+from iop._message import _Message, _PydanticMessage
+from pydantic import TypeAdapter
 
 class _Utils():
     @staticmethod
@@ -42,7 +44,13 @@ class _Utils():
         
         :param cls: The class to register
         """
-        schema = get_schema(cls)
+        if issubclass(cls,_PydanticMessage):
+            schema = cls.model_json_schema()
+        elif issubclass(cls,_Message):
+            type_adapter = TypeAdapter(cls)
+            schema = type_adapter.json_schema()
+        else:
+            raise ValueError("The class must be a subclass of _Message or _PydanticMessage")
         schema_name = cls.__module__ + '.' + cls.__name__
         schema_str = json.dumps(schema)
         categories = schema_name
@@ -234,7 +242,7 @@ class _Utils():
             settings = _Utils.import_module_from_path('settings',filename)
         else:
             # import settings from the settings module
-            import settings
+            import settings # type: ignore
         # get the path of the settings file
         path = os.path.dirname(inspect.getfile(settings))
         try:
@@ -254,7 +262,7 @@ class _Utils():
         except AttributeError:
             print("No schemas to register")
         try:
-            sys.path.remove(path)
+            sys.path.remove(os.path.normpath(path))
         except ValueError:
             pass