iris-pex-embedded-python 3.6.1b1__tar.gz → 3.7.1b1__tar.gz

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 3.6.1b1
+Version: 3.7.1b1
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -34,19 +34,17 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Utilities
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: xmltodict>=0.12.0
 Requires-Dist: iris-embedded-python-wrapper>=0.0.6
+Requires-Dist: iris-persistence>=0.1.0
 Requires-Dist: jsonpath-ng>=1.7.0
 Requires-Dist: debugpy>=1.8.0
 Requires-Dist: requests>=2.24.0

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/pyproject.toml

@@ -3,9 +3,10 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.6.1b1"
+version = "3.7.1b1"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
+requires-python = ">=3.10"
 authors = [
     { name = "grongier", email = "guillaume.rongier@intersystems.com" },
 ]
@@ -16,10 +17,6 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.6",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -30,6 +27,7 @@ dependencies = [
     "pydantic>=2.0.0",
     "xmltodict>=0.12.0",
     "iris-embedded-python-wrapper>=0.0.6",
+    "iris-persistence>=0.1.0",
     "jsonpath-ng>=1.7.0",
     "debugpy>=1.8.0",
     "requests>=2.24.0"
@@ -51,7 +49,7 @@ where = ["src"]
 exclude = ["tests*"]
 
 [tool.setuptools.package-data]
-"*" = ["*.cls"]
+"*" = ["*.cls", "cls/**/*.cls"]
 
 [tool.pytest.ini_options]
 asyncio_default_fixture_loop_scope = "class"
@@ -60,4 +58,4 @@ markers = [
     "unit: pure unit test - no IRIS instance required (all IRIS calls mocked)",
     "e2e_local: end-to-end test requiring a local IRIS instance",
     "e2e_remote: end-to-end test requiring a remote IRIS instance via REST API",
-]
+]

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/src/grongier/pex/__init__.py

@@ -5,10 +5,11 @@ from iop._private_session_process import _PrivateSessionProcess
 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._message import _PickleMessage
-from iop._director import _Director
-from iop._utils import _Utils
+from iop._message import _Message
+from iop._message import _PickleMessage
+from iop._persistent_message import Field, Model, _PersistentMessage
+from iop._director import _Director
+from iop._utils import _Utils
 
 class Utils(_Utils): pass
 class InboundAdapter(_InboundAdapter): pass
@@ -19,6 +20,8 @@ class BusinessProcess(_BusinessProcess): pass
 class DuplexService(_PrivateSessionDuplex): pass
 class DuplexOperation(_PrivateSessionDuplex): pass
 class DuplexProcess(_PrivateSessionProcess): pass
-class Message(_Message): pass
-class PickleMessage(_PickleMessage): pass
-class Director(_Director): pass
+class Message(_Message): pass
+class PickleMessage(_PickleMessage): pass
+class PersistentMessage(_PersistentMessage):
+    _iop_persistent_message_abstract = True
+class Director(_Director): pass

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/src/iop/__init__.py

@@ -2,12 +2,13 @@ from iop._business_operation import _BusinessOperation
 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, _PickleMessage, _PydanticMessage, _PydanticPickleMessage
-from iop._outbound_adapter import _OutboundAdapter
-from iop._private_session_duplex import _PrivateSessionDuplex
-from iop._private_session_process import _PrivateSessionProcess
-from iop._utils import _Utils
+from iop._inbound_adapter import _InboundAdapter
+from iop._message import _Message, _PickleMessage, _PydanticMessage, _PydanticPickleMessage
+from iop._outbound_adapter import _OutboundAdapter
+from iop._persistent_message import Field, Model, _PersistentMessage
+from iop._private_session_duplex import _PrivateSessionDuplex
+from iop._private_session_process import _PrivateSessionProcess
+from iop._utils import _Utils
 
 class Utils(_Utils): pass
 class InboundAdapter(_InboundAdapter): pass
@@ -19,7 +20,9 @@ class DuplexService(_PrivateSessionDuplex): pass
 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
