iris-pex-embedded-python 4.0.2b1__py3-none-any.whl → 4.1.0b1__py3-none-any.whl

iop/cli/formatting.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import json
-from typing import Any
+from typing import Any, cast
 
 
 def format_test_response(response: Any) -> str:
@@ -41,5 +41,5 @@ def format_test_response(response: Any) -> str:
             return response
 
     if dataclasses.is_dataclass(response):
-        return json.dumps(dataclasses.asdict(response), indent=4)
+        return json.dumps(dataclasses.asdict(cast(Any, response)), indent=4)
     return str(response)

iop/cli/main.py

@@ -241,6 +241,8 @@ class Command:
             if self.args.export == "not_set"
             else self.args.export
         )
+        if not export_name:
+            raise ValueError("No production name was provided or configured.")
         export_format = self.args.export_format or "json"
         if export_format == "json":
             print(json.dumps(self.director.export_production(export_name), indent=4))

iop/components/async_request.py

@@ -30,37 +30,48 @@ class AsyncRequest(asyncio.Future):
         if host is None:
             raise ValueError("host parameter cannot be None")
         self._iris_handle = host.iris_handle
-        asyncio.create_task(self.send())
+        self._message_header_id = 0
+        self._queue_name = ""
+        self._end_time = 0
+        self._response = None
+        self._done = False
+        self._send_task = asyncio.create_task(self.send())
 
     async def send(self) -> None:
-        # init parameters
-        iris = _iris.get_iris()
-        message_header_id = iris.ref()
-        queue_name = iris.ref()
-        end_time = iris.ref()
-        request = dispatch_serializer(self.request)
+        try:
+            iris = _iris.get_iris()
+            message_header_id = iris.ref()
+            queue_name = iris.ref()
+            end_time = iris.ref()
+            request = dispatch_serializer(self.request)
 
-        # send request
-        self._iris_handle.dispatchSendRequestAsyncNG(
-            self.target,
-            request,
-            self.timeout,
-            self.description,
-            message_header_id,
-            queue_name,
-            end_time,
-        )
+            self._iris_handle.dispatchSendRequestAsyncNG(
+                self.target,
+                request,
+                self.timeout,
+                self.description,
+                message_header_id,
+                queue_name,
+                end_time,
+            )
 
-        # get byref values
-        self._message_header_id = message_header_id.value
-        self._queue_name = queue_name.value
-        self._end_time = end_time.value
+            self._message_header_id = message_header_id.value
+            self._queue_name = queue_name.value
+            self._end_time = end_time.value
 
-        while not self._done:
-            await asyncio.sleep(0.1)
-            self.is_done()
+            while not self._done:
+                await asyncio.sleep(0.1)
+                self.is_done()
 
-        self.set_result(self._response)
+            if not self.done():
+                self.set_result(self._response)
+        except asyncio.CancelledError:
+            if not self.done():
+                self.cancel()
+            raise
+        except Exception as exc:
+            if not self.done():
+                self.set_exception(exc)
 
     def is_done(self) -> None:
         iris = _iris.get_iris()

iop/components/debugpy.py

@@ -127,7 +127,10 @@ def debugpython(self, host_object: Any) -> None:
         return
 
     if not is_debugpy_installed():
-        self.log_alert("Debugpy is not installed.")
+        self.log_alert(
+            "Debugpy is not installed. Install iris-pex-embedded-python[debug] "
+            "to enable remote debugging."
+        )
         return
 
     # Configure Python interpreter
@@ -167,7 +170,10 @@ def debugpy_in_iris(iris_dir, port) -> bool:
         os.__file__ = __file__
 
     if not is_debugpy_installed():
-        print("debugpy is not installed.")
+        print(
+            "debugpy is not installed. Install iris-pex-embedded-python[debug] "
+            "to enable remote debugging."
+        )
         return False
     if not iris_dir:
         print("IRIS directory is not specified.")

