iris-pex-embedded-python 3.7.2b2__py3-none-any.whl → 4.0.0__py3-none-any.whl

iop/{_persistent_message.py → messages/persistent.py}

@@ -4,7 +4,7 @@ import importlib
 import inspect
 import os
 import sys
-from typing import Any, Optional
+from typing import Any
 
 import iris_persistence
 from iris_persistence import Field as Field
@@ -12,6 +12,7 @@ from iris_persistence import Model
 from iris_persistence.models import ModelMeta
 from iris_persistence.runtime import get_runtime
 
+from ..runtime.environment import prepend_sys_path
 
 DEFAULT_SUPERCLASS = "Ens.MessageBody"
 DEFAULT_SYNC_MODE = "extend"
@@ -25,7 +26,7 @@ _IRIS_TO_PYTHON_CACHE: dict[str, str] = {}
 _IRIS_TO_PYTHON_CLASSPATH_CACHE: dict[str, str] = {}
 _IRIS_TO_PYTHON_STRICT_CACHE: dict[str, bool] = {}
 _IRIS_TO_MESSAGE_CLASS_CACHE: dict[str, type] = {}
-_IRIS_PARAMETER_CACHE: dict[tuple[str, str], Optional[str]] = {}
+_IRIS_PARAMETER_CACHE: dict[tuple[str, str], str | None] = {}
 _AUTO_SYNCED: set[tuple[type, str]] = set()
 
 
@@ -54,18 +55,18 @@ class _PersistentMessageMeta(ModelMeta):
         cls._iop_persistent_message_abstract = False
 
 
-def _explicit_meta_classname(cls: type) -> Optional[str]:
+def _explicit_meta_classname(cls: type) -> str | None:
     meta = cls.__dict__.get("Meta")
     if meta is None or not hasattr(meta, "classname"):
         return None
-    value = getattr(meta, "classname")
+    value = meta.classname
     return str(value) if value else None
 
 
 def _apply_persistent_message_defaults(
     cls: type,
-    namespace: Optional[dict] = None,
-    kwargs: Optional[dict] = None,
+    namespace: dict | None = None,
+    kwargs: dict | None = None,
 ) -> None:
     namespace = namespace or {}
     kwargs = kwargs or {}
@@ -90,9 +91,17 @@ def _apply_persistent_message_defaults(
 
 
 class _PersistentMessage(Model, metaclass=_PersistentMessageMeta):
+    """Base class for native persistent IRIS message bodies.
+
+    Use PersistentMessage when IRIS needs a generated native message class or
+    persistent message body. Prefer Message or PydanticMessage for Python-only
+    production routing. See docs/getting-started/register-component.md and
+    docs/settings.md.
+    """
+
     _iop_persistent_message_abstract = True
 
-    def get_iris_id(self) -> Optional[str]:
+    def get_iris_id(self) -> str | None:
         if self.pk:
             return self.pk
 
@@ -200,7 +209,7 @@ def serialize_persistent_message(
 
 def deserialize_persistent_message(
     serial: Any,
-    iris_classname: Optional[str] = None,
+    iris_classname: str | None = None,
 ) -> Any:
     iris_classname = iris_classname or get_iris_object_classname(serial)
     if not iris_classname:
@@ -263,7 +272,7 @@ def resolve_iris_classname(msg_cls: type) -> str:
     return iris_classname
 
 
-def resolve_python_classname(iris_classname: str) -> Optional[str]:
+def resolve_python_classname(iris_classname: str) -> str | None:
     python_classname, _python_classpath, _strict = _resolve_python_message_metadata(
         iris_classname
     )
@@ -271,7 +280,7 @@ def resolve_python_classname(iris_classname: str) -> Optional[str]:
 
 
 def load_python_class(
-    python_classname: str, python_classpath: Optional[str] = None
+    python_classname: str, python_classpath: str | None = None
 ) -> type:
     module_name, _, class_name = python_classname.rpartition(".")
     if not module_name:
@@ -306,7 +315,7 @@ def get_python_classpath(klass: type) -> str:
     return classpath
 
 
-def get_iris_object_classname(obj: Any) -> Optional[str]:
+def get_iris_object_classname(obj: Any) -> str | None:
     for method_name in ("%ClassName", "_ClassName"):
         try:
             method = getattr(obj, method_name)
@@ -322,7 +331,7 @@ def get_iris_object_classname(obj: Any) -> Optional[str]:
         return None
 
 
-def _safe_get_object_id(obj: Any) -> Optional[str]:
+def _safe_get_object_id(obj: Any) -> str | None:
     for method_name in ("_Id", "Id", "%Id"):
         try:
             method = getattr(obj, method_name)
@@ -387,7 +396,7 @@ def _cache_mapping(python_classname: str, iris_classname: str) -> None:
 
 def _resolve_python_message_metadata(
     iris_classname: str,
-) -> tuple[Optional[str], Optional[str], bool]:
+) -> tuple[str | None, str | None, bool]:
     cached = _IRIS_TO_PYTHON_CACHE.get(iris_classname)
     if cached:
         return (
@@ -417,7 +426,7 @@ def _resolve_python_message_metadata(
 def get_iris_class_parameter(
     iris_classname: str,
     parameter_name: str,
-) -> Optional[str]:
+) -> str | None:
     key = (iris_classname, parameter_name)
     if key in _IRIS_PARAMETER_CACHE:
         return _IRIS_PARAMETER_CACHE[key]
@@ -511,11 +520,7 @@ def _decode_iris_identifier(value: str) -> str:
 
 
 def _prepend_sys_path(path: str) -> None:
-    normalized_path = os.path.abspath(os.path.normpath(path))
-    while normalized_path in sys.path:
-        sys.path.remove(normalized_path)
-    sys.path.insert(0, normalized_path)
-    importlib.invalidate_caches()
+    prepend_sys_path(path)
 
 
 def _import_module_from_classpath(module_name: str, python_classpath: str):

iop/{_serialization.py → messages/serialization.py}

@@ -1,17 +1,19 @@
 from __future__ import annotations
+
 import codecs
+import copy
 import importlib
 import inspect
-import pickle
 import json
+import pickle
 from dataclasses import is_dataclass
-from typing import Any, Dict, Type
+from typing import Any
 
 from pydantic import BaseModel, TypeAdapter, ValidationError
 
-from . import _iris
-from ._message import _Message
-from ._utils import _Utils
+from ..migration import utils as _migration_utils
+from ..runtime import iris as _iris
+from .base import _Message
 
 
 class SerializationError(Exception):
@@ -20,6 +22,12 @@ class SerializationError(Exception):
     pass
 
 
+class MessageClassImportError(SerializationError, ImportError):
+    """Raised when a JSON message's Python class cannot be imported."""
+
+    pass
+
+
 class TempPydanticModel(BaseModel):
     model_config = {"arbitrary_types_allowed": True, "extra": "allow"}
 
@@ -32,7 +40,6 @@ class MessageSerializer:
         message: Any, use_pickle: bool = False, is_generator: bool = False
     ) -> Any:
         """Serializes a message to IRIS format."""
-        message = remove_iris_id(message)
         if use_pickle:
             return MessageSerializer._serialize_pickle(message, is_generator)
         return MessageSerializer._serialize_json(message, is_generator)
@@ -48,7 +55,7 @@ class MessageSerializer:
         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)