+class PickleMessage(_PickleMessage): pass
+class PydanticMessage(_PydanticMessage): pass
+class PydanticPickleMessage(_PydanticPickleMessage): pass
+class PersistentMessage(_PersistentMessage):
+    _iop_persistent_message_abstract = True
+class Director(_Director): pass

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/src/iop/_dispatch.py

@@ -3,6 +3,11 @@ from typing import Any, List, Tuple, Callable
 
 from ._serialization import serialize_message, serialize_pickle_message, deserialize_message, deserialize_pickle_message, serialize_message_generator, serialize_pickle_message_generator
 from ._message_validator import is_message_instance, is_pickle_message_instance, is_iris_object_instance
+from ._persistent_message import (
+    deserialize_persistent_message,
+    is_persistent_message_instance,
+    serialize_persistent_message,
+)
 
 def dispatch_serializer(message: Any, is_generator: bool = False) -> Any:
     """Serializes the message based on its type.
@@ -17,7 +22,9 @@ def dispatch_serializer(message: Any, is_generator: bool = False) -> Any:
         TypeError: If message is invalid type
     """
     if message is not None:
-        if is_message_instance(message):
+        if is_persistent_message_instance(message):
+            return serialize_persistent_message(message, is_generator=is_generator)
+        elif is_message_instance(message):
             if is_generator:
                 return serialize_message_generator(message)
             return serialize_message(message)
@@ -63,6 +70,8 @@ def dispatch_deserializer(serial: Any) -> Any:
         )
     ):
         return deserialize_pickle_message(serial)
+    elif is_iris_object_instance(serial):
+        return deserialize_persistent_message(serial)
     else:
         return serial
 
@@ -133,4 +142,4 @@ def get_handler_info(host: Any, method_name: str) -> Tuple[str, str] | None:
         return f"{annotation.__module__}.{annotation.__name__}", method_name
             
     except ValueError:
-        return None
+        return None

iris_pex_embedded_python-3.7.1b1/src/iop/_persistent_message.py

