iris-pex-embedded-python 4.0.0b2__tar.gz → 4.0.0b4__tar.gz

{iris_pex_embedded_python-4.0.0b2/src/iris_pex_embedded_python.egg-info → iris_pex_embedded_python-4.0.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 4.0.0b2
+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.0b2 → iris_pex_embedded_python-4.0.0b4}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "4.0.0b2"
+version = "4.0.0b4"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 requires-python = ">=3.10"

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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",

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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(

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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(

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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))
 		}

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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)

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/iop/messages/serialization.py

@@ -22,6 +22,12 @@ class SerializationError(Exception):
     pass
 
 
+class MessageClassImportError(SerializationError, ImportError):
+    """Raised when a JSON message's Python class cannot be imported."""
+
+    pass
+
+
 class TempPydanticModel(BaseModel):
     model_config = {"arbitrary_types_allowed": True, "extra": "allow"}
 
@@ -93,8 +99,8 @@ class MessageSerializer:
             )
             module = importlib.import_module(module_name)
             msg_class = getattr(module, class_name)
-        except Exception as e:
-            raise SerializationError(
+        except (ModuleNotFoundError, AttributeError, ValueError) as e:
+            raise MessageClassImportError(
                 f"Failed to load class {serial.classname}: {str(e)}"
             ) from e
 
@@ -130,9 +136,12 @@ class MessageSerializer:
 
     @staticmethod
     def _parse_classname(classname: str) -> tuple[str, str]:
-        j = classname.rindex(".")
+        try:
+            j = classname.rindex(".")
+        except ValueError as e:
+            raise ValueError(f"Classname must include a module: {classname}") from e
         if j <= 0:
-            raise SerializationError(f"Classname must include a module: {classname}")
+            raise ValueError(f"Classname must include a module: {classname}")
         return classname[:j], classname[j + 1 :]
 
     @staticmethod

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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(

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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)
 

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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",

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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):

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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]]:

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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]]:

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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)
 

{iris_pex_embedded_python-4.0.0b2 → iris_pex_embedded_python-4.0.0b4}/src/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,
     )