+            msg.json = _migration_utils.string_to_stream(json_string, msg.buffer)
         else:
             msg.json = json_string
         return msg
@@ -63,7 +70,7 @@ class MessageSerializer:
         else:
             msg = _iris.get_iris().cls("IOP.PickleMessage")._New()
         msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
-        msg.jstr = _Utils.string_to_stream(pickle_string)
+        msg.jstr = _migration_utils.string_to_stream(pickle_string)
         return msg
 
     @staticmethod
@@ -92,10 +99,10 @@ class MessageSerializer:
             )
             module = importlib.import_module(module_name)
             msg_class = getattr(module, class_name)
-        except Exception as e:
-            raise SerializationError(
+        except (ModuleNotFoundError, AttributeError, ValueError) as e:
+            raise MessageClassImportError(
                 f"Failed to load class {serial.classname}: {str(e)}"
-            )
+            ) from e
 
         if is_dataclass(msg_class) and issubclass(msg_class, BaseModel):
             raise SerializationError(
@@ -105,7 +112,7 @@ class MessageSerializer:
             )
 
         json_string = (
-            _Utils.stream_to_string(serial.json)
+            _migration_utils.stream_to_string(serial.json)
             if serial.type == "Stream"
             else serial.json
         )
@@ -120,18 +127,21 @@ class MessageSerializer:
                     f"Class {msg_class} must be a Pydantic model or dataclass"
                 )
         except Exception as e:
-            raise SerializationError(f"Failed to deserialize JSON: {str(e)}")
+            raise SerializationError(f"Failed to deserialize JSON: {str(e)}") from e
 
     @staticmethod
     def _deserialize_pickle(serial: Any) -> Any:
-        string = _Utils.stream_to_string(serial.jstr)
+        string = _migration_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(".")
+        try:
+            j = classname.rindex(".")
+        except ValueError as e:
+            raise ValueError(f"Classname must include a module: {classname}") from e
         if j <= 0:
-            raise SerializationError(f"Classname must include a module: {classname}")
+            raise ValueError(f"Classname must include a module: {classname}")
         return classname[:j], classname[j + 1 :]
 
     @staticmethod
@@ -156,18 +166,19 @@ class MessageSerializer:
 
 
 def remove_iris_id(message: Any) -> Any:
+    message = copy.copy(message)
     try:
-        del message._iris_id
+        delattr(message, "_iris_id")
     except AttributeError:
         pass
     return message
 
 