@@ -0,0 +1,513 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import os
+import sys
+from typing import Any, Optional
+
+from iris_persistence import Field, Model
+from iris_persistence.models import ModelMeta
+from iris_persistence.query import _build_model_from_iris_obj, _materialize_related_value
+from iris_persistence.runtime import get_runtime
+
+
+DEFAULT_SUPERCLASS = "Ens.MessageBody"
+DEFAULT_SYNC_MODE = "extend"
+MESSAGE_KIND_PARAMETER = "IOP_MESSAGE_KIND"
+MESSAGE_KIND_VALUE = "PersistentMessage"
+PYTHON_CLASS_PARAMETER = "IOP_PYTHON_CLASS"
+PYTHON_CLASSPATH_PARAMETER = "IOP_PYTHON_CLASSPATH"
+
+_PYTHON_TO_IRIS_CACHE: dict[str, str] = {}
+_IRIS_TO_PYTHON_CACHE: dict[str, str] = {}
+_IRIS_TO_PYTHON_CLASSPATH_CACHE: dict[str, str] = {}
+_IRIS_TO_PYTHON_STRICT_CACHE: dict[str, bool] = {}
+_IRIS_PARAMETER_CACHE: dict[tuple[str, str], Optional[str]] = {}
+_AUTO_SYNCED: set[tuple[type, str]] = set()
+
+
+class PersistentMessageError(Exception):
+    """Raised when a native persistent message cannot be materialized."""
+
+
+class _PersistentMessageMeta(ModelMeta):
+    def __init__(cls, name: str, bases: tuple, namespace: dict, **kwargs: Any):
+        super().__init__(name, bases, namespace, **kwargs)
+
+        if namespace.get("_iop_persistent_message_abstract", False):
+            cls._iop_persistent_message_base = True
+            cls._iop_persistent_message_abstract = True
+            return
+
+        if not any(getattr(base, "_iop_persistent_message_base", False) for base in bases):
+            cls._iop_persistent_message_base = True
+            cls._iop_persistent_message_abstract = True
+            return
+
+        _apply_persistent_message_defaults(cls, namespace, kwargs)
+        cls._iop_persistent_message_base = True
+        cls._iop_persistent_message_abstract = False
+
+
+def _explicit_meta_classname(cls: type) -> Optional[str]:
+    meta = cls.__dict__.get("Meta")
+    if meta is None or not hasattr(meta, "classname"):
+        return None
+    value = getattr(meta, "classname")
+    return str(value) if value else None
+
+
+def _apply_persistent_message_defaults(
+    cls: type,
+    namespace: Optional[dict] = None,
+    kwargs: Optional[dict] = None,
+) -> None:
+    namespace = namespace or {}
+    kwargs = kwargs or {}
+    meta = namespace.get("Meta") or cls.__dict__.get("Meta")
+
+    has_superclasses = "superclasses" in kwargs or (
+        meta is not None and hasattr(meta, "superclasses")
+    )
+    has_classname = meta is not None and hasattr(meta, "classname")
+    has_mode = meta is not None and hasattr(meta, "mode")
+    has_auto_sync = meta is not None and hasattr(meta, "auto_sync")
+
+    if not has_superclasses:
+        cls._superclasses = DEFAULT_SUPERCLASS
+    if not has_classname and not getattr(cls, "_iop_registered_classname", None):
+        cls._classname = python_classname_to_iris_classname(get_python_classname(cls))
+    if not has_mode:
+        cls._sync_mode = DEFAULT_SYNC_MODE
+    if not has_auto_sync:
+        cls._auto_sync = True
+    _set_message_parameters(cls)
+
+
+class _PersistentMessage(Model, metaclass=_PersistentMessageMeta):
+    _iop_persistent_message_abstract = True
+
+    def get_iris_id(self) -> Optional[str]:
+        if self.pk:
+            return self.pk
+
+        iris_obj = self.__dict__.get("_iris_obj")
+        if iris_obj is None:
+            return None
+
+        try:
+            obj_id = get_runtime().get_object_id(iris_obj)
+            if obj_id:
+                return str(obj_id)
+        except Exception:
+            pass
+
+        for method_name in ("_Id", "Id", "%Id"):
+            try:
+                method = getattr(iris_obj, method_name)
+                obj_id = method()
+                if obj_id:
+                    return str(obj_id)
+            except Exception:
+                pass
+        return None
+
+
+def is_persistent_message_class(klass: Any) -> bool:
+    try:
+        return (
+            isinstance(klass, type)
+            and issubclass(klass, _PersistentMessage)
+            and not getattr(klass, "_iop_persistent_message_abstract", False)
+        )
+    except TypeError:
+        return False
+
+
+def is_persistent_message_instance(obj: Any) -> bool:
+    return is_persistent_message_class(type(obj))
+
+
+def get_python_classname(klass: type) -> str:
+    return f"{klass.__module__}.{klass.__name__}"
+
+
+def python_classname_to_iris_classname(python_classname: str) -> str:
+    """Encode a Python FQCN as an IRIS-safe classname."""
+    if not python_classname:
+        raise ValueError("Python classname cannot be empty")
+    return ".".join(_encode_iris_identifier(part) for part in python_classname.split("."))
+
+
+def iris_classname_to_python_classname(iris_classname: str) -> str:
+    """Decode an IRIS classname produced by python_classname_to_iris_classname."""
+    if not iris_classname:
+        raise ValueError("IRIS classname cannot be empty")
+    return ".".join(_decode_iris_identifier(part) for part in iris_classname.split("."))
+
+
+def register_persistent_message_class(
+    msg_cls: type,
+    iris_classname: str,
+    *,
+    sync_schema: bool = True,
+) -> None:
+    if not is_persistent_message_class(msg_cls):
+        raise TypeError("The class must be a subclass of PersistentMessage")
+    if not iris_classname:
+        raise ValueError("PersistentMessage IRIS classname cannot be empty")
+
+    explicit_classname = _explicit_meta_classname(msg_cls)
+    if explicit_classname and explicit_classname != iris_classname:
+        raise ValueError(
+            f"{get_python_classname(msg_cls)} declares Meta.classname={explicit_classname!r}, "
+            f"but CLASSES registers it as {iris_classname!r}"
+        )
+
+    _prepare_message_class(msg_cls, iris_classname, registered=True)
+
+    if sync_schema:
+        msg_cls.sync_schema()
+
+
+def serialize_persistent_message(message: _PersistentMessage, is_generator: bool = False) -> Any:
+    if is_generator:
+        raise TypeError("PersistentMessage cannot be used as a generator start message.")
+
+    msg_cls = type(message)
+    iris_classname = resolve_iris_classname(msg_cls)
+    _ensure_schema(msg_cls, iris_classname)
+
+    runtime = get_runtime()
+    iris_obj = message.__dict__.get("_iris_obj")
+    if iris_obj is None:
+        iris_obj = runtime.create_object(iris_classname)
+
+    for field_name, model_field in msg_cls.__model_fields__.items():
+        if field_name not in message.__dict__:
+            continue
+        value = getattr(message, field_name)
+        materialized = _materialize_related_value(runtime, model_field.declared_type, value)
+        runtime.inject_iris_value(
+            iris_obj,
+            field_name,
+            materialized,
+            field_meta=model_field.field_info,
+        )
+
+    message._iris_obj = iris_obj
+    try:
+        obj_id = runtime.get_object_id(iris_obj)
+        if obj_id:
+            message._pk = str(obj_id)
+    except Exception:
+        pass
+    return iris_obj
+
+
+def deserialize_persistent_message(serial: Any) -> Any:
+    iris_classname = get_iris_object_classname(serial)
+    if not iris_classname:
+        return serial
+
+    python_classname, python_classpath, strict = _resolve_python_message_metadata(
+        iris_classname
+    )
+    if not python_classname:
+        return serial
+
+    try:
+        msg_cls = load_python_class(python_classname, python_classpath)
+    except (AttributeError, ModuleNotFoundError, PersistentMessageError) as exc:
+        if strict:
+            raise PersistentMessageError(
+                f"IRIS class {iris_classname!r} is marked as a PersistentMessage for "
+                f"Python class {python_classname!r}, but that Python class could not "
+                "be imported. Ensure the message class is importable, or register it "
+                "through CLASSES so migration writes IOP_PYTHON_CLASSPATH."
+            ) from exc
+        return serial
+
+    if not is_persistent_message_class(msg_cls):
+        if strict:
+            raise PersistentMessageError(
+                f"IRIS class {iris_classname!r} maps to {python_classname!r}, "
+                "but that class is not a PersistentMessage subclass."
+            )
+        return serial
+
+    _prepare_message_class(msg_cls, iris_classname, registered=False)
+
+    known_pk = _safe_get_object_id(serial)
+    return _build_model_from_iris_obj(msg_cls, serial, known_pk=known_pk or "")
+
+
+def resolve_iris_classname(msg_cls: type) -> str:
+    python_classname = get_python_classname(msg_cls)
+
+    cached = _PYTHON_TO_IRIS_CACHE.get(python_classname)
+    if cached:
+        return cached
+
+    registered = getattr(msg_cls, "_iop_registered_classname", None)
+    if registered:
+        _cache_mapping(python_classname, registered)
+        return registered
+
+    explicit_classname = _explicit_meta_classname(msg_cls)
+    if explicit_classname:
+        _prepare_message_class(msg_cls, explicit_classname, registered=False)
+        return explicit_classname
+
+    iris_classname = python_classname_to_iris_classname(python_classname)
+    _prepare_message_class(msg_cls, iris_classname, registered=False)
+    return iris_classname
+
+
+def resolve_python_classname(iris_classname: str) -> Optional[str]:
+    python_classname, _python_classpath, _strict = _resolve_python_message_metadata(
+        iris_classname
+    )
+    return python_classname
+
+
+def load_python_class(python_classname: str, python_classpath: Optional[str] = None) -> type:
+    module_name, _, class_name = python_classname.rpartition(".")
+    if not module_name:
+        raise PersistentMessageError(
+            f"PersistentMessage Python classname {python_classname!r} is not fully qualified"
+        )
+    try:
+        module = importlib.import_module(module_name)
+    except ModuleNotFoundError as exc:
+        if not python_classpath or not _is_missing_target_module(exc, module_name):
+            raise
+        _prepend_sys_path(python_classpath)
+        module = importlib.import_module(module_name)
+    return getattr(module, class_name)
+
+
+def get_python_classpath(klass: type) -> str:
+    try:
+        class_file = inspect.getfile(klass)
+    except TypeError:
+        return ""
+
+    if not class_file:
+        return ""
+
+    classpath = os.path.abspath(os.path.dirname(class_file))
+    module_parts = klass.__module__.split(".")
+    for _ in module_parts[:-1]:
+        classpath = os.path.dirname(classpath)
+    return classpath
+
+
+def get_iris_object_classname(obj: Any) -> Optional[str]:
+    for method_name in ("%ClassName", "_ClassName"):
+        try:
+            method = getattr(obj, method_name)
+            value = method(1)
+            if value:
+                return str(value)
+        except Exception:
+            pass
+    try:
+        value = obj.__class__.__name__
+        return str(value) if value else None
+    except Exception:
+        return None
+
+
+def _safe_get_object_id(obj: Any) -> Optional[str]:
+    for method_name in ("_Id", "Id", "%Id"):
+        try:
+            method = getattr(obj, method_name)
+            obj_id = method()
+            if obj_id:
+                return str(obj_id)
+        except Exception:
+            pass
+    return None
+
+
+def _ensure_schema(msg_cls: type, iris_classname: str) -> None:
+    if not getattr(msg_cls, "_auto_sync", False):
+        return
+    if getattr(msg_cls, "_sync_mode", DEFAULT_SYNC_MODE) != DEFAULT_SYNC_MODE:
+        raise PersistentMessageError(
+            f"{get_python_classname(msg_cls)} has auto_sync=True but mode="
+            f"{getattr(msg_cls, '_sync_mode', None)!r}. Runtime auto-sync is only allowed "
+            "with mode='extend'."
+        )
+
+    key = (msg_cls, iris_classname)
+    if key in _AUTO_SYNCED:
+        return
+
+    _prepare_message_class(msg_cls, iris_classname, registered=False)
+    msg_cls.sync_schema()
+    _AUTO_SYNCED.add(key)
+
+
+def _prepare_message_class(
+    msg_cls: type,
+    iris_classname: str,
+    *,
+    registered: bool,
+) -> None:
+    _apply_persistent_message_defaults(msg_cls)
+    msg_cls._classname = iris_classname
+    if registered:
+        msg_cls._iop_registered_classname = iris_classname
+    _set_message_parameters(msg_cls)
+    _cache_mapping(get_python_classname(msg_cls), iris_classname)
+
+
+def _set_message_parameters(msg_cls: type) -> None:
+    parameters = dict(getattr(msg_cls, "_parameters", {}) or {})
+    parameters.update(
+        {
+            MESSAGE_KIND_PARAMETER: MESSAGE_KIND_VALUE,
+            PYTHON_CLASS_PARAMETER: get_python_classname(msg_cls),
+            PYTHON_CLASSPATH_PARAMETER: get_python_classpath(msg_cls),
+        }
+    )
+    msg_cls._parameters = parameters
+
+
+def _cache_mapping(python_classname: str, iris_classname: str) -> None:
+    _PYTHON_TO_IRIS_CACHE[python_classname] = iris_classname
+    _IRIS_TO_PYTHON_CACHE[iris_classname] = python_classname
+    _IRIS_TO_PYTHON_STRICT_CACHE[iris_classname] = True
+
+
+def _resolve_python_message_metadata(
+    iris_classname: str,
+) -> tuple[Optional[str], Optional[str], bool]:
+    cached = _IRIS_TO_PYTHON_CACHE.get(iris_classname)
+    if cached:
+        return (
+            cached,
+            _IRIS_TO_PYTHON_CLASSPATH_CACHE.get(iris_classname),
+            _IRIS_TO_PYTHON_STRICT_CACHE.get(iris_classname, True),
+        )
+
+    kind = get_iris_class_parameter(iris_classname, MESSAGE_KIND_PARAMETER)
+    python_classname = get_iris_class_parameter(iris_classname, PYTHON_CLASS_PARAMETER)
+    python_classpath = get_iris_class_parameter(iris_classname, PYTHON_CLASSPATH_PARAMETER)
+    strict = kind == MESSAGE_KIND_VALUE or bool(python_classname)
+
+    if not python_classname:
+        python_classname = iris_classname_to_python_classname(iris_classname)
+
+    if python_classname and strict:
+        _cache_mapping(python_classname, iris_classname)
+        if python_classpath:
+            _IRIS_TO_PYTHON_CLASSPATH_CACHE[iris_classname] = python_classpath
+
+    return python_classname, python_classpath, strict
+
+
+def get_iris_class_parameter(
+    iris_classname: str,
+    parameter_name: str,
+) -> Optional[str]:
+    key = (iris_classname, parameter_name)
+    if key in _IRIS_PARAMETER_CACHE:
+        return _IRIS_PARAMETER_CACHE[key]
+
+    value = None
+    runtime = get_runtime()
+    for method_name in ("_GetParameter", "%GetParameter"):
+        try:
+            raw_value = runtime.call_classmethod(
+                iris_classname,
+                method_name,
+                parameter_name,
+            )
+        except Exception:
+            continue
+        if raw_value:
+            value = str(raw_value)
+            break
+
+    if value is not None:
+        _IRIS_PARAMETER_CACHE[key] = value
+    return value
+
+
+def _is_missing_target_module(exc: ModuleNotFoundError, module_name: str) -> bool:
+    missing_name = getattr(exc, "name", None)
+    return bool(
+        missing_name
+        and (module_name == missing_name or module_name.startswith(f"{missing_name}."))
+    )
+
+
+def _encode_iris_identifier(value: str) -> str:
+    if not value:
+        raise ValueError("IRIS classname parts cannot be empty")
+
+    encoded: list[str] = []
+    for char in value:
+        if char == "z":
+            encoded.append("zz")
+        elif char == "_":
+            encoded.append("zU")
+        elif char.isascii() and char.isalnum():
+            encoded.append(char)
+        else:
+            encoded.append(f"zX{ord(char):X}z")
+
+    return "".join(encoded)
+
+
+def _decode_iris_identifier(value: str) -> str:
+    decoded: list[str] = []
+    index = 0
+    while index < len(value):
+        char = value[index]
+        if char != "z":
+            decoded.append(char)
+            index += 1
+            continue
+
+        if index + 1 >= len(value):
+            decoded.append(char)
+            index += 1
+            continue
+
+        marker = value[index + 1]
+        if marker == "z":
+            decoded.append("z")
+            index += 2
+        elif marker == "U":
+            decoded.append("_")
+            index += 2
+        elif marker == "X":
+            end = value.find("z", index + 2)
+            if end == -1:
+                decoded.append(char)
+                index += 1
+                continue
+            try:
+                decoded.append(chr(int(value[index + 2 : end], 16)))
+            except ValueError:
+                decoded.append(char)
+                index += 1
+                continue
+            index = end + 1
+        else:
+            decoded.append(char)
+            index += 1
+
+    return "".join(decoded)
+
+
+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)

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/src/iop/_utils.py