iop/messages/persistent.py

@@ -4,18 +4,19 @@ import importlib
 import inspect
 import os
 import sys
+from dataclasses import dataclass
+from enum import Enum
 from typing import Any
 
-import iris_persistence
 from iris_persistence import Field as Field
-from iris_persistence import Model
+from iris_persistence import Model as _PersistenceModel
 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"
+DEFAULT_SYNC_MODE = "managed"
 MESSAGE_KIND_PARAMETER = "IOP_MESSAGE_KIND"
 MESSAGE_KIND_VALUE = "PersistentMessage"
 PYTHON_CLASS_PARAMETER = "IOP_PYTHON_CLASS"
@@ -28,13 +29,46 @@ _IRIS_TO_PYTHON_STRICT_CACHE: dict[str, bool] = {}
 _IRIS_TO_MESSAGE_CLASS_CACHE: dict[str, type] = {}
 _IRIS_PARAMETER_CACHE: dict[tuple[str, str], str | None] = {}
 _AUTO_SYNCED: set[tuple[type, str]] = set()
+_CACHE_VALUE_UNSET = object()
 
 
 class PersistentMessageError(Exception):
     """Raised when a native persistent message cannot be materialized."""
 
 
-class _PersistentMessageMeta(ModelMeta):
+class _PersistentMessageResolutionState(Enum):
+    UNMAPPED = "unmapped"
+    RESOLVED = "resolved"
+    INVALID = "invalid"
+
+
+@dataclass(frozen=True)
+class _PersistentMessageResolution:
+    state: _PersistentMessageResolutionState
+    message_class: type | None = None
+    error: PersistentMessageError | None = None
+
+
+def _materialize_deferred_annotations(namespace: dict) -> None:
+    """Expose Python 3.14 deferred annotations to iris-persistence."""
+    if "__annotations__" in namespace:
+        return
+    annotate = namespace.get("__annotate_func__")
+    if annotate is not None:
+        namespace["__annotations__"] = annotate(1)
+
+
+class _ModelMeta(ModelMeta):
+    def __new__(mcs, name: str, bases: tuple, namespace: dict, **kwargs: Any):
+        _materialize_deferred_annotations(namespace)
+        return super().__new__(mcs, name, bases, namespace, **kwargs)
+
+
+class Model(_PersistenceModel, metaclass=_ModelMeta):
+    """Python 3.10–3.14 compatible public persistence model base."""
+
+
+class _PersistentMessageMeta(_ModelMeta):
     def __init__(cls, name: str, bases: tuple, namespace: dict, **kwargs: Any):
         super().__init__(name, bases, namespace, **kwargs)
 
