iris-pex-embedded-python 3.6.1b1__py3-none-any.whl → 3.7.1b1__py3-none-any.whl

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

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

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

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)

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.dist-info → iris_pex_embedded_python-3.7.1b1.dist-info}/METADATA

@@ -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.dist-info → iris_pex_embedded_python-3.7.1b1.dist-info}/RECORD

@@ -19,7 +19,7 @@ grongier/cls/Grongier/PEX/PrivateSession/Message/Poll.cls,sha256=pcUgHgxX1pMH-wQ
 grongier/cls/Grongier/PEX/PrivateSession/Message/Start.cls,sha256=T3jNoR8RjKr1InQ6SgqBYTgFwpSB0Q60WholjbvForg,433
 grongier/cls/Grongier/PEX/PrivateSession/Message/Stop.cls,sha256=zy30ZXXN4XcovPij-kOF3PuH1SkP1EUvlEJQRx2S9RU,431
 grongier/cls/Grongier/Service/WSGI.cls,sha256=7u2SsFmnsubMfdazvaDchKCM3yesPRMfKBzMIkwQ9xc,77
-grongier/pex/__init__.py,sha256=CPLDFa4dusvGX9VZYTUk-M0Xa_yR4e4Gqku1rIT75qo,1060
+grongier/pex/__init__.py,sha256=Gs3S8F1xAXAGxDUFZHh9giJIKJF66Obsuc-jfhU3Rsg,1211
 grongier/pex/__main__.py,sha256=pQzVtkDhAeI6dpNRC632dVk2SGZZIEDwDufdgZe8VWs,98
 grongier/pex/_business_host.py,sha256=dlV8CWJad8Pr2TNfD9OjcVKaq5gEYQACZla1FK6-bDM,44
 grongier/pex/_cli.py,sha256=hOHz3n-aHtULuhdCkqZ_SSb3sv7M6j2WhRxgCTvgR9I,64
@@ -27,7 +27,7 @@ grongier/pex/_common.py,sha256=HZwG2C2-yB8yNN8kXhI6vxg8h-rROuEx38YOVFWIk1s,31
 grongier/pex/_director.py,sha256=pCmoiJ-sxe24yQaDz6ZFBsAnqU6fh57_dlew98B7rtE,35
 grongier/pex/_utils.py,sha256=gvsdr8WhWrE6smlsCxhoF14VUZfitrwqr5J57HkJhi4,29
 grongier/pex/wsgi/handlers.py,sha256=NrFLo_YbAh-x_PlWhAiWkQnUUN2Ss9HoEm63dDWCBpQ,2947
-iop/__init__.py,sha256=1C589HojSVK0yJf1KuTPA39ZjrOYO0QFLv45rqbZpA4,1183
+iop/__init__.py,sha256=XA_tU3-KsFgMaweY2QSVOTWgj7NhRYmW7Mp-nobe-k0,1331
 iop/__main__.py,sha256=pQzVtkDhAeI6dpNRC632dVk2SGZZIEDwDufdgZe8VWs,98
 iop/_async_request.py,sha256=Umx79MHjIE5JV5exxCzKT9ZuJ3YhMHYwjeFyB4gIlU4,2324
 iop/_business_host.py,sha256=asX2z9Jfbwrs-B0TI2-JeXvSsYUMKUUlnJ4-kohZg8U,11280
@@ -40,7 +40,7 @@ iop/_debugpy.py,sha256=EJ3XK29cDQ1mBklEgUwG6HyHYJAmhVa3-8m_FvtbVOs,6008
 iop/_decorators.py,sha256=LpK0AK4GIzXbPFSIw_x6zzM3FwsHvFjgQUh-MnqtTE8,2322
 iop/_director.py,sha256=MVTCLIhxp1bYbDW7K-LEJ7A9fhAAnOZtDNE9pWK3tgE,11462
 iop/_director_protocol.py,sha256=Zn4vqN_N0SBSmo5S2LdI5BO0Fk1ZkZb5YVlNfi-i4wc,2783
-iop/_dispatch.py,sha256=eXElnLGLdc6ondZhTQtKfa7URMkT-QnmqOTwXBSXAsY,4650
+iop/_dispatch.py,sha256=tnkbLvAcK2cH3wE3YvE1VpuiyMmeOhIxZ3Mipjlfklc,5028
 iop/_generator_request.py,sha256=I67JOjfsznN9JlS0bg_D05phcfSXqp6GJlCULJPXKvw,1284
 iop/_inbound_adapter.py,sha256=yG33VfJ2KxSDVxBTQTjFXqdX1fMEic1zxSAOhP5DqTk,1649
 iop/_iris.py,sha256=cw1mIKchXNlUJXSxwMhXYQr8DntJEO1hSPnLyJab10w,204