@@ -13,6 +13,10 @@ from pydantic import TypeAdapter
 
 from . import _iris
 from ._message import _Message, _PydanticMessage
+from ._persistent_message import (
+    is_persistent_message_class,
+    register_persistent_message_class,
+)
 
 class _Utils():
     @staticmethod
@@ -84,6 +88,17 @@ class _Utils():
         """
         _Utils.raise_on_error(_iris.get_iris().cls('IOP.Message.JSONSchema').Import(schema_str,categories,schema_name))
 
+    @staticmethod
+    def register_persistent_message(msg_cls: type, iris_classname: str, sync_schema: bool = True):
+        """
+        Register a PersistentMessage as a native IRIS message body class.
+
+        :param msg_cls: PersistentMessage subclass to register
+        :param iris_classname: IRIS class name to generate, usually the CLASSES key
+        :param sync_schema: when True, sync the IRIS schema immediately
+        """
+        register_persistent_message_class(msg_cls, iris_classname, sync_schema=sync_schema)
+
     @staticmethod
     def get_python_settings() -> Tuple[str,str,str]:
         import iris_utils._cli
@@ -384,6 +399,9 @@ class _Utils():
         """
         for key, value in class_items.items():
             if inspect.isclass(value):
+                if is_persistent_message_class(value):
+                    _Utils.register_persistent_message(value, key)
+                    continue
                 path = None
                 if root_path:
                     path = root_path