@@ -199,8 +233,7 @@ def serialize_persistent_message(
     iris_classname = resolve_iris_classname(msg_cls)
     _ensure_schema(msg_cls, iris_classname)
 
-    iris_obj = iris_persistence.materialize(
-        message,
+    iris_obj = message.to_iris(
         auto_sync=False,
         validate=False,
     )
@@ -215,36 +248,14 @@ def deserialize_persistent_message(
     if not iris_classname:
         return serial
 
-    msg_cls = _IRIS_TO_MESSAGE_CLASS_CACHE.get(iris_classname)
-    if msg_cls is None:
-        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)
-        _IRIS_TO_MESSAGE_CLASS_CACHE[iris_classname] = msg_cls
+    resolution = _resolve_persistent_message_class(iris_classname)
+    if resolution.state is _PersistentMessageResolutionState.UNMAPPED:
+        return serial
+    if resolution.state is _PersistentMessageResolutionState.INVALID:
+        assert resolution.error is not None
+        raise resolution.error
+    msg_cls = resolution.message_class
+    assert msg_cls is not None
 
     known_pk = _safe_get_object_id(serial)
     return msg_cls.from_iris(serial, known_pk=known_pk or "")
@@ -353,7 +364,7 @@ def _ensure_schema(msg_cls: type, iris_classname: str) -> None:
         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'."
+            "with mode='managed'."
         )
 
     _prepare_message_class(msg_cls, iris_classname, registered=False)
@@ -372,8 +383,12 @@ def _prepare_message_class(
     if registered:
         msg_cls._iop_registered_classname = iris_classname
     _set_message_parameters(msg_cls)
-    _cache_mapping(get_python_classname(msg_cls), iris_classname)
-    _IRIS_TO_MESSAGE_CLASS_CACHE[iris_classname] = msg_cls
+    _cache_mapping(
+        get_python_classname(msg_cls),
+        iris_classname,
+        python_classpath=get_python_classpath(msg_cls),
+        message_class=msg_cls,
+    )
 
 
 def _set_message_parameters(msg_cls: type) -> None:
@@ -388,10 +403,37 @@ def _set_message_parameters(msg_cls: type) -> None:
     msg_cls._parameters = parameters
 
 
-def _cache_mapping(python_classname: str, iris_classname: str) -> None:
+def _cache_mapping(
+    python_classname: str,
+    iris_classname: str,
+    *,
+    python_classpath: str | None | object = _CACHE_VALUE_UNSET,
+    strict: bool = True,
+    message_class: type | None = None,
+) -> None:
+    previous_iris = _PYTHON_TO_IRIS_CACHE.get(python_classname)
+    if previous_iris and previous_iris != iris_classname:
+        _IRIS_TO_PYTHON_CACHE.pop(previous_iris, None)
+        _IRIS_TO_PYTHON_CLASSPATH_CACHE.pop(previous_iris, None)
+        _IRIS_TO_PYTHON_STRICT_CACHE.pop(previous_iris, None)
+        _IRIS_TO_MESSAGE_CLASS_CACHE.pop(previous_iris, None)
+
+    previous_python = _IRIS_TO_PYTHON_CACHE.get(iris_classname)
+    if previous_python and previous_python != python_classname:
+        if _PYTHON_TO_IRIS_CACHE.get(previous_python) == iris_classname:
+            _PYTHON_TO_IRIS_CACHE.pop(previous_python, None)
+        _IRIS_TO_MESSAGE_CLASS_CACHE.pop(iris_classname, 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
+    _IRIS_TO_PYTHON_STRICT_CACHE[iris_classname] = strict
+    if python_classpath is not _CACHE_VALUE_UNSET:
+        if python_classpath:
+            _IRIS_TO_PYTHON_CLASSPATH_CACHE[iris_classname] = str(python_classpath)
+        else:
+            _IRIS_TO_PYTHON_CLASSPATH_CACHE.pop(iris_classname, None)
+    if message_class is not None:
+        _IRIS_TO_MESSAGE_CLASS_CACHE[iris_classname] = message_class
 
 
 def _resolve_python_message_metadata(
@@ -416,13 +458,73 @@ def _resolve_python_message_metadata(
         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
+        _cache_mapping(
+            python_classname,
+            iris_classname,
+            python_classpath=python_classpath,
+            strict=strict,
+        )
 
     return python_classname, python_classpath, strict
 
 
+def _resolve_persistent_message_class(
+    iris_classname: str,
+) -> _PersistentMessageResolution:
+    cached = _IRIS_TO_MESSAGE_CLASS_CACHE.get(iris_classname)
+    if cached is not None:
+        return _PersistentMessageResolution(
+            _PersistentMessageResolutionState.RESOLVED,
+            message_class=cached,
+        )
+
+    python_classname, python_classpath, strict = _resolve_python_message_metadata(
+        iris_classname
+    )
+    if not python_classname:
+        return _PersistentMessageResolution(
+            _PersistentMessageResolutionState.UNMAPPED
+        )
+
+    try:
+        msg_cls = load_python_class(python_classname, python_classpath)
+    except (AttributeError, ModuleNotFoundError, PersistentMessageError) as exc:
+        if not strict:
+            return _PersistentMessageResolution(
+                _PersistentMessageResolutionState.UNMAPPED
+            )
+        error = 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."
+        )
+        error.__cause__ = exc
+        return _PersistentMessageResolution(
+            _PersistentMessageResolutionState.INVALID,
+            error=error,
+        )
+
+    if not is_persistent_message_class(msg_cls):
+        if not strict:
+            return _PersistentMessageResolution(
+                _PersistentMessageResolutionState.UNMAPPED
+            )
+        return _PersistentMessageResolution(
+            _PersistentMessageResolutionState.INVALID,
+            error=PersistentMessageError(
+                f"IRIS class {iris_classname!r} maps to {python_classname!r}, "
+                "but that class is not a PersistentMessage subclass."
+            ),
+        )
+
+    _prepare_message_class(msg_cls, iris_classname, registered=False)
+    return _PersistentMessageResolution(
+        _PersistentMessageResolutionState.RESOLVED,
+        message_class=msg_cls,
+    )
+
+
 def get_iris_class_parameter(
     iris_classname: str,
     parameter_name: str,

iop/messages/serialization.py

@@ -104,6 +104,9 @@ class MessageSerializer:
                 f"Failed to load class {serial.classname}: {str(e)}"
             ) from e
 
+        if not isinstance(msg_class, type):
+            raise SerializationError(f"Class {msg_class} must be a class")
+
         if is_dataclass(msg_class) and issubclass(msg_class, BaseModel):
             raise SerializationError(
                 f"Class '{msg_class.__name__}' combines @dataclass with PydanticMessage, which are incompatible. "

iop/migration/_conversion.py

@@ -0,0 +1,58 @@
+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:
+    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:
+    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)

iop/migration/_production_io.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from typing import Any
+
+from ..runtime import iris as _iris
+from .io import dict_to_xml, stream_to_string, string_to_stream, xml_to_json
+
+
+def _raise_on_error(status: Any) -> None:
+    iris = _iris.get_iris()
+    if iris.system.Status.IsError(status):
+        raise RuntimeError(iris.system.Status.GetOneStatusText(status))
+
+
+def register_production(production_name: str, xml: str) -> None:
+    package, _, short_name = production_name.rpartition(".")
+    stream = string_to_stream(_iris.get_iris(), xml)
+    _raise_on_error(
+        _iris.get_iris().cls("IOP.Utils").CreateProduction(package, short_name, stream)
+    )
+
+
+def register_production_definition(
+    production_name: str,
+    production: dict,
+    *,
+    xml_fallback: Callable[[str, str], None] = register_production,
+) -> None:
+    try:
+        _raise_on_error(
+            _iris.get_iris()
+            .cls("IOP.Utils")
+            .CreateProductionFromJSON(production_name, json.dumps(production))
+        )
+    except RuntimeError as exc:
+        if not is_missing_production_class_error(exc, production_name):
+            raise
+        xml_fallback(production_name, dict_to_xml(production))
+
+
+def is_missing_production_class_error(
+    exc: RuntimeError, production_name: str
+) -> bool:
+    message = str(exc)
+    return "CLASS DOES NOT EXIST" in message and production_name in message
+
+
+def export_production(production_name: str):
+    data = _iris.get_iris().cls("IOP.Utils").ExportProduction(production_name)
+    return xml_to_json(stream_to_string(data))
+
+
+def export_production_connections(production_name: str) -> dict:
+    data = _iris.get_iris().cls("IOP.Utils").ExportProductionConnections(
+        production_name
+    )
+    return data if isinstance(data, dict) else json.loads(data)
+
+
+def export_production_queue_info(production_name: str) -> dict:
+    data = _iris.get_iris().cls("IOP.Utils").ExportProductionQueueInfo(production_name)
+    return data if isinstance(data, dict) else json.loads(data)
+
+
+def apply_production_plan(
+    plan: dict, allow_destructive: bool = False
+) -> dict:
+    production_name = plan.get("production") or plan.get("production_name")
+    if not production_name:
+        raise ValueError("Production plan is missing the production name.")
+    data = (
+        _iris.get_iris()
+        .cls("IOP.Utils")
+        .ApplyProductionPlan(
+            production_name,
+            json.dumps(plan),
+            1 if allow_destructive else 0,
+        )
+    )
+    return data if isinstance(data, dict) else json.loads(data)

iop/migration/_registration.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from .manifest import ClassRegistration, MigrationManifest
+
+
+def execute_class_registration(
+    registration: ClassRegistration,
+    *,
+    persistent_registry: dict[str, tuple[type, bool]] | None,
+    register_persistent: Callable[..., None],
+    register_component: Callable[..., None],
+    register_file: Callable[..., None],
+    register_package: Callable[..., None],
+    register_folder: Callable[..., None],
+) -> None:
+    action = registration.action
+    if action == "persistent_message":
+        assert registration.cls is not None
+        register_persistent(
+            registration.cls,
+            registration.iris_classname,
+            sync_schema=registration.sync_schema,
+            persistent_registry=persistent_registry,
+        )
+        return
+
+    assert registration.path is not None
+    if action in {"component_class", "component_descriptor"}:
+        register_component(
+            registration.module,
+            registration.classname,
+            registration.path,
+            1,
+            registration.iris_classname,
+        )
+    elif action in {"module_file", "file"}:
+        register_file(
+            registration.file,
+            registration.path,
+            1,
+            registration.iris_classname,
+        )
+    elif action == "package":
+        register_package(
+            registration.package,
+            registration.path,
+            1,
+            registration.iris_classname,
+        )
+    elif action == "folder":
+        register_folder(registration.path, 1, registration.iris_classname)
+    else:
+        raise ValueError(f"Invalid migration class action: {action}.")
+
+
+def execute_manifest(
+    manifest: MigrationManifest,
+    *,
+    persistent_registry: dict[str, tuple[type, bool]] | None,
+    execute_class: Callable[..., None],
+    validate_production: Callable[[Any], Any],
+    register_production: Callable[[str, dict], None],
+    register_schema: Callable[[type], None],
+) -> None:
+    for registration in manifest.class_registrations:
+        execute_class(registration, persistent_registry=persistent_registry)
+
+    for production in manifest.production_registrations:
+        for registration in production.class_registrations:
+            execute_class(registration, persistent_registry=persistent_registry)
+        validate_production(production.validation_subject)
+        register_production(production.name, production.definition)
+
+    for registration in manifest.schema_registrations:
+        register_schema(registration.schema_class)

iop/migration/_settings.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import importlib.util
+import os
+import sys
+from types import ModuleType
+
+
+def module_name_from_file(filename: str) -> str:
+    return os.path.splitext(os.path.basename(filename))[0]
+
+
+def import_module_from_path(module_name: str, file_path: str) -> ModuleType:
+    if not os.path.isabs(file_path):
+        raise ValueError("The file path must be absolute")
+
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Cannot find module named {module_name} at {file_path}")
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    try:
+        spec.loader.exec_module(module)
+    except Exception:
+        sys.modules.pop(module_name, None)
+        raise
+    return module
+
+
+def load_settings(filename: str | None = None) -> tuple[ModuleType, str | None]:
+    path_added = None
+    if filename:
+        if not os.path.isabs(filename):
+            raise ValueError("The filename must be absolute")
+        path_added = os.path.normpath(os.path.dirname(filename))
+        sys.path.insert(0, path_added)
+        settings = import_module_from_path(module_name_from_file(filename), filename)
+    else:
+        import settings  # type: ignore
+
+    return settings, path_added
+
+
+def folder_path(filename: str | None, path_added_to_sys: str | None) -> str:
+    del path_added_to_sys
+    return os.path.dirname(filename) if filename else os.getcwd()