iris-pex-embedded-python 4.0.0b3__py3-none-any.whl → 4.0.0b4__py3-none-any.whl

iop/__init__.py

@@ -31,6 +31,10 @@ from iop.production import Production as Production
 from iop.production import ProductionDiff as ProductionDiff
 from iop.production import ProductionDiffEntry as ProductionDiffEntry
 from iop.production import ProductionGraph as ProductionGraph
+from iop.production import ProductionValidationError as ProductionValidationError
+from iop.production import ProductionValidationIssue as ProductionValidationIssue
+from iop.production import ProductionValidationReport as ProductionValidationReport
+from iop.production import ProductionValidationWarning as ProductionValidationWarning
 from iop.production import target as target
 from iop.runtime.director import _Director
 from iop.runtime.protocol import DirectorProtocol as DirectorProtocol
@@ -59,6 +63,10 @@ __all__ = [
     "ProductionDiff",
     "ProductionDiffEntry",
     "ProductionGraph",
+    "ProductionValidationError",
+    "ProductionValidationIssue",
+    "ProductionValidationReport",
+    "ProductionValidationWarning",
     "PydanticMessage",
     "PydanticPickleMessage",
     "Setting",

iop/cli/main.py

@@ -244,17 +244,33 @@ class Command:
             if self.args.migration_plan:
                 print(
                     migration_utils.explain_migration(
-                        migrate_path, mode=mode, namespace=self.director.namespace
+                        migrate_path,
+                        mode=mode,
+                        namespace=self.director.namespace,
+                        strict_production_validation=(
+                            self.args.strict_production_validation
+                        ),
                     )
                 )
                 return
             if self._is_remote:
                 print(
                     migration_utils.explain_migration(
-                        migrate_path, mode=mode, namespace=self.director.namespace
+                        migrate_path,
+                        mode=mode,
+                        namespace=self.director.namespace,
+                        strict_production_validation=(
+                            self.args.strict_production_validation
+                        ),
                     )
                 )
-            self.director.migrate(migrate_path)
+            if self.args.strict_production_validation:
+                self.director.migrate(
+                    migrate_path,
+                    strict_production_validation=True,
+                )
+            else:
+                self.director.migrate(migrate_path)
             if self._is_remote:
                 print(
                     migration_utils.format_migration_success(

iop/cli/parser.py

@@ -95,6 +95,11 @@ def create_parser() -> argparse.ArgumentParser:
         help="show the migration plan and validation messages without writing to IRIS",
         action="store_true",
     )
+    migrate.add_argument(
+        "--strict-production-validation",
+        help="fail migration when production validation reports issues",
+        action="store_true",
+    )
 
     export = main_parser.add_argument_group("export arguments")
     export.add_argument(

iop/cli/types.py

@@ -55,3 +55,4 @@ class CommandArgs:
     remote_settings: str | None = None
     update: bool = False
     migration_plan: bool = False
+    strict_production_validation: bool = False

iop/cls/IOP/Service/Remote/Rest/v1.cls

@@ -499,6 +499,7 @@ ClassMethod PutMigrate() As %DynamicObject
 		set targetDirectory = dyna.%Get("remote_folder")
 		set packageName = dyna.%Get("package")
 		set settingsFile = dyna.%Get("settings_file")
+		set strictProductionValidation = dyna.%Get("strict_production_validation")
 		If settingsFile = "" { Set settingsFile = "settings.py" }
 		// check for namespace existence and user permissions against namespace
 		If '..NamespaceCheck(namespace) {
@@ -551,7 +552,7 @@ ClassMethod PutMigrate() As %DynamicObject
 		set iopUtils = ##class(IOP.Wrapper).Import("iop.migration.utils")
 		set builtins = ##class(%SYS.Python).Import("builtins")
 		If builtins.hasattr(iopUtils, "migrate") {
-			do builtins.getattr(iopUtils, "migrate")."__call__"(##class(%Library.File).NormalizeFilename(settingsFile, packagePath))
+			do builtins.getattr(iopUtils, "migrate")."__call__"(##class(%Library.File).NormalizeFilename(settingsFile, packagePath),"REMOTE",namespace,strictProductionValidation)
 		} Else {
 			do iopUtils."_Utils".migrate(##class(%Library.File).NormalizeFilename(settingsFile, packagePath))
 		}

iop/cls/IOP/Utils.cls

@@ -719,8 +719,10 @@ ClassMethod InsertSetting(
 	pSettingData) As %Status [ Internal, Private ]
 {
 	#dim tSetting As Ens.Config.Setting
+	#dim tDefaultTarget As %String
+	Set tDefaultTarget = $Select(pOwner.%IsA("Ens.Config.Production"):"",1:"Host")
 	Set tSetting = ##class(Ens.Config.Setting).%New()
-	Set tSetting.Target = ..DynamicGet(pSettingData,"@Target","Host")
+	Set tSetting.Target = ..DynamicGet(pSettingData,"@Target",tDefaultTarget)
 	Set tSetting.Name = ..DynamicGet(pSettingData,"@Name","")
 	Set tSetting.Value = ..DynamicGet(pSettingData,"#text","")
 	Do pOwner.Settings.Insert(tSetting)

iop/migration/plans.py

@@ -4,6 +4,8 @@ import inspect
 import os
 from typing import Any
 
+from ..production.validation import validate_production_entry
+
 
 def format_migration_success(filename: str, namespace: str | None = None) -> str:
     suffix = f" in namespace {namespace}" if namespace else ""
@@ -21,6 +23,7 @@ def format_migration_plan(plan: dict[str, Any]) -> str:
     lines.extend(format_plan_section("CLASSES", plan["classes"]))
     lines.extend(format_plan_section("SCHEMAS", plan["schemas"]))
     lines.extend(format_plan_section("PRODUCTIONS", plan["productions"]))
+    lines.extend(format_plan_section("VALIDATION", plan.get("validation", [])))
     return "\n".join(lines)
 
 
@@ -47,6 +50,7 @@ class MigrationPlanner:
         filename=None,
         mode: str | None = None,
         namespace: str | None = None,
+        strict_production_validation: bool = False,
     ) -> dict[str, Any]:
         """Build and validate a migration plan from a settings module."""
         if not path:
@@ -59,11 +63,16 @@ class MigrationPlanner:
             "classes": [],
             "schemas": [],
             "productions": [],
+            "validation": [],
         }
 
         self._add_class_entries(plan, getattr(settings, "CLASSES", {}), path)
         self._add_schema_entries(plan, getattr(settings, "SCHEMAS", None))
-        self._add_production_entries(plan, getattr(settings, "PRODUCTIONS", None))
+        self._add_production_entries(
+            plan,
+            getattr(settings, "PRODUCTIONS", None),
+            strict_production_validation=strict_production_validation,
+        )
         return plan
 
     @staticmethod
@@ -102,7 +111,11 @@ class MigrationPlanner:
             plan["schemas"].append(self._utils._python_classname(cls))
 
     def _add_production_entries(
-        self, plan: dict[str, Any], productions: list[Any] | None
+        self,
+        plan: dict[str, Any],
+        productions: list[Any] | None,
+        *,
+        strict_production_validation: bool = False,
     ) -> None:
         if productions is None:
             return
@@ -110,6 +123,16 @@ class MigrationPlanner:
             raise ValueError("PRODUCTIONS must be a list.")
         auto_class_entries = set()
         for production in productions:
+            report = validate_production_entry(
+                production,
+                strict=strict_production_validation,
+                warn=False,
+            )
+            if report.has_issues:
+                plan["validation"].extend(
+                    f"{report.production_name}: {issue.to_text()}"
+                    for issue in report.issues
+                )
             if self._utils._is_production_object(production):
                 plan["productions"].append(production.name)
                 self._add_production_component_entries(

iop/migration/utils.py

@@ -18,6 +18,7 @@ from ..messages.persistent import (
     is_persistent_message_class,
     register_persistent_message_class,
 )
+from ..production.validation import validate_production_entry
 from ..runtime import iris as _iris
 from ..runtime.environment import remove_sys_path, temporary_sys_path
 from .io import (
@@ -425,7 +426,12 @@ def filename_to_module(filename) -> str:
     return module
 
 
-def migrate(filename=None, mode: str | None = None, namespace: str | None = None):
+def migrate(
+    filename=None,
+    mode: str | None = None,
+    namespace: str | None = None,
+    strict_production_validation: bool = False,
+):
     """
     Read the settings.py file and register all the components
     settings.py file has two dictionaries:
@@ -443,10 +449,19 @@ def migrate(filename=None, mode: str | None = None, namespace: str | None = None
 
     try:
         plan = _build_migration_plan(
-            settings, path, filename, mode=mode, namespace=namespace
+            settings,
+            path,
+            filename,
+            mode=mode,
+            namespace=namespace,
+            strict_production_validation=strict_production_validation,
         )
         print(format_migration_plan(plan))
-        _register_settings_components(settings, path)
+        _register_settings_components(
+            settings,
+            path,
+            strict_production_validation=strict_production_validation,
+        )
         print(
             format_migration_success(
                 filename or inspect.getfile(settings), namespace=namespace
@@ -457,13 +472,21 @@ def migrate(filename=None, mode: str | None = None, namespace: str | None = None
 
 
 def explain_migration(
-    filename=None, mode: str | None = None, namespace: str | None = None
+    filename=None,
+    mode: str | None = None,
+    namespace: str | None = None,
+    strict_production_validation: bool = False,
 ):
     """Return a human-readable migration plan without writing to IRIS."""
     settings, path = _load_settings(filename)
     try:
         plan = _build_migration_plan(
-            settings, path, filename, mode=mode, namespace=namespace
+            settings,
+            path,
+            filename,
+            mode=mode,
+            namespace=namespace,
+            strict_production_validation=strict_production_validation,
         )
         return _format_migration_plan(plan)
     finally:
@@ -488,6 +511,7 @@ def _build_migration_plan(
     filename=None,
     mode: str | None = None,
     namespace: str | None = None,
+    strict_production_validation: bool = False,
 ):
     return MigrationPlanner(sys.modules[__name__]).build(
         settings,
@@ -495,6 +519,7 @@ def _build_migration_plan(
         filename=filename,
         mode=mode,
         namespace=namespace,
+        strict_production_validation=strict_production_validation,
     )
 
 
@@ -589,7 +614,12 @@ def _validate_dtl_schema_class(cls, setting_name):
         )
 
 
-def _register_settings_components(settings, path):
+def _register_settings_components(
+    settings,
+    path,
+    *,
+    strict_production_validation: bool = False,
+):
     """Register all components from settings (classes, productions, schemas).
 
     Args:
@@ -616,6 +646,7 @@ def _register_settings_components(settings, path):
             settings.PRODUCTIONS,
             path,
             persistent_registry=persistent_registry,
+            strict_production_validation=strict_production_validation,
         )
     except AttributeError:
         pass
@@ -835,18 +866,25 @@ def set_productions_settings(
     production_list,
     root_path=None,
     persistent_registry=None,
+    strict_production_validation: bool = False,
 ):
     """
     It takes a list of dictionaries and registers the productions
     """
     # for each production in the list
     for production in production_list:
-        if _is_production_object(production):
+        production_is_object = _is_production_object(production)
+        if production_is_object:
             _register_production_object_messages(
                 production,
                 persistent_registry=persistent_registry,
             )
             _register_production_object_components(production, root_path)
+            validate_production_entry(
+                production,
+                strict=strict_production_validation,
+                warn=True,
+            )
             production = production.to_dict()
         else:
             production = copy.deepcopy(production)
@@ -860,6 +898,12 @@ def set_productions_settings(
         production["Production"] = production.pop(production_name)
         # handle Items
         production = handle_items(production, root_path)
+        if not production_is_object:
+            validate_production_entry(
+                production,
+                strict=strict_production_validation,
+                warn=True,
+            )
         # register the production
         register_production_definition(production_name, production)
 

iop/production/__init__.py

@@ -12,6 +12,10 @@ from .types import ProductionDiffEntry as ProductionDiffEntry
 from .types import ProductionGraph as ProductionGraph
 from .types import TargetSetting as TargetSetting
 from .types import target as target
+from .validation import ProductionValidationError as ProductionValidationError
+from .validation import ProductionValidationIssue as ProductionValidationIssue
+from .validation import ProductionValidationReport as ProductionValidationReport
+from .validation import ProductionValidationWarning as ProductionValidationWarning
 
 __all__ = [
     "ComponentRef",
@@ -23,6 +27,10 @@ __all__ = [
     "ProductionDiff",
     "ProductionDiffEntry",
     "ProductionGraph",
+    "ProductionValidationError",
+    "ProductionValidationIssue",
+    "ProductionValidationReport",
+    "ProductionValidationWarning",
     "TargetSetting",
     "resolve_target",
     "target",

iop/production/common.py

@@ -3,6 +3,25 @@ from __future__ import annotations
 import importlib
 from typing import Any
 
+PRODUCTION_SETTING_FIELDS: dict[str, tuple[str, Any]] = {
+    "shutdown_timeout": ("ShutdownTimeout", 120),
+    "update_timeout": ("UpdateTimeout", 10),
+    "alert_notification_manager": ("AlertNotificationManager", ""),
+    "alert_notification_operation": ("AlertNotificationOperation", ""),
+    "alert_notification_recipients": ("AlertNotificationRecipients", ""),
+    "alert_action_window": ("AlertActionWindow", 60),
+}
+
+PRODUCTION_SETTING_NAMES: dict[str, str] = {
+    field_name: iris_name
+    for field_name, (iris_name, _default) in PRODUCTION_SETTING_FIELDS.items()
+}
+
+PRODUCTION_SETTING_FIELDS_BY_IRIS: dict[str, str] = {
+    iris_name: field_name
+    for field_name, (iris_name, _default) in PRODUCTION_SETTING_FIELDS.items()
+}
+
 
 def _bool_text(value: bool | str) -> str:
     if isinstance(value, bool):

iop/production/diff.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from typing import TYPE_CHECKING, Any
 
-from .common import _bool_text, _text_value
+from .common import PRODUCTION_SETTING_FIELDS, _bool_text, _text_value
 from .types import (
     GraphEdge,
     ProductionDiff,
@@ -66,12 +66,19 @@ def _diff_warnings(desired: Production, current: Production) -> list[str]:
 
 
 def _production_signature(production: Production) -> dict[str, Any]:
-    return {
+    signature = {
         "testing_enabled": _bool_text(production.testing_enabled),
         "log_general_trace_events": _bool_text(production.log_general_trace_events),
         "actor_pool_size": _text_value(production.actor_pool_size),
         "description": production.description,
     }
+    signature.update(
+        {
+            field_name: _text_value(getattr(production, field_name))
+            for field_name in PRODUCTION_SETTING_FIELDS
+        }
+    )
+    return signature
 
 
 def _item_signatures(production: Production) -> dict[str, dict[str, Any]]:

iop/production/import_.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from .common import _text_value
+from .common import PRODUCTION_SETTING_FIELDS_BY_IRIS, _text_value
 
 
 def _as_list(value: Any) -> list[Any]:
@@ -54,6 +54,21 @@ def _split_settings(
     return host_settings, adapter_settings, other_settings
 
 
+def _split_production_settings(settings: Any) -> dict[str, Any]:
+    values: dict[str, Any] = {}
+    for setting in _as_list(settings):
+        if not isinstance(setting, dict):
+            continue
+        target = setting.get("@Target", "")
+        if target not in ("", "Production"):
+            continue
+        iris_name = str(setting.get("@Name", ""))
+        field_name = PRODUCTION_SETTING_FIELDS_BY_IRIS.get(iris_name)
+        if field_name:
+            values[field_name] = setting.get("#text", "")
+    return values
+
+
 def _normalize_connections(
     connections: Any,
 ) -> tuple[dict[str, list[dict[str, Any]]], set[str], list[str]]:

iop/production/model.py

@@ -5,6 +5,7 @@ from typing import Any
 from ..runtime.protocol import DirectorProtocol as _DirectorProtocol
 from . import actions as _actions
 from .common import (
+    PRODUCTION_SETTING_FIELDS,
     _adapter_type_from_component_class,
     _apply_settings_update,
     _auto_proxy_class_name,
@@ -46,6 +47,20 @@ class Production:
         log_general_trace_events: bool | str = False,
         actor_pool_size: int | str = 2,
         description: str = "",
+        shutdown_timeout: int | str = PRODUCTION_SETTING_FIELDS["shutdown_timeout"][1],
+        update_timeout: int | str = PRODUCTION_SETTING_FIELDS["update_timeout"][1],
+        alert_notification_manager: str = PRODUCTION_SETTING_FIELDS[
+            "alert_notification_manager"
+        ][1],
+        alert_notification_operation: str = PRODUCTION_SETTING_FIELDS[
+            "alert_notification_operation"
+        ][1],
+        alert_notification_recipients: str = PRODUCTION_SETTING_FIELDS[
+            "alert_notification_recipients"
+        ][1],
+        alert_action_window: int | str = PRODUCTION_SETTING_FIELDS[
+            "alert_action_window"
+        ][1],
         namespace: str | None = None,
         director: _DirectorProtocol | None = None,
     ):
@@ -54,6 +69,12 @@ class Production:
         self.log_general_trace_events = log_general_trace_events
         self.actor_pool_size = actor_pool_size
         self.description = description
+        self.shutdown_timeout = shutdown_timeout
+        self.update_timeout = update_timeout
+        self.alert_notification_manager = alert_notification_manager
+        self.alert_notification_operation = alert_notification_operation
+        self.alert_notification_recipients = alert_notification_recipients
+        self.alert_action_window = alert_action_window
         self.namespace = namespace
         self._director = director
         self._items: list[ComponentRef] = []
@@ -80,6 +101,36 @@ class Production:
         self.description = text
         return self
 
+    def timeouts(
+        self,
+        *,
+        shutdown: int | str | None = None,
+        update: int | str | None = None,
+    ) -> Production:
+        if shutdown is not None:
+            self.shutdown_timeout = shutdown
+        if update is not None:
+            self.update_timeout = update
+        return self
+
+    def alerting(
+        self,
+        *,
+        manager: str | None = None,
+        operation: str | None = None,
+        recipients: str | None = None,
+        action_window: int | str | None = None,
+    ) -> Production:
+        if manager is not None:
+            self.alert_notification_manager = manager
+        if operation is not None:
+            self.alert_notification_operation = operation
+        if recipients is not None:
+            self.alert_notification_recipients = recipients
+        if action_window is not None:
+            self.alert_action_window = action_window
+        return self
+
     def in_namespace(self, namespace: str | None) -> Production:
         self.namespace = namespace
         return self
@@ -555,6 +606,11 @@ class Production:
     def message_registrations(self) -> tuple[PersistentMessageRegistration, ...]:
         return tuple(self._messages)
 
+    def validate(self, *, strict: bool = False):
+        from .validation import validate_production
+
+        return validate_production(self, strict=strict, warn=not strict)
+
     def start(self, detach: bool = True) -> None:
         _actions.start(self, detach=detach)
 

iop/production/reconstruction.py

@@ -12,6 +12,7 @@ from .import_ import (
     _normalize_runtime_item_metadata,
     _production_payload,
     _setting_targets,
+    _split_production_settings,
     _split_settings,
 )
 
@@ -26,12 +27,25 @@ def production_from_dict(
     director: Any = None,
 ):
     production_name, production_data = _production_payload(data)
+    production_settings = _split_production_settings(production_data.get("Setting"))
     production = production_cls(
         production_name,
         testing_enabled=production_data.get("@TestingEnabled", False),
         log_general_trace_events=production_data.get("@LogGeneralTraceEvents", False),
         actor_pool_size=production_data.get("ActorPoolSize", 2),
         description=production_data.get("Description", ""),
+        shutdown_timeout=production_settings.get("shutdown_timeout", 120),
+        update_timeout=production_settings.get("update_timeout", 10),
+        alert_notification_manager=production_settings.get(
+            "alert_notification_manager", ""
+        ),
+        alert_notification_operation=production_settings.get(
+            "alert_notification_operation", ""
+        ),
+        alert_notification_recipients=production_settings.get(
+            "alert_notification_recipients", ""
+        ),
+        alert_action_window=production_settings.get("alert_action_window", 60),
         namespace=namespace,
         director=director,
     )

iop/production/rendering.py

@@ -9,7 +9,7 @@ from typing import Any
 
 from pydantic import BaseModel
 
-from .common import _bool_text, _text_value
+from .common import PRODUCTION_SETTING_FIELDS, _bool_text, _text_value
 from .types import GraphNode, ProductionGraph
 
 
@@ -21,11 +21,29 @@ def production_to_dict(production) -> dict[str, Any]:
         "Description": production.description,
         "ActorPoolSize": _text_value(production.actor_pool_size),
     }
+    production_settings = _production_settings_to_iris(production)
+    if production_settings:
+        data["Setting"] = production_settings
     if production._items:
         data["Item"] = [item.to_dict() for item in production._items]
     return {production.name: data}
 
 
+def _production_settings_to_iris(production) -> list[dict[str, str]]:
+    settings: list[dict[str, str]] = []
+    for field_name, (iris_name, default) in PRODUCTION_SETTING_FIELDS.items():
+        value = getattr(production, field_name)
+        if _text_value(value) == _text_value(default):
+            continue
+        settings.append(
+            {
+                "@Name": iris_name,
+                "#text": _text_value(value),
+            }
+        )
+    return settings
+
+
 def production_to_xml(production) -> str:
     from ..migration import utils as migration_utils
 
@@ -78,6 +96,24 @@ def _production_constructor_lines(production) -> list[str]:
         ),
         ("actor_pool_size", _int_literal(production.actor_pool_size), 2),
         ("description", production.description, ""),
+        ("shutdown_timeout", _int_literal(production.shutdown_timeout), 120),
+        ("update_timeout", _int_literal(production.update_timeout), 10),
+        (
+            "alert_notification_manager",
+            production.alert_notification_manager,
+            "",
+        ),
+        (
+            "alert_notification_operation",
+            production.alert_notification_operation,
+            "",
+        ),
+        (
+            "alert_notification_recipients",
+            production.alert_notification_recipients,
+            "",
+        ),
+        ("alert_action_window", _int_literal(production.alert_action_window), 60),
     ]
     rendered = [
         (name, value)

iop/production/validation.py

@@ -0,0 +1,453 @@
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass
+from typing import Any
+
+from .common import PRODUCTION_SETTING_FIELDS_BY_IRIS, PRODUCTION_SETTING_NAMES
+from .import_ import _as_list, _production_payload, _split_settings
+
+_PRODUCTION_PUBLIC_FIELDS = {
+    "name",
+    "testing_enabled",
+    "log_general_trace_events",
+    "actor_pool_size",
+    "description",
+    "shutdown_timeout",
+    "update_timeout",
+    "alert_notification_manager",
+    "alert_notification_operation",
+    "alert_notification_recipients",
+    "alert_action_window",
+    "namespace",
+}
+
+_PRODUCTION_DICT_KEYS = {
+    "@Name",
+    "@TestingEnabled",
+    "@LogGeneralTraceEvents",
+    "Description",
+    "ActorPoolSize",
+    "Setting",
+    "Item",
+}
+
+_SETTING_NAME_ALIASES = {
+    "target_config_name": "TargetConfigName",
+    "target_config_names": "TargetConfigNames",
+}
+
+_PRODUCTION_SETTING_NAME_ALIASES = {
+    **PRODUCTION_SETTING_NAMES,
+    **{iris_name: iris_name for iris_name in PRODUCTION_SETTING_FIELDS_BY_IRIS},
+}
+
+
+@dataclass(frozen=True)
+class ProductionValidationIssue:
+    kind: str
+    path: str
+    message: str
+    suggestion: str = ""
+
+    def to_dict(self) -> dict[str, str]:
+        data = {
+            "kind": self.kind,
+            "path": self.path,
+            "message": self.message,
+        }
+        if self.suggestion:
+            data["suggestion"] = self.suggestion
+        return data
+
+    def to_text(self) -> str:
+        text = f"{self.kind} {self.path}: {self.message}"
+        if self.suggestion:
+            return f"{text} {self.suggestion}"
+        return text
+
+
+@dataclass(frozen=True)
+class ProductionValidationReport:
+    production_name: str
+    issues: tuple[ProductionValidationIssue, ...] = ()
+
+    @property
+    def has_issues(self) -> bool:
+        return bool(self.issues)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "production": self.production_name,
+            "has_issues": self.has_issues,
+            "issues": [issue.to_dict() for issue in self.issues],
+        }
+
+    def to_text(self) -> str:
+        lines = [f"Production validation: {self.production_name}"]
+        if not self.issues:
+            lines.append("  no issues")
+        else:
+            lines.extend(f"  {issue.to_text()}" for issue in self.issues)
+        return "\n".join(lines)
+
+    def __str__(self) -> str:
+        return self.to_text()
+
+
+class ProductionValidationWarning(UserWarning):
+    pass
+
+
+class ProductionValidationError(ValueError):
+    def __init__(self, report: ProductionValidationReport):
+        self.report = report
+        super().__init__(report.to_text())
+
+
+def validate_production(
+    production: Any,
+    *,
+    strict: bool = False,
+    warn: bool = True,
+) -> ProductionValidationReport:
+    report = _build_production_object_report(production)
+    return _finalize_report(report, strict=strict, warn=warn)
+
+
+def validate_production_entry(
+    production: Any,
+    *,
+    strict: bool = False,
+    warn: bool = True,
+) -> ProductionValidationReport:
+    if _is_production_object(production):
+        report = _build_production_object_report(production)
+    else:
+        report = _build_production_dict_report(production)
+    return _finalize_report(report, strict=strict, warn=warn)
+
+
+def _finalize_report(
+    report: ProductionValidationReport,
+    *,
+    strict: bool,
+    warn: bool,
+) -> ProductionValidationReport:
+    if not report.has_issues:
+        return report
+    if strict:
+        raise ProductionValidationError(report)
+    if warn:
+        for issue in report.issues:
+            warnings.warn(issue.to_text(), ProductionValidationWarning, stacklevel=3)
+    return report
+
+
+def _build_production_object_report(production: Any) -> ProductionValidationReport:
+    production_name = str(getattr(production, "name", "Production"))
+    issues: list[ProductionValidationIssue] = []
+    issues.extend(_unknown_public_attrs(production))
+
+    for item in getattr(production, "items", ()):
+        issues.extend(_validate_component_ref(item))
+
+    return ProductionValidationReport(production_name, tuple(issues))
+
+
+def _unknown_public_attrs(production: Any) -> list[ProductionValidationIssue]:
+    issues = []
+    for attr in sorted(getattr(production, "__dict__", {})):
+        if attr.startswith("_") or attr in _PRODUCTION_PUBLIC_FIELDS:
+            continue
+        issues.append(
+            ProductionValidationIssue(
+                kind="production",
+                path=f"production.{attr}",
+                message=(
+                    "Unknown public Production attribute. Only documented "
+                    "Production fields are serialized."
+                ),
+            )
+        )
+    return issues
+
+
+def _validate_component_ref(item: Any) -> list[ProductionValidationIssue]:
+    issues: list[ProductionValidationIssue] = []
+    item_name = str(getattr(item, "name", ""))
+    component_class = getattr(item, "component_class", None)
+    class_name = str(getattr(item, "class_name", "") or "")
+
+    issues.extend(
+        _validate_settings(
+            settings=dict(getattr(item, "host_settings", {}) or {}),
+            path_prefix=f"items.{item_name}.settings.Host",
+            local_class=component_class,
+            iris_class_name=class_name,
+        )
+    )
+
+    adapter_settings = dict(getattr(item, "adapter_settings", {}) or {})
+    if str(getattr(item, "kind", "")) == "process" and adapter_settings:
+        issues.append(
+            ProductionValidationIssue(
+                kind="setting",
+                path=f"items.{item_name}.settings.Adapter",
+                message="Business process items do not support adapter settings.",
+            )
+        )
+
+    adapter_class = getattr(item, "adapter_class", None)
+    adapter_class_name = str(getattr(item, "adapter_class_name", "") or "")
+    issues.extend(
+        _validate_settings(
+            settings=adapter_settings,
+            path_prefix=f"items.{item_name}.settings.Adapter",
+            local_class=adapter_class,
+            iris_class_name=adapter_class_name,
+            host_class_name=class_name,
+        )
+    )
+    return issues
+
+
+def _build_production_dict_report(data: Any) -> ProductionValidationReport:
+    issues: list[ProductionValidationIssue] = []
+    try:
+        production_name, production_data = _production_payload(data)
+    except Exception:
+        return ProductionValidationReport("Production", tuple(issues))
+
+    for key in sorted(set(production_data) - _PRODUCTION_DICT_KEYS):
+        issues.append(
+            ProductionValidationIssue(
+                kind="production",
+                path=f"production.{key}",
+                message="Unknown production dictionary key.",
+            )
+        )
+
+    issues.extend(_validate_production_settings(production_data.get("Setting")))
+    for item in _as_list(production_data.get("Item", [])):
+        if isinstance(item, dict):
+            issues.extend(_validate_dict_item(item))
+
+    return ProductionValidationReport(str(production_name), tuple(issues))
+
+
+def _validate_production_settings(settings: Any) -> list[ProductionValidationIssue]:
+    issues: list[ProductionValidationIssue] = []
+    known_iris_names = set(PRODUCTION_SETTING_FIELDS_BY_IRIS)
+    for setting in _as_list(settings):
+        if not isinstance(setting, dict):
+            continue
+        target = setting.get("@Target", "")
+        if target not in ("", "Production"):
+            continue
+        setting_name = str(setting.get("@Name", ""))
+        if not setting_name or setting_name in known_iris_names:
+            continue
+        alias = _PRODUCTION_SETTING_NAME_ALIASES.get(setting_name)
+        if alias in known_iris_names:
+            issues.append(
+                ProductionValidationIssue(
+                    kind="production",
+                    path=f"production.settings.{setting_name}",
+                    message=(
+                        "Production setting name is accepted as a known alias for "
+                        "validation, but IoP will emit the original name."
+                    ),
+                    suggestion=f"Use {alias!r}.",
+                )
+            )
+            continue
+        issues.append(
+            ProductionValidationIssue(
+                kind="production",
+                path=f"production.settings.{setting_name}",
+                message="Unknown production-level setting.",
+            )
+        )
+    return issues
+
+
+def _validate_dict_item(item: dict[str, Any]) -> list[ProductionValidationIssue]:
+    item_name = str(item.get("@Name", ""))
+    class_ref = item.get("@ClassName", "")
+    local_class = class_ref if isinstance(class_ref, type) else None
+    iris_class_name = "" if isinstance(class_ref, type) else str(class_ref or "")
+    host_settings, adapter_settings, _other_settings = _split_settings(
+        item.get("Setting", [])
+    )
+
+    issues = _validate_settings(
+        settings=host_settings,
+        path_prefix=f"items.{item_name}.settings.Host",
+        local_class=local_class,
+        iris_class_name=iris_class_name,
+    )
+    issues.extend(
+        _validate_settings(
+            settings=adapter_settings,
+            path_prefix=f"items.{item_name}.settings.Adapter",
+            local_class=None,
+            iris_class_name="",
+            host_class_name=iris_class_name,
+        )
+    )
+    return issues
+
+
+def _validate_settings(
+    *,
+    settings: dict[str, Any],
+    path_prefix: str,
+    local_class: type | None,
+    iris_class_name: str,
+    host_class_name: str = "",
+) -> list[ProductionValidationIssue]:
+    if not settings:
+        return []
+    if local_class is not None:
+        local_names = _local_setting_names(local_class)
+        if local_names is not None:
+            return _validate_names_with_known_set(
+                settings,
+                path_prefix=path_prefix,
+                known_names=local_names,
+            )
+
+    iris_target_class = iris_class_name or _adapter_class_name_from_host(host_class_name)
+    if iris_target_class:
+        report = _validate_names_with_iris_dictionary(
+            settings,
+            path_prefix=path_prefix,
+            iris_class_name=iris_target_class,
+        )
+        if report is not None:
+            return report
+    return []
+
+
+def _local_setting_names(cls: type) -> set[str] | None:
+    getter = getattr(cls, "_get_properties", None)
+    if not callable(getter):
+        return None
+    try:
+        return {str(prop[0]) for prop in getter() if prop}
+    except Exception:
+        return None
+
+
+def _validate_names_with_known_set(
+    settings: dict[str, Any],
+    *,
+    path_prefix: str,
+    known_names: set[str],
+) -> list[ProductionValidationIssue]:
+    issues: list[ProductionValidationIssue] = []
+    for setting_name in sorted(settings):
+        if setting_name.startswith("%") or setting_name in known_names:
+            continue
+        alias = _SETTING_NAME_ALIASES.get(setting_name)
+        if alias in known_names:
+            issues.append(_setting_alias_issue(path_prefix, setting_name, alias))
+            continue
+        issues.append(_unknown_setting_issue(path_prefix, setting_name))
+    return issues
+
+
+def _validate_names_with_iris_dictionary(
+    settings: dict[str, Any],
+    *,
+    path_prefix: str,
+    iris_class_name: str,
+) -> list[ProductionValidationIssue] | None:
+    iris = _iris_module()
+    if iris is None or not _iris_class_exists(iris, iris_class_name):
+        return None
+
+    issues: list[ProductionValidationIssue] = []
+    for setting_name in sorted(settings):
+        if _iris_property_exists(iris, iris_class_name, setting_name):
+            continue
+        alias = _SETTING_NAME_ALIASES.get(setting_name)
+        if alias and _iris_property_exists(iris, iris_class_name, alias):
+            issues.append(_setting_alias_issue(path_prefix, setting_name, alias))
+            continue
+        issues.append(_unknown_setting_issue(path_prefix, setting_name))
+    return issues
+
+
+def _adapter_class_name_from_host(host_class_name: str) -> str:
+    if not host_class_name:
+        return ""
+    iris = _iris_module()
+    if iris is None:
+        return ""
+    try:
+        parameter = iris._Dictionary.CompiledParameter._OpenId(
+            f"{host_class_name}||ADAPTER"
+        )
+        return str(getattr(parameter, "Default", "") or "")
+    except Exception:
+        return ""
+
+
+def _iris_module():
+    try:
+        import iris  # type: ignore
+    except Exception:
+        return None
+    return iris
+
+
+def _iris_class_exists(iris: Any, class_name: str) -> bool:
+    try:
+        return bool(iris._Dictionary.CompiledClass._ExistsId(class_name))
+    except Exception:
+        return False
+
+
+def _iris_property_exists(iris: Any, class_name: str, property_name: str) -> bool:
+    try:
+        return bool(
+            iris._Dictionary.CompiledProperty._ExistsId(
+                f"{class_name}||{property_name}"
+            )
+        )
+    except Exception:
+        return False
+
+
+def _setting_alias_issue(
+    path_prefix: str,
+    setting_name: str,
+    alias: str,
+) -> ProductionValidationIssue:
+    return ProductionValidationIssue(
+        kind="setting",
+        path=f"{path_prefix}.{setting_name}",
+        message=(
+            "Setting name is accepted as a known alias for validation, "
+            "but IoP will emit the original name."
+        ),
+        suggestion=f"Use {alias!r}.",
+    )
+
+
+def _unknown_setting_issue(path_prefix: str, setting_name: str) -> ProductionValidationIssue:
+    return ProductionValidationIssue(
+        kind="setting",
+        path=f"{path_prefix}.{setting_name}",
+        message="Unknown setting name.",
+    )
+
+
+def _is_production_object(value: Any) -> bool:
+    return (
+        hasattr(value, "to_dict")
+        and hasattr(value, "component_registrations")
+        and hasattr(value, "name")
+    )

iop/runtime/local.py

@@ -114,8 +114,17 @@ class _LocalDirector(_DirectorProtocol):
     # Migrate
     # ------------------------------------------------------------------
 
-    def migrate(self, path: str) -> None:
-        _migration_utils.migrate(path, mode="LOCAL", namespace=self.namespace)
+    def migrate(
+        self,
+        path: str,
+        strict_production_validation: bool = False,
+    ) -> None:
+        _migration_utils.migrate(
+            path,
+            mode="LOCAL",
+            namespace=self.namespace,
+            strict_production_validation=strict_production_validation,
+        )
 
     # ------------------------------------------------------------------
     # Metadata

iop/runtime/protocol.py

@@ -75,7 +75,11 @@ class DirectorProtocol(Protocol):
     # Migrate
     # ------------------------------------------------------------------
 
-    def migrate(self, path: str) -> None: ...
+    def migrate(
+        self,
+        path: str,
+        strict_production_validation: bool = False,
+    ) -> None: ...
 
     # ------------------------------------------------------------------
     # Metadata

iop/runtime/remote/director.py

@@ -227,8 +227,16 @@ class _RemoteDirector(_RemoteClient, _DirectorProtocol):
     # Migrate
     # ------------------------------------------------------------------
 
-    def migrate(self, path: str) -> None:
-        upload_migration(self, path)
+    def migrate(
+        self,
+        path: str,
+        strict_production_validation: bool = False,
+    ) -> None:
+        upload_migration(
+            self,
+            path,
+            strict_production_validation=strict_production_validation,
+        )
 
     # ------------------------------------------------------------------
     # Init / setup — uploads .cls files via the Atelier API

iop/runtime/remote/migration.py

@@ -6,7 +6,12 @@ import os
 import requests
 
 
-def upload_migration(client, path: str) -> None:
+def upload_migration(
+    client,
+    path: str,
+    *,
+    strict_production_validation: bool = False,
+) -> None:
     """Upload .py and .cls files from *path*'s folder to remote IRIS."""
     folder = os.path.dirname(path)
 
@@ -38,6 +43,7 @@ def upload_migration(client, path: str) -> None:
         "package": package,
         "remote_folder": remote_folder,
         "settings_file": settings_file,
+        "strict_production_validation": bool(strict_production_validation),
         "body": body,
     }
     resp = requests.put(

{iris_pex_embedded_python-4.0.0b3.dist-info → iris_pex_embedded_python-4.0.0b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 4.0.0b3
+Version: 4.0.0b4
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License

{iris_pex_embedded_python-4.0.0b3.dist-info → iris_pex_embedded_python-4.0.0b4.dist-info}/RECORD

@@ -1,10 +1,10 @@
-iop/__init__.py,sha256=VCdKplz26dn-7R6PXHXliy35PC4-qhRO6ASMOR2Fur4,3532
+iop/__init__.py,sha256=JCkmGv50W1i4oi7CKrvLXyQ88-lv-2y-8SJ_05BOsPA,4001
 iop/__main__.py,sha256=2rUNM7vaYK0W57Jj72rm7GORyIFLMXKwPq3QNLwYBmY,100
 iop/cli/__init__.py,sha256=Y78pBdA-ULzq1c_9xQZsFBlzm3x5xgxSzkvrH5DoM7I,31
 iop/cli/formatting.py,sha256=OLgHA1d8_paAuINQyKkYgihWMLoBhPn7kSXW5whRlIs,1606
-iop/cli/main.py,sha256=LLepnBOH2sj9_taHulcXvW-OhTsNfUVib6pj7JT_CzU,12578
-iop/cli/parser.py,sha256=vufFtEOEOhYudG-p6h5vHJ1sqq6LL7yjNNQgT-_wJhE,4702
-iop/cli/types.py,sha256=uRb2z3TwRBBNC-iuHn8SixUoN2zKW7ey57vXgIAWA3k,1296
+iop/cli/main.py,sha256=FzE86PbdIrJ8zVIIcsTRD7-v5_zdFUisnQ5Rs5hbQH8,13197
+iop/cli/parser.py,sha256=HWn3mxndR8Fw9HrnjtSP-ZMTps9X1cbQWCcye7NPIug,4878
+iop/cli/types.py,sha256=7GxUy2KHw_LNOWAQ2-EalKOikIDQFiKjMmEEmlWeOB8,1343
 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
@@ -16,7 +16,7 @@ iop/cls/IOP/OutboundAdapter.cls,sha256=OQoGFHUy2qV_kcsShTlWGOngDrdH5dhwux4eopZyI
 iop/cls/IOP/PickleMessage.cls,sha256=S3y7AClQ8mAILjxPuHdCjGosBZYzGbUQ5WTv4mYPNMQ,1673
 iop/cls/IOP/Projection.cls,sha256=AZgbfpbEk02llhyIwrSw0M3QMcQNcjhjY3_vU_yx8FU,1315
 iop/cls/IOP/Test.cls,sha256=zvlCZJfOCmSFdmi-ZQHWDGYmqZAgRspaJj1j0r_IxJQ,2017
-iop/cls/IOP/Utils.cls,sha256=tms1rC7gkRRj2Fb-nJtUBCJKXfqztxA1RQH5jVtzlPU,30975
+iop/cls/IOP/Utils.cls,sha256=SZOKKVaJEUp3Y4xkt1OIWw2ExsjNZoWCBsySP7CjqoY,31095
 iop/cls/IOP/Wrapper.cls,sha256=ydlNpqAekoH_XdGk0ZpspX1pxgv__E00Xf57F8oxsqs,1624
 iop/cls/IOP/Duplex/Operation.cls,sha256=K_fmgeLjPZQbHgNrc0kd6DUQoW0fDn1VHQjJxHo95Zk,525
 iop/cls/IOP/Duplex/Process.cls,sha256=xbefZ4z84a_IUhavWN6P_gZBzqkdJ5XRTXxro6iDvAg,6986
@@ -33,7 +33,7 @@ iop/cls/IOP/PrivateSession/Message/Poll.cls,sha256=z3ALYmGYQasTcyYNyBeoHzJdNXI4n
 iop/cls/IOP/PrivateSession/Message/Start.cls,sha256=RsJLrhglrONBDGT0RqW2K9MDXa98vMYcxJfgeD8lhAE,943
 iop/cls/IOP/PrivateSession/Message/Stop.cls,sha256=7g3gKFUjNg0WXBLuWnj-VnCs5G6hSE09YTzGEp0zbGc,1390
 iop/cls/IOP/Service/Remote/Handler.cls,sha256=JfsXse2jvoVvQfW8_rVEt2DCQJ9SVqReCcOUngOkpzE,938
-iop/cls/IOP/Service/Remote/Rest/v1.cls,sha256=IIv38En6Jg-Hm9QrePwqd_8OOo0WRR7UdhrOgcQnGrc,20154
+iop/cls/IOP/Service/Remote/Rest/v1.cls,sha256=33FEBVZhHqysYaLL7l0314kJu1eZXyJlvAk2l4Q-B5g,20277
 iop/components/__init__.py,sha256=uRF_YCn_ukkgzFrW0nLLMmC2jJ1dMk-ME7HX9EEEVic,880
 iop/components/async_request.py,sha256=AU36pf6NIQMM9ZYR5h6LeQry0EfXXqDaKAjsP16_hWE,2411
 iop/components/business_host.py,sha256=P2gna1tkvP2fKtzhHutny11Qdf6DYH1c4CKnNGBlNd0,10243
@@ -59,35 +59,36 @@ iop/messages/serialization.py,sha256=BW0o-7GaceMW7RMOzOJ8g9rKEv28NYnYFwtTLmAf7Yg
 iop/messages/validation.py,sha256=cbq2VaaWTcqesmV-DDwReHh8peynvEMw9h0JNf4q9kQ,1530
 iop/migration/__init__.py,sha256=wp-RvjLKYW_Pi2AJLfiWe1bACxENzEgjXtP9UMNiSVY,36
 iop/migration/io.py,sha256=hAehtApFZFgGzjzgwBmDMxdA1xoRhE-okOcEzvgFdQ4,1822
-iop/migration/plans.py,sha256=pG2hQNYe2Ea-ubi-kE_8GcyWpeFSwfxhwvGs6kef1o0,5947
-iop/migration/utils.py,sha256=_Gg-jwQQACxKUj5zNjneMfheY6ARFL_rv_KaEIoyzUI,39578
-iop/production/__init__.py,sha256=kfWCJe4-JSWo3odYRw9TLNYoNbal-IFmUNoMmHcETP8,903
+iop/migration/plans.py,sha256=oj0sNLMBtWZBCoVEoP82RagIFumfTPqmGylDUxGLJNE,6738
+iop/migration/utils.py,sha256=s2CoqWj4HeW8KrKTaQZGBKH4ZMku3Zg8eolNZvGKMq0,40817
+iop/production/__init__.py,sha256=bVFLRI4lvhbUlKApRvvSqM6pVkOsBuofRrzuEIBT6nY,1360
 iop/production/actions.py,sha256=h95K9O6N8S2thV0dYEKOWxo5uPhfvgALZfB6G2jrUt8,7992
-iop/production/common.py,sha256=_PLPv_n2z-6Q1_BUerWL1Cto_KLZ59I5DLcB6y_vAno,2230
+iop/production/common.py,sha256=RopwhFJT7jP15a4iBvMWipwYwIAV6A0d0UsoxWLo-is,2969
 iop/production/component.py,sha256=uRCQZwlPNFbAEaWgDtbDHUdf4VD8A0R1sJhLTj8kHcA,7988
-iop/production/diff.py,sha256=w1eR-9TiNCTCrY10KlMUjLmOVZH3PM3evrEGNor7Jcg,9742
-iop/production/import_.py,sha256=8P1cZ8rMUSGorzhWJRAVT3x1NAscXqUHC7104DxxYdI,9300
+iop/production/diff.py,sha256=iVJeixEZzy-TaK7b7wdR5wzO5dyIGr2KPVsN0pf2dp4,9968
+iop/production/import_.py,sha256=hK5d6CKtd-_FOmuU39wiZ2cmn-SCUoZ-r3hRz8HgwgA,9865
 iop/production/inspection.py,sha256=LsAI4vhF27v8OMXtRAOHQn8XeaT4CIhjBu-CA-aorO0,3343
-iop/production/model.py,sha256=mHWXxYdlUHoJJqCjAM6rcqItjEeawaPcdqkke6DAZao,28934
-iop/production/reconstruction.py,sha256=2cLeh9J-Gyjbnn34wG9jBmaKEfHvm3eCBZdjMkYB7PQ,6435
-iop/production/rendering.py,sha256=XK1d1tLjuseZfasQhHDZr0BAMVgZjkUKPBo6-8_umMg,9368
+iop/production/model.py,sha256=7YDAgQ-fo87VnE5A-CxmNtNsRHMVFB2NKkpBykH-ohQ,31106
+iop/production/reconstruction.py,sha256=YJMOBtpTzT-IxgQ4lx1kivA8zbWz3UZfwt-5q7d_kMk,7135
+iop/production/rendering.py,sha256=d9Et3hE8aPTCfnk0RKc6vu5HYOrI-JXFCfU6vZLKsKg,10649
 iop/production/runtime.py,sha256=JngIVVkigt1PNLUXBvQu3t8cBos-zLKlgguf0_WWh-M,2302
 iop/production/types.py,sha256=SsTYPspc8VGrSH8hy49tDBVLWu55D5yODNT7lfFbjmc,9131
+iop/production/validation.py,sha256=yeWEQmWANQ8md2H8QN4DhHyR5nIDLMJWZN7e0d2y2Rk,13839
 iop/runtime/__init__.py,sha256=wcyWMRuPCYE_CLd1NmgmI1M-IbFs2Gz2yIj2-EW_2AA,70
 iop/runtime/director.py,sha256=KW8BvkATK8XuIUPNBD9rMww9r3Zg4K3H54868eOgvl0,12867
 iop/runtime/environment.py,sha256=0KZ4EoW6NUEbF7FW471emxQ-9FbaiX6ngUHVGihgZXU,1564
 iop/runtime/iris.py,sha256=wFbrgyv0FiMujGeEyZTysx4JX8Exk5ZPAhjc25wGWGU,185
-iop/runtime/local.py,sha256=p6jZRxd7tsmgyeZqoH5qzqFVBCa5j-r7b-SuaP8dUcI,4593
-iop/runtime/protocol.py,sha256=wclpJYdK36oG1LN2hyDlBs4g0Ky8oSgsn1ark6GNqGE,3289
+iop/runtime/local.py,sha256=Ph3QO-vxwjuRzxMsgeueQEV1vaKRSYHypN9bS08RCLI,4786
+iop/runtime/protocol.py,sha256=Z5l8jjjM7OU1tdOunzQSNLlzid8ZiMciPL__8Oi0QV4,3364
 iop/runtime/remote/__init__.py,sha256=qUIhYpG28edUc_-hgILjP3xGwljGqS5AuybvmUayWlg,350
 iop/runtime/remote/client.py,sha256=A-cTFgl2Lvwwv6CxNoa_yqriYncIXCsU6o5TWBfkzck,2912
-iop/runtime/remote/director.py,sha256=IZa505MUsAwI_cfTK5nzRmrB927TMW-BBB2B7dQPnEY,9199
-iop/runtime/remote/migration.py,sha256=J7r1MiWd3ISPjojj_ZqG2x88GddSwjJmXHiuy2F3HkY,1689
+iop/runtime/remote/director.py,sha256=jNnBIocWS76vog6noJtVky5Tv7ZDnPwiWl-hCu958DE,9380
+iop/runtime/remote/migration.py,sha256=Iboz-Ye7i9xif9bn433GazCF-gtD-HJW3wiUwWS5P6w,1831
 iop/runtime/remote/settings.py,sha256=P1Hsgld5o57HpSZgPVZzobyjlUmxJj6bstiWvR0JXnc,2144
 iop/runtime/remote/setup.py,sha256=Tr80F3JJTy7oSUso2jyx0iA_KZayd4MYt9vL0BvPpMA,2600
-iris_pex_embedded_python-4.0.0b3.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-4.0.0b3.dist-info/METADATA,sha256=aWCFN8YxK2lK5sJD0vzlu8AkfJ3YBAkSjY3ulm-F78k,4412
-iris_pex_embedded_python-4.0.0b3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-iris_pex_embedded_python-4.0.0b3.dist-info/entry_points.txt,sha256=fzS8ZFsPe8cnpEx208X60DNugCPQmuSloPeg4pyyJDY,42
-iris_pex_embedded_python-4.0.0b3.dist-info/top_level.txt,sha256=BM54-OXQ6l2BDtmesWNXckh033s9gcjoO7bfjbwZbxU,4
-iris_pex_embedded_python-4.0.0b3.dist-info/RECORD,,
+iris_pex_embedded_python-4.0.0b4.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
+iris_pex_embedded_python-4.0.0b4.dist-info/METADATA,sha256=wksvI6gY4uyZ7OftWfoAvCB4AspPjHl5xNqMsiA0sIY,4412
+iris_pex_embedded_python-4.0.0b4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+iris_pex_embedded_python-4.0.0b4.dist-info/entry_points.txt,sha256=fzS8ZFsPe8cnpEx208X60DNugCPQmuSloPeg4pyyJDY,42
+iris_pex_embedded_python-4.0.0b4.dist-info/top_level.txt,sha256=BM54-OXQ6l2BDtmesWNXckh033s9gcjoO7bfjbwZbxU,4
+iris_pex_embedded_python-4.0.0b4.dist-info/RECORD,,