-def dataclass_from_dict(klass: Type | Any, dikt: Dict) -> Any:
+def dataclass_from_dict(klass: type | Any, 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:
+    def process_field(value: Any, field_type: type) -> Any:
         if value is None:
             return None
         if is_dataclass(field_type):
@@ -203,11 +214,13 @@ def dataclass_from_dict(klass: Type | Any, dikt: Dict) -> Any:
     return instance
 
 
-def dataclass_to_dict(instance: Any) -> Dict:
+def dataclass_to_dict(instance: Any) -> dict:
     """Converts a class instance to a dictionary.
     Handles non attended fields."""
     result = {}
     for field in instance.__dict__:
+        if field == "_iris_id":
+            continue
         value = getattr(instance, field)
         if is_dataclass(value):
             result[field] = dataclass_to_dict(value)
@@ -227,7 +240,7 @@ def dataclass_to_dict(instance: Any) -> Dict:
     return result
 
 
-# Maintain backwards compatibility
+# Convenience wrappers used by dispatch and tests.
 def serialize_pickle_message(msg):
     return MessageSerializer.serialize(msg, use_pickle=True, is_generator=False)
 

iop/{_message_validator.py → messages/validation.py}

@@ -1,12 +1,14 @@
 import dataclasses
-from typing import Any, Type
+from typing import Any
 
-from ._message import _Message, _PickleMessage, _PydanticPickleMessage, BaseModel
+from .base import _Message, _PickleMessage, _PydanticMessage, _PydanticPickleMessage
+
+_PYDANTIC_BASE = _PydanticMessage.__mro__[1]
 
 
 def is_message_instance(obj: Any) -> bool:
     """Check if object is a valid Message instance."""
-    if isinstance(obj, BaseModel):
+    if isinstance(obj, _PYDANTIC_BASE):
         return True
     if is_message_class(type(obj)):
         if not dataclasses.is_dataclass(obj):
@@ -36,17 +38,17 @@ def is_iris_object_instance(obj: Any) -> bool:
     # Stream.Object are used for HTTP InboundAdapter/OutboundAdapter
 
 
-def is_message_class(klass: Type) -> bool:
+def is_message_class(klass: type) -> bool:
     """Check if class is a Message type."""
-    if issubclass(klass, _Message):
-        return True
-    return False
+    try:
+        return issubclass(klass, (_Message, _PYDANTIC_BASE))
+    except TypeError:
+        return False
 
 
-def is_pickle_message_class(klass: Type) -> bool:
+def is_pickle_message_class(klass: type) -> bool:
     """Check if class is a PickleMessage type."""
-    if issubclass(klass, _PickleMessage):
-        return True
-    if issubclass(klass, _PydanticPickleMessage):
-        return True
-    return False
+    try:
+        return issubclass(klass, (_PickleMessage, _PydanticPickleMessage))
+    except TypeError:
+        return False

iop/migration/__init__.py

@@ -0,0 +1 @@
+from .utils import _Utils as _Utils

iop/migration/io.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+import xmltodict
+
+
+def dict_to_xml(data: dict[str, Any]) -> str:
+    xml = xmltodict.unparse(data, pretty=True)
+    xml = xml.replace('<?xml version="1.0" encoding="utf-8"?>', "")
+    return xml[1:]
+
+
+def xml_to_json(xml_string: str) -> str:
+    """Convert an XML production export to the JSON shape used by Production."""
+
+    def postprocessor(path, key, value):
+        return key, "" if value is None else value
+
+    data = xmltodict.parse(xml_string, postprocessor=postprocessor)
+    if "Production" in data:
+        production_obj = data["Production"]
+        production_name = production_obj.get("@Name", "Production")
+        data = {production_name: production_obj}
+    return json.dumps(data)
+
+
+def stream_to_string(stream, buffer=1000000) -> str:
+    string = ""
+    stream.Rewind()
+    while not stream.AtEnd:
+        string += stream.Read(buffer)
+    return string
+
+
+def string_to_stream(iris, string: str, buffer=1000000):
+    stream = iris.cls("%Stream.GlobalCharacter")._New()
+    chunks = [string[i : i + buffer] for i in range(0, len(string), buffer)]
+    for chunk in chunks:
+        stream.Write(chunk)
+    return stream
+
+
+def guess_path(module: str, path: str) -> str:
+    """Determine the full file path for a module name under a base path."""
+    if not module:
+        raise ValueError("Module name cannot be empty")
+
+    if module.startswith("."):
+        dot_count = len(module) - len(module.lstrip("."))
+        module = module[dot_count:]
+        for _ in range(dot_count - 1):
+            path = os.path.dirname(path)
+
+    if module.endswith(".py"):
+        module_path = module.replace(".", os.sep)
+    else:
+        module_path = module.replace(".", os.sep) + ".py"
+    return os.path.join(path, module_path)