@@ -49,11 +49,12 @@ iop/_log_manager.py,sha256=SHY2AUBSjh-qZbEHfe0j4c_S8PuU6JFjjmjEX6qnoC4,3407
 iop/_message.py,sha256=iM7LXdhYRGOBEAJu-VH1m9iKyMYtrScWcALc3khmCFY,1465
 iop/_message_validator.py,sha256=ooDFWp8XvqJWP91RDbkFgpA5V3LbNrQO6IMx2vSjoF8,1516
 iop/_outbound_adapter.py,sha256=cN7dkZyx9ED89yUGePsUYsUhlR3ze3w1JorCG8HvDCw,723
+iop/_persistent_message.py,sha256=hAlvzqqnYHaoDxoTu_F401TaE0Kus78q5Eae90XEuvA,16559
 iop/_private_session_duplex.py,sha256=c6Q0k-qnZi_JcIOdpUx1Edu44zVbUE2Kf2aCHM8Eq80,5202
 iop/_private_session_process.py,sha256=rvZFO6nWVwZtaEWJkSHyLTV-vhzDqQhsVi7INQLLwWI,1685
 iop/_remote.py,sha256=7Iz2WxmKBmzEP-Dfkxa7YVq2nrwwmEVquLhCuPeNbjg,17169
 iop/_serialization.py,sha256=mnLnEvkigWBAU2xIoAWW5laSn3W2xH_s7XemBZB0400,8560
-iop/_utils.py,sha256=qdj4pWOgNa2PjTyXShGrGrclbx88J_WJR8zNC-PNIFM,23679
+iop/_utils.py,sha256=tqdlJnc05zw88n2usLgTJUQiamhHIB3CRvFoz3i-F2g,25625
 iop/cls/IOP/BusinessOperation.cls,sha256=NlvbNtm1ZFZmHaMX_9FMKoptY-hQMq5jYN1nLQwvYJw,936
 iop/cls/IOP/BusinessProcess.cls,sha256=XJxzbiV0xokzRm-iI2Be5UIJLE3MlXr7W3WS_LkOCYs,3363
 iop/cls/IOP/BusinessService.cls,sha256=fplKrbQgA7cQgjKIqDR2IK2iD1iNHmT-QvWrozhE4n4,1189
@@ -85,9 +86,9 @@ iop/cls/IOP/Service/WSGI.cls,sha256=VLNCXEwmHW9dBnE51uGE1nvGX6T4HjhqePT3LVhsjAE,
 iop/cls/IOP/Service/Remote/Handler.cls,sha256=JfsXse2jvoVvQfW8_rVEt2DCQJ9SVqReCcOUngOkpzE,938
 iop/cls/IOP/Service/Remote/Rest/v1.cls,sha256=DRaYNsbFmczdVltb-HMZvviy5EcjcJx7__zmnKANNm8,14429
 iop/wsgi/handlers.py,sha256=NrFLo_YbAh-x_PlWhAiWkQnUUN2Ss9HoEm63dDWCBpQ,2947
-iris_pex_embedded_python-3.6.1b1.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-3.6.1b1.dist-info/METADATA,sha256=CMA3iqi8GJIXimiVM13aXKYHXpkJqr0mFuKOpj_HjK0,4447
-iris_pex_embedded_python-3.6.1b1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-iris_pex_embedded_python-3.6.1b1.dist-info/entry_points.txt,sha256=pj-i4LSDyiSP6xpHlVjMCbg1Pik7dC3_sdGY3Yp9Vhk,38
-iris_pex_embedded_python-3.6.1b1.dist-info/top_level.txt,sha256=4p0q6hCATmYIVMVi3I8hOUcJE1kwzyBeHygWv_rGvrU,13
-iris_pex_embedded_python-3.6.1b1.dist-info/RECORD,,
+iris_pex_embedded_python-3.7.1b1.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
+iris_pex_embedded_python-3.7.1b1.dist-info/METADATA,sha256=zoK-1dOfnusytNLr4ijEbP_16LiUKqCMs3xB9mdPi14,4310
+iris_pex_embedded_python-3.7.1b1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+iris_pex_embedded_python-3.7.1b1.dist-info/entry_points.txt,sha256=pj-i4LSDyiSP6xpHlVjMCbg1Pik7dC3_sdGY3Yp9Vhk,38
+iris_pex_embedded_python-3.7.1b1.dist-info/top_level.txt,sha256=4p0q6hCATmYIVMVi3I8hOUcJE1kwzyBeHygWv_rGvrU,13
+iris_pex_embedded_python-3.7.1b1.dist-info/RECORD,,