@@ -401,6 +419,10 @@ class _Utils():
             elif isinstance(value,dict):
                 # if the dict has a key 'path' and a key 'module' and a key 'class'
                 if 'path' in value and 'module' in value and 'class' in value:
+                    msg_cls = _Utils._try_import_class(value['module'], value['class'], value['path'])
+                    if msg_cls is not None and is_persistent_message_class(msg_cls):
+                        _Utils.register_persistent_message(msg_cls, key)
+                        continue
                     # register the component
                     _Utils.register_component(value['module'],value['class'],value['path'],1,key)
                 # if the dict has a key 'path' and a key 'package'
@@ -418,6 +440,31 @@ class _Utils():
                 else:
                     raise ValueError(f"Invalid value for {key}.")
 
+    @staticmethod
+    def _try_import_class(module_name: str, class_name: str, path: str):
+        remove_path = False
+        try:
+            path = os.path.abspath(os.path.normpath(path))
+            fullpath = _Utils.guess_path(module_name, path)
+            if path not in sys.path:
+                sys.path.insert(0, path)
+                remove_path = True
+            else:
+                remove_path = False
+            try:
+                module = _Utils.import_module_from_path(module_name, fullpath)
+            except Exception:
+                module = importlib.import_module(module_name)
+            return getattr(module, class_name)
+        except Exception:
+            return None
+        finally:
+            try:
+                if remove_path:
+                    sys.path.remove(path)
+            except Exception:
+                pass
+
     @staticmethod
     def set_productions_settings(production_list,root_path=None):
         """
@@ -582,4 +629,4 @@ class _Utils():
             module_path = module.replace(".", os.sep)
         else:
             module_path = module.replace(".", os.sep) + ".py"
-        return os.path.join(path, module_path)
+        return os.path.join(path, module_path)

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/src/iris_pex_embedded_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 3.6.1b1
+Version: 3.7.1b1
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -34,19 +34,17 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Utilities
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: xmltodict>=0.12.0
 Requires-Dist: iris-embedded-python-wrapper>=0.0.6
+Requires-Dist: iris-persistence>=0.1.0
 Requires-Dist: jsonpath-ng>=1.7.0
 Requires-Dist: debugpy>=1.8.0
 Requires-Dist: requests>=2.24.0

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/src/iris_pex_embedded_python.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ src/iop/_log_manager.py
 src/iop/_message.py
 src/iop/_message_validator.py
 src/iop/_outbound_adapter.py
+src/iop/_persistent_message.py
 src/iop/_private_session_duplex.py
 src/iop/_private_session_process.py
 src/iop/_remote.py

{iris_pex_embedded_python-3.6.1b1 → iris_pex_embedded_python-3.7.1b1}/src/iris_pex_embedded_python.egg-info/requires.txt

@@ -1,6 +1,7 @@
 pydantic>=2.0.0
 xmltodict>=0.12.0
 iris-embedded-python-wrapper>=0.0.6
+iris-persistence>=0.1.0
 jsonpath-ng>=1.7.0
 debugpy>=1.8.0
 requests>=2.24.0