iris-pex-embedded-python 3.7.2b1__py3-none-any.whl → 3.7.2b2__py3-none-any.whl

grongier/pex/__init__.py

@@ -6,11 +6,16 @@ from iop._inbound_adapter import _InboundAdapter
 from iop._message import _Message
 from iop._message import _PickleMessage
 from iop._outbound_adapter import _OutboundAdapter
+from iop._polling_business_service import _PollingBusinessServiceMixin
 from iop._persistent_message import Field as Field
 from iop._persistent_message import Model as Model
 from iop._persistent_message import _PersistentMessage
 from iop._private_session_duplex import _PrivateSessionDuplex
 from iop._private_session_process import _PrivateSessionProcess
+from iop._settings import Category as Category
+from iop._settings import Setting as Setting
+from iop._settings import controls as controls
+from iop._settings import setting as setting
 from iop._utils import _Utils
 
 
@@ -30,6 +35,10 @@ class BusinessService(_BusinessService):
     pass
 
 
+class PollingBusinessService(_PollingBusinessServiceMixin, BusinessService):
+    pass
+
+
 class BusinessOperation(_BusinessOperation):
     pass
 

iop/__init__.py

@@ -10,11 +10,16 @@ from iop._message import (
     _PydanticPickleMessage,
 )
 from iop._outbound_adapter import _OutboundAdapter
+from iop._polling_business_service import _PollingBusinessServiceMixin
 from iop._persistent_message import Field as Field
 from iop._persistent_message import Model as Model
 from iop._persistent_message import _PersistentMessage
 from iop._private_session_duplex import _PrivateSessionDuplex
 from iop._private_session_process import _PrivateSessionProcess
+from iop._settings import Category as Category
+from iop._settings import Setting as Setting
+from iop._settings import controls as controls
+from iop._settings import setting as setting
 from iop._utils import _Utils
 
 
@@ -34,6 +39,10 @@ class BusinessService(_BusinessService):
     pass
 
 
+class PollingBusinessService(_PollingBusinessServiceMixin, BusinessService):
+    pass
+
+
 class BusinessOperation(_BusinessOperation):
     pass
 

iop/_cli.py

@@ -13,6 +13,7 @@ from importlib.metadata import version
 from ._local import _LocalDirector
 from ._remote import _RemoteDirector, get_remote_settings
 from ._director_protocol import DirectorProtocol
+from ._utils import _Utils
 
 
 class CommandType(Enum):
@@ -57,6 +58,7 @@ class CommandArgs:
     force_local: bool = False
     remote_settings: Optional[str] = None
     update: bool = False
+    migration_plan: bool = False
 
 
 class Command:
@@ -252,7 +254,27 @@ class Command:
         if migrate_path is not None:
             if not os.path.isabs(migrate_path):
                 migrate_path = os.path.join(os.getcwd(), migrate_path)
+            mode = "REMOTE" if self._is_remote else "LOCAL"
+            if self.args.migration_plan:
+                print(
+                    _Utils.explain_migration(
+                        migrate_path, mode=mode, namespace=self.director.namespace
+                    )
+                )
+                return
+            if self._is_remote:
+                print(
+                    _Utils.explain_migration(
+                        migrate_path, mode=mode, namespace=self.director.namespace
+                    )
+                )
             self.director.migrate(migrate_path)
+            if self._is_remote:
+                print(
+                    _Utils.format_migration_success(
+                        migrate_path, namespace=self.director.namespace
+                    )
+                )
 
     def _handle_log(self) -> None:
         if self.args.log == "not_set":
@@ -406,6 +428,13 @@ def create_parser() -> argparse.ArgumentParser:
         help="force local mode, skip remote even if REMOTE_SETTINGS or IOP_URL is present",
         action="store_true",
     )
+    migrate.add_argument(
+        "--dry-run",
+        "--explain",
+        dest="migration_plan",
+        help="show the migration plan and validation messages without writing to IRIS",
+        action="store_true",
+    )
 
     remote = main_parser.add_argument_group("remote arguments")
     remote.add_argument(

iop/_common.py

@@ -1,11 +1,143 @@
 import abc
 import inspect
 import traceback
-from typing import Any, ClassVar, List, Optional, Tuple
+from enum import Enum
+from types import UnionType
+from typing import (
+    Annotated,
+    Any,
+    ClassVar,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from . import _iris
-from ._log_manager import LogManager, logging
 from ._debugpy import debugpython
+from ._log_manager import LogManager, logging
+from ._settings import Setting
+
+
+_NO_VALUE = object()
+
+_EXCLUDED_SETTING_NAMES = {
+    "INFO_URL",
+    "ICON_URL",
+    "PERSISTENT_PROPERTY_LIST",
+    "log_to_console",
+    "logger",
+    "iris_handle",
+    "DISPATCH",
+    "adapter",
+    "Adapter",
+    "buffer",
+    "BusinessHost",
+    "business_host",
+    "business_host_python",
+}
+
+_PYTHON_TYPE_TO_IRIS = {
+    int: "Integer",
+    float: "Numeric",
+    complex: "Numeric",
+    bool: "Boolean",
+    str: "String",
+}
+
+_SIMPLE_TYPE_NAMES = {
+    "int": "Integer",
+    "integer": "Integer",
+    "float": "Numeric",
+    "complex": "Numeric",
+    "number": "Numeric",
+    "numeric": "Numeric",
+    "bool": "Boolean",
+    "boolean": "Boolean",
+    "str": "String",
+    "string": "String",
+}
+
+
+def _string_metadata(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, Enum):
+        return str(value.value)
+    return str(value)
+
+
+def _type_hints_with_extras(cls) -> dict[str, Any]:
+    try:
+        return get_type_hints(cls, include_extras=True)
+    except Exception:
+        hints: dict[str, Any] = {}
+        for base in reversed(inspect.getmro(cls)):
+            hints.update(getattr(base, "__annotations__", {}))
+        return hints
+
+
+def _unwrap_annotated(data_type: Any) -> tuple[Any, tuple[Any, ...]]:
+    if get_origin(data_type) is Annotated:
+        args = get_args(data_type)
+        if args:
+            return args[0], args[1:]
+    return data_type, ()
+
+
+def _setting_from_annotation(data_type: Any) -> tuple[Any, Optional[Setting]]:
+    data_type, metadata = _unwrap_annotated(data_type)
+    setting = None
+    for item in metadata:
+        if isinstance(item, Setting):
+            setting = item
+    return data_type, setting
+
+
+def _unwrap_optional(data_type: Any) -> Any:
+    origin = get_origin(data_type)
+    if origin in (Union, UnionType):
+        args = [arg for arg in get_args(data_type) if arg is not type(None)]
+        if len(args) == 1:
+            return args[0]
+    return data_type
+
+
+def _iris_data_type(data_type: Any) -> Optional[str]:
+    if data_type is None or data_type == "":
+        return None
+
+    data_type, _ = _unwrap_annotated(data_type)
+    data_type = _unwrap_optional(data_type)
+
+    if data_type is Any or data_type is object:
+        return "String"
+
+    if isinstance(data_type, str):
+        data_type = data_type.strip()
+        return _SIMPLE_TYPE_NAMES.get(data_type.lower(), data_type)
+
+    if data_type in _PYTHON_TYPE_TO_IRIS:
+        return _PYTHON_TYPE_TO_IRIS[data_type]
+
+    origin = get_origin(data_type)
+    if origin in _PYTHON_TYPE_TO_IRIS:
+        return _PYTHON_TYPE_TO_IRIS[origin]
+    if origin is not None:
+        return "String"
+
+    return None
+
+
+def _is_setting_member(name: str, value: Any) -> bool:
+    if name.startswith("_") or name in _EXCLUDED_SETTING_NAMES:
+        return False
+    return not (
+        inspect.ismethod(value) or inspect.isfunction(value) or inspect.isclass(value)
+    )
 
 
 class _Common(metaclass=abc.ABCMeta):
@@ -168,87 +300,117 @@ class _Common(metaclass=abc.ABCMeta):
         - Required flag
         - Category
         - Description
+        - Control/editor context
 
         Only includes non-private class attributes and properties.
         """
         ret = []
         try:
-            # getmembers() returns all the members of an obj
-            for member in inspect.getmembers(cls):
-                # remove private and protected functions
-                if not member[0].startswith("_"):
-                    # remove other methods and functions
-                    if (
-                        not inspect.ismethod(member[1])
-                        and not inspect.isfunction(member[1])
-                        and not inspect.isclass(member[1])
-                    ):
-                        if member[0] not in (
-                            "INFO_URL",
-                            "ICON_URL",
-                            "PERSISTENT_PROPERTY_LIST",
-                            "log_to_console",
-                            "logger",
-                            "iris_handle",
-                            "DISPATCH",
-                            "adapter",
-                            "Adapter",
-                            "buffer",
-                            "BusinessHost",
-                            "business_host",
-                            "business_host_python",
-                        ):
-                            name = member[0]
-                            req = 0
-                            cat = "Additional"
-                            desc = ""
-                            # get value, set to "" if None or a @property
-                            val = member[1]
-                            if isinstance(val, property) or (val is None):
-                                val = ""
-                            dt = str(type(val))[8:-2]
-                            # get datatype from attribute definition, default to String
-                            data_type = {
-                                "int": "Integer",
-                                "float": "Numeric",
-                                "complex": "Numeric",
-                                "bool": "Boolean",
-                            }.get(dt, "String")
-                            # if the user has created a attr_info function, then check the annotation on the return from that for more information about this attribute
-                            if hasattr(cls, name + "_info"):
-                                func = getattr(cls, name + "_info")
-                                if callable(func):
-                                    annotations = func.__annotations__["return"]
-                                    if annotations is not None:
-                                        if bool(annotations.get("ExcludeFromSettings")):
-                                            # don't add this attribute to the settings list
-                                            continue
-                                        req = bool(annotations.get("IsRequired"))
-                                        cat = annotations.get("Category", "Additional")
-                                        desc = annotations.get("Description")
-                                        dt = annotations.get("DataType")
-                                        # only override DataType found
-                                        if (dt is not None) and ("" != dt):
-                                            data_type = {
-                                                int: "Integer",
-                                                float: "Number",
-                                                complex: "Number",
-                                                bool: "Boolean",
-                                                str: "String",
-                                            }.get(dt, str(dt))
-                                    default = func()
-                                    if default is not None:
-                                        val = default
-                            # create list of information for this specific property
-                            info = []
-                            info.append(name)  # Name
-                            info.append(data_type)  # DataType
-                            info.append(val)  # Default Value
-                            info.append(req)  # Required
-                            info.append(cat)  # Category
-                            info.append(desc)  # Description
-                            # add this property to the list
-                            ret.append(info)
+            annotations = _type_hints_with_extras(cls)
+            members = dict(inspect.getmembers(cls))
+
+            names = [
+                name
+                for name, value in members.items()
+                if _is_setting_member(name, value)
+            ]
+            for name in annotations:
+                if (
+                    name in names
+                    or name.startswith("_")
+                    or name in _EXCLUDED_SETTING_NAMES
+                ):
+                    continue
+                value = members.get(name, _NO_VALUE)
+                if value is not _NO_VALUE and not _is_setting_member(name, value):
+                    continue
+                names.append(name)
+
+            for name in names:
+                member_exists = name in members
+                val = members.get(name, "")
+                annotated_type, annotated_setting = _setting_from_annotation(
+                    annotations.get(name)
+                )
+                value_setting = val if isinstance(val, Setting) else None
+                setting_info = value_setting or annotated_setting
+
+                if setting_info is not None and setting_info.exclude:
+                    continue
+
+                req = bool(setting_info.required) if setting_info is not None else False
+                cat = setting_info.category if setting_info is not None else ""
+                desc = setting_info.description if setting_info is not None else ""
+                control = setting_info.control if setting_info is not None else ""
+
+                if value_setting is not None:
+                    val = value_setting.default if value_setting.has_default else ""
+                elif (
+                    not member_exists
+                    and annotated_setting is not None
+                    and annotated_setting.has_default
+                ):
+                    val = annotated_setting.default
+                elif not member_exists:
+                    val = ""
+
+                if isinstance(val, property) or (val is None):
+                    val = ""
+
+                if setting_info is not None and setting_info.iris_type:
+                    data_type = setting_info.iris_type
+                else:
+                    data_type_source = (
+                        setting_info.data_type
+                        if setting_info is not None and setting_info.data_type
+                        else annotated_type
+                    )
+                    data_type = _iris_data_type(data_type_source)
+                    if data_type is None:
+                        data_type = _iris_data_type(type(val)) or "String"
+
+                # Legacy attr_info() support. Values supplied here keep working
+                # and can also provide the new control/editor context field.
+                if hasattr(cls, name + "_info"):
+                    func = getattr(cls, name + "_info")
+                    if callable(func):
+                        info_annotations = getattr(func, "__annotations__", {}).get(
+                            "return"
+                        )
+                        if info_annotations is not None:
+                            if bool(info_annotations.get("ExcludeFromSettings")):
+                                continue
+                            req = bool(info_annotations.get("IsRequired", req))
+                            cat = _string_metadata(
+                                info_annotations.get("Category", cat)
+                            )
+                            desc = _string_metadata(
+                                info_annotations.get("Description", desc)
+                            )
+                            control = _string_metadata(
+                                info_annotations.get(
+                                    "Control",
+                                    info_annotations.get("EditorContext", control),
+                                )
+                            )
+                            dt = info_annotations.get("DataType")
+                            if (dt is not None) and ("" != dt):
+                                data_type = _iris_data_type(dt) or str(dt)
+                        default = func()
+                        if default is not None:
+                            val = default
+
+                ret.append(
+                    [
+                        name,  # Name
+                        data_type,  # DataType
+                        val,  # Default Value
+                        req,  # Required
+                        _string_metadata(cat),  # Category
+                        _string_metadata(desc),  # Description
+                        _string_metadata(control),  # Control/editor context
+                    ]
+                )
         except Exception:
             pass
         return ret

iop/_local.py

@@ -95,7 +95,7 @@ class _LocalDirector(_DirectorProtocol):
     # ------------------------------------------------------------------
 
     def migrate(self, path: str) -> None:
-        _Utils.migrate(path)
+        _Utils.migrate(path, mode="LOCAL", namespace=self.namespace)
 
     # ------------------------------------------------------------------
     # Metadata

iop/_polling_business_service.py

@@ -0,0 +1,6 @@
+class _PollingBusinessServiceMixin:
+    """Mixin for services polled by the default IRIS inbound adapter."""
+
+    @staticmethod
+    def get_adapter_type() -> str:
+        return "Ens.InboundAdapter"

iop/_settings.py

@@ -0,0 +1,188 @@
+from enum import Enum
+from typing import Any
+
+
+_MISSING = object()
+
+
+class Category(str, Enum):
+    """Common IRIS production setting categories for Management Portal grouping."""
+
+    INFO = "Info"
+    BASIC = "Basic"
+    CONNECTION = "Connection"
+    ADDITIONAL = "Additional"
+    ALERTING = "Alerting"
+    DEV = "Dev"
+
+
+def _string_value(value: Any) -> str:
+    if isinstance(value, Enum):
+        return str(value.value)
+    return str(value)
+
+
+class Setting:
+    """Metadata for an IRIS production setting."""
+
+    def __init__(
+        self,
+        default: Any = _MISSING,
+        *,
+        data_type: Any = None,
+        iris_type: str | None = None,
+        category: str | Category | None = None,
+        required: bool = False,
+        description: str = "",
+        control: str | None = None,
+        exclude: bool = False,
+    ):
+        self.default = default
+        self.data_type = data_type
+        self.iris_type = iris_type
+        self.category = _string_value(category) if category is not None else None
+        self.required = required
+        self.description = description or ""
+        self.control = control or ""
+        self.exclude = exclude
+        self.name = ""
+
+    def __set_name__(self, owner, name):
+        self.name = name
+
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        if self.name in instance.__dict__:
+            return instance.__dict__[self.name]
+        if self.default is _MISSING:
+            return None
+        return self.default
+
+    def __set__(self, instance, value):
+        instance.__dict__[self.name] = value
+
+    @property
+    def has_default(self) -> bool:
+        return self.default is not _MISSING
+
+
+def setting(default: Any = _MISSING, **kwargs) -> Setting:
+    return Setting(default, **kwargs)
+
+
+class _Controls:
+    """Helpers for IRIS production setting editor controls."""
+
+    @staticmethod
+    def raw(value: str) -> str:
+        """Return an advanced IRIS editor context string unchanged."""
+        return value
+
+    @staticmethod
+    def selector(
+        context: str | None = None, *, multi_select: bool | None = None, **params
+    ) -> str:
+        """Build an IRIS selector editor context from a context search string."""
+        query = []
+        if multi_select is not None:
+            query.append(f"multiSelect={1 if multi_select else 0}")
+        if context:
+            if not (context.startswith("{") and context.endswith("}")):
+                context = "{" + context + "}"
+            query.append(f"context={context}")
+        for key, value in params.items():
+            if value is not None:
+                query.append(f"{key}={value}")
+        return "selector" + (f"?{'&'.join(query)}" if query else "")
+
+    @staticmethod
+    def production_item(
+        *,
+        targets: bool = True,
+        production_name: str = "@productionId",
+        multi_select: bool = False,
+    ) -> str:
+        """Select production items, normally target components, from a production."""
+        context = (
+            "Ens.ContextSearch/ProductionItems?"
+            f"targets={1 if targets else 0}&productionName={production_name}"
+        )
+        return _Controls.selector(context, multi_select=multi_select or None)
+
+    @staticmethod
+    def partner() -> str:
+        """Select a partner setting value."""
+        return "partnerSelector"
+
+    @staticmethod
+    def rule() -> str:
+        """Select an IRIS rule definition."""
+        return "ruleSelector"
+
+    @staticmethod
+    def credentials() -> str:
+        """Select an IRIS credentials entry."""
+        return "credentialsSelector"
+
+    @staticmethod
+    def directory() -> str:
+        """Select a directory path."""
+        return "directorySelector"
+
+    @staticmethod
+    def file() -> str:
+        """Select a file path."""
+        return "fileSelector"
+
+    @staticmethod
+    def dtl() -> str:
+        """Select an IRIS DTL data transformation."""
+        return "dtlSelector"
+
+    @staticmethod
+    def schedule() -> str:
+        """Select an IRIS schedule."""
+        return "scheduleSelector"
+
+    @staticmethod
+    def ssl_config() -> str:
+        """Select an IRIS SSL/TLS configuration."""
+        return "sslConfigSelector"
+
+    @staticmethod
+    def bpl() -> str:
+        """Select an IRIS BPL business process."""
+        return "bplSelector"
+
+    @staticmethod
+    def character_set() -> str:
+        """Select an IRIS character set."""
+        return _Controls.selector("Ens.ContextSearch/CharacterSets")
+
+    charset = character_set
+
+    @staticmethod
+    def framing(*, host: str = "@currHostId", prop: str = "Framing") -> str:
+        """Select a display-list value such as the current host framing option."""
+        return _Controls.selector(
+            f"Ens.ContextSearch/getDisplayList?host={host}&prop={prop}"
+        )
+
+    @staticmethod
+    def local_interface() -> str:
+        """Select a configured TCP local interface."""
+        return _Controls.selector("Ens.ContextSearch/TCPLocalInterfaces")
+
+    @staticmethod
+    def schema_category(host: str) -> str:
+        """Select a schema category for the specified host expression."""
+        return _Controls.selector(f"Ens.ContextSearch/SchemaCategories?host={host}")
+
+    @staticmethod
+    def search_table(host: str) -> str:
+        """Select a search table class for the specified host expression."""
+        return _Controls.selector(f"Ens.ContextSearch/SearchTableClasses?host={host}")
+
+
+controls = _Controls()

iop/_utils.py

@@ -6,7 +6,7 @@ import importlib.resources
 import json
 import inspect
 import ast
-from typing import Optional, Tuple
+from typing import Any, Optional, Tuple
 
 import xmltodict
 from pydantic import TypeAdapter
@@ -71,6 +71,13 @@ class _Utils:
 
         :param cls: The class to register
         """
+        if is_persistent_message_class(msg_cls):
+            raise ValueError(
+                f"{_Utils._python_classname(msg_cls)} is a PersistentMessage. "
+                "Register it in CLASSES, not SCHEMAS."
+            )
+        if not inspect.isclass(msg_cls):
+            raise ValueError("SCHEMAS entries must be message classes.")
         if issubclass(msg_cls, _PydanticMessage):
             schema = msg_cls.model_json_schema()
         elif issubclass(msg_cls, _Message):
@@ -78,7 +85,8 @@ class _Utils:
             schema = type_adapter.json_schema()
         else:
             raise ValueError(
-                "The class must be a subclass of _Message or _PydanticMessage"
+                f"{_Utils._python_classname(msg_cls)} cannot be registered as a "
+                "DTL schema. Use a Message or PydanticMessage subclass."
             )
         schema_name = msg_cls.__module__ + "." + msg_cls.__name__
         schema_str = json.dumps(schema)
@@ -118,6 +126,23 @@ class _Utils:
             msg_cls, iris_classname, sync_schema=sync_schema
         )
 
+    @staticmethod
+    def _python_classname(value: Any) -> str:
+        module = getattr(value, "__module__", "")
+        name = getattr(value, "__name__", repr(value))
+        return f"{module}.{name}" if module else str(name)
+
+    @staticmethod
+    def _is_message_schema_class(value: Any) -> bool:
+        try:
+            return (
+                inspect.isclass(value)
+                and (issubclass(value, _Message) or issubclass(value, _PydanticMessage))
+                and not is_persistent_message_class(value)
+            )
+        except TypeError:
+            return False
+
     @staticmethod
     def get_python_settings() -> Tuple[str, str, str]:
         import iris_utils._cli
@@ -268,6 +293,7 @@ class _Utils:
                     "BusinessOperation",
                     "BusinessProcess",
                     "BusinessService",
+                    "PollingBusinessService",
                     "DuplexService",
                     "DuplexProcess",
                     "DuplexOperation",
@@ -329,7 +355,9 @@ class _Utils:
         return module
 
     @staticmethod
-    def migrate(filename=None):
+    def migrate(
+        filename=None, mode: Optional[str] = None, namespace: Optional[str] = None
+    ):
         """
         Read the settings.py file and register all the components
         settings.py file has two dictionaries:
@@ -345,9 +373,120 @@ class _Utils:
         """
         settings, path = _Utils._load_settings(filename)
 
-        _Utils._register_settings_components(settings, path)
+        try:
+            plan = _Utils._build_migration_plan(
+                settings, path, filename, mode=mode, namespace=namespace
+            )
+            print(_Utils.format_migration_plan(plan))
+            _Utils._register_settings_components(settings, path)
+            print(
+                _Utils.format_migration_success(
+                    filename or inspect.getfile(settings), namespace=namespace
+                )
+            )
+        finally:
+            _Utils._cleanup_sys_path(path)
+
+    @staticmethod
+    def explain_migration(
+        filename=None, mode: Optional[str] = None, namespace: Optional[str] = None
+    ):
+        """Return a human-readable migration plan without writing to IRIS."""
+        settings, path = _Utils._load_settings(filename)
+        try:
+            plan = _Utils._build_migration_plan(
+                settings, path, filename, mode=mode, namespace=namespace
+            )
+            return _Utils.format_migration_plan(plan)
+        finally:
+            _Utils._cleanup_sys_path(path)
+
+    @staticmethod
+    def format_migration_success(filename, namespace: Optional[str] = None):
+        suffix = f" in namespace {namespace}" if namespace else ""
+        return f"Migration succeeded{suffix}: {filename}"
 
-        _Utils._cleanup_sys_path(path)
+    @staticmethod
+    def format_migration_plan(plan):
+        """Format a migration plan for CLI and migration output."""
+        lines = [f"Migration plan: {plan['settings']}"]
+        if plan.get("mode"):
+            lines.append(f"Mode: {plan['mode']}")
+        if plan.get("namespace"):
+            lines.append(f"Namespace: {plan['namespace']}")
+        lines.append("")
+        lines.extend(_Utils._format_plan_section("CLASSES", plan["classes"]))
+        lines.extend(_Utils._format_plan_section("SCHEMAS", plan["schemas"]))
+        lines.extend(_Utils._format_plan_section("PRODUCTIONS", plan["productions"]))
+        return "\n".join(lines)
+
+    @staticmethod
+    def _format_plan_section(title, entries):
+        lines = [f"{title}:"]
+        if entries:
+            lines.extend(f"  {entry}" for entry in entries)
+        else:
+            lines.append("  none")
+        lines.append("")
+        return lines
+
+    @staticmethod
+    def _build_migration_plan(
+        settings,
+        path,
+        filename=None,
+        mode: Optional[str] = None,
+        namespace: Optional[str] = None,
+    ):
+        """Build and validate a migration plan from a settings module."""
+        if not path:
+            path = os.path.dirname(inspect.getfile(settings))
+
+        plan = {
+            "settings": filename or inspect.getfile(settings),
+            "mode": mode,
+            "namespace": namespace,
+            "classes": [],
+            "schemas": [],
+            "productions": [],
+        }
+
+        classes = getattr(settings, "CLASSES", {})
+        if not isinstance(classes, dict):
+            raise ValueError("CLASSES must be a dictionary.")
+        for key, value in classes.items():
+            kind, target = _Utils._classify_class_setting(value, path)
+            if kind == "message_schema":
+                schema_hint = value.__name__ if inspect.isclass(value) else target
+                raise ValueError(
+                    f"{target} is a Message/PydanticMessage and cannot be registered "
+                    f"in CLASSES. Use SCHEMAS = [{schema_hint}] if you "
+                    "need DTL support. Otherwise, no migration is required for this "
+                    "message."
+            )
+            if kind == "persistent_message":
+                plan["classes"].append(f"{key} -> {target} (PersistentMessage)")
+            else:
+                plan["classes"].append(f"{key} -> {target} (component)")
+
+        schemas = getattr(settings, "SCHEMAS", None)
+        if schemas is not None:
+            if not isinstance(schemas, list):
+                raise ValueError("SCHEMAS must be a list of message classes.")
+            for cls in schemas:
+                _Utils._validate_dtl_schema_class(cls, "SCHEMAS")
+                plan["schemas"].append(_Utils._python_classname(cls))
+
+        productions = getattr(settings, "PRODUCTIONS", None)
+        if productions is not None:
+            if not isinstance(productions, list):
+                raise ValueError("PRODUCTIONS must be a list.")
+            for production in productions:
+                if not isinstance(production, dict) or not production:
+                    raise ValueError("Each PRODUCTION entry must be a non-empty dict.")
+                plan["productions"].append(next(iter(production.keys())))
+
+        return plan
 
     @staticmethod
     def _load_settings(filename):
@@ -390,6 +529,52 @@ class _Utils:
         else:
             return os.getcwd()
 
+    @staticmethod
+    def _classify_class_setting(value, root_path=None):
+        if inspect.isclass(value):
+            if is_persistent_message_class(value):
+                return "persistent_message", _Utils._python_classname(value)
+            if _Utils._is_message_schema_class(value):
+                return "message_schema", _Utils._python_classname(value)
+            return "component", _Utils._python_classname(value)
+
+        if inspect.ismodule(value):
+            return "component", f"{value.__name__}.*"
+
+        if isinstance(value, dict):
+            if "path" in value and "module" in value and "class" in value:
+                cls = _Utils._try_import_class(
+                    value["module"], value["class"], value["path"]
+                )
+                target = f"{value['module']}.{value['class']}"
+                if cls is not None:
+                    if is_persistent_message_class(cls):
+                        return "persistent_message", target
+                    if _Utils._is_message_schema_class(cls):
+                        return "message_schema", target
+                return "component", target
+            if "path" in value and "package" in value:
+                return "component", f"{value['package']} package"
+            if "path" in value and "file" in value:
+                return "component", value["file"]
+            if "path" in value:
+                return "component", value["path"]
+
+        raise ValueError(f"Invalid migration class entry: {value!r}.")
+
+    @staticmethod
+    def _validate_dtl_schema_class(cls, setting_name):
+        if is_persistent_message_class(cls):
+            raise ValueError(
+                f"{_Utils._python_classname(cls)} is a PersistentMessage. Register it "
+                "in CLASSES, not SCHEMAS."
+            )
+        if not _Utils._is_message_schema_class(cls):
+            raise ValueError(
+                f"{_Utils._python_classname(cls)} cannot be registered in "
+                f"{setting_name}. Use a Message or PydanticMessage subclass."
+            )
+
     @staticmethod
     def _register_settings_components(settings, path):
         """Register all components from settings (classes, productions, schemas).
@@ -402,24 +587,23 @@ class _Utils:
         if not path:
             path = os.path.dirname(inspect.getfile(settings))
 
-        try:
-            # set the classes settings
-            _Utils.set_classes_settings(settings.CLASSES, path)
-        except AttributeError:
-            print("No classes to register")
+        class_items = getattr(settings, "CLASSES", None)
+        if class_items is not None:
+            _Utils.set_classes_settings(class_items, path)
 
         try:
             # set the productions settings
             _Utils.set_productions_settings(settings.PRODUCTIONS, path)
         except AttributeError:
-            print("No productions to register")
-
-        try:
-            # set the schemas
-            for cls in settings.SCHEMAS:
+            pass
+
+        schemas = getattr(settings, "SCHEMAS", None)
+        if schemas is not None:
+            if not isinstance(schemas, list):
+                raise ValueError("SCHEMAS must be a list of message classes.")
+            for cls in schemas:
+                _Utils._validate_dtl_schema_class(cls, "SCHEMAS")
                 _Utils.register_message_schema(cls)
-        except AttributeError:
-            print("No schemas to register")
 
     @staticmethod
     def _cleanup_sys_path(path):
@@ -456,11 +640,21 @@ class _Utils:
         :param class_items: a dictionary of classes
         :return: a dictionary of settings for each class
         """
+        if not isinstance(class_items, dict):
+            raise ValueError("CLASSES must be a dictionary.")
         for key, value in class_items.items():
             if inspect.isclass(value):
                 if is_persistent_message_class(value):
                     _Utils.register_persistent_message(value, key)
                     continue
+                if _Utils._is_message_schema_class(value):
+                    raise ValueError(
+                        f"{_Utils._python_classname(value)} is a Message/"
+                        "PydanticMessage and cannot be registered in CLASSES. "
+                        f"Use SCHEMAS = [{value.__name__}] if you need DTL "
+                        "support. Otherwise, no migration is required for this "
+                        "message."
+                    )
                 path = None
                 if root_path:
                     path = root_path
@@ -486,6 +680,14 @@ class _Utils:
                     if msg_cls is not None and is_persistent_message_class(msg_cls):
                         _Utils.register_persistent_message(msg_cls, key)
                         continue
+                    if msg_cls is not None and _Utils._is_message_schema_class(msg_cls):
+                        raise ValueError(
+                            f"{value['module']}.{value['class']} is a Message/"
+                            "PydanticMessage and cannot be registered in CLASSES. "
+                            "Use SCHEMAS if you need DTL "
+                            "support. Otherwise, no migration is required for this "
+                            "message."
+                        )
                     # register the component
                     _Utils.register_component(
                         value["module"], value["class"], value["path"], 1, key

iop/cls/IOP/Utils.cls

@@ -352,12 +352,32 @@ ClassMethod GenerateProxyClass(
 				}
 			}
 			Set tCustomProp.Required = tPropInfo."__getitem__"(3)
+			Set tDesc = ""
+			If (builtins.len(tPropInfo)>5) {
+				Set tDesc = tPropInfo."__getitem__"(5)
+			}
+			If ""'=tDesc {
+				Set tCustomProp.Description = tDesc
+			}
 			
 			Set tSC = tCOSClass.Properties.Insert(tCustomProp)
 			Quit:$$$ISERR(tSC)
 
-			Set tPropCat = "Python Attributes $type"
+			Set tPropCat = ""
+			If (builtins.len(tPropInfo)>4) {
+				Set tPropCat = tPropInfo."__getitem__"(4)
+			}
+			If ""=tPropCat {
+				Set tPropCat = "Python Attributes $type"
+			}
+			Set tContext = ""
+			If (builtins.len(tPropInfo)>6) {
+				Set tContext = tPropInfo."__getitem__"(6)
+			}
 			Set tSETTINGSParamValue = tSETTINGSParamValue_","_tPropName_":"_tPropCat
+			If ""'=tContext {
+				Set tSETTINGSParamValue = tSETTINGSParamValue_":"_tContext
+			}
 		}
 		Quit:$$$ISERR(tSC)
 

{iris_pex_embedded_python-3.7.2b1.dist-info → iris_pex_embedded_python-3.7.2b2.dist-info}/METADATA

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

{iris_pex_embedded_python-3.7.2b1.dist-info → iris_pex_embedded_python-3.7.2b2.dist-info}/RECORD

@@ -19,7 +19,7 @@ grongier/cls/Grongier/PEX/PrivateSession/Message/Poll.cls,sha256=pcUgHgxX1pMH-wQ
 grongier/cls/Grongier/PEX/PrivateSession/Message/Start.cls,sha256=T3jNoR8RjKr1InQ6SgqBYTgFwpSB0Q60WholjbvForg,433
 grongier/cls/Grongier/PEX/PrivateSession/Message/Stop.cls,sha256=zy30ZXXN4XcovPij-kOF3PuH1SkP1EUvlEJQRx2S9RU,431
 grongier/cls/Grongier/Service/WSGI.cls,sha256=7u2SsFmnsubMfdazvaDchKCM3yesPRMfKBzMIkwQ9xc,77
-grongier/pex/__init__.py,sha256=mOCWppLEgwnLHzY_8UFFbT2ftZ22KApvDOjhYRB4SQ8,1355
+grongier/pex/__init__.py,sha256=XxMw6cAaCEEtmFIAL5-FrRkM1u-aQbbYvzr1WE7zYMw,1698
 grongier/pex/__main__.py,sha256=pQzVtkDhAeI6dpNRC632dVk2SGZZIEDwDufdgZe8VWs,98
 grongier/pex/_business_host.py,sha256=dlV8CWJad8Pr2TNfD9OjcVKaq5gEYQACZla1FK6-bDM,44
 grongier/pex/_cli.py,sha256=hOHz3n-aHtULuhdCkqZ_SSb3sv7M6j2WhRxgCTvgR9I,64
@@ -27,15 +27,15 @@ grongier/pex/_common.py,sha256=HZwG2C2-yB8yNN8kXhI6vxg8h-rROuEx38YOVFWIk1s,31
 grongier/pex/_director.py,sha256=pCmoiJ-sxe24yQaDz6ZFBsAnqU6fh57_dlew98B7rtE,35
 grongier/pex/_utils.py,sha256=gvsdr8WhWrE6smlsCxhoF14VUZfitrwqr5J57HkJhi4,29
 grongier/pex/wsgi/handlers.py,sha256=NrFLo_YbAh-x_PlWhAiWkQnUUN2Ss9HoEm63dDWCBpQ,2947
-iop/__init__.py,sha256=rtIVTkzR8gxm2zZBQZBkYO8bWylkce0TiUKslwCw7IQ,1510
+iop/__init__.py,sha256=tb9Vcz2XzApqKWxit4WTEecyiPB9PRWG8MJdPN9J_wI,1853
 iop/__main__.py,sha256=C0MZpXA8XFopuveMDbZgX1bttrb2DxarhaY1XYfbhsg,100
 iop/_async_request.py,sha256=lW3vasdepKwLPuWRm1zDs3xlRWCoVL0RJZqVUj8gkJw,2409
 iop/_business_host.py,sha256=l0X_2xiMArMQsvI99kXDuI6vVrJMvPHZtDnXHGqT7c4,11669
 iop/_business_operation.py,sha256=AhKw-KKpOatXGqaMFwMcb774SF0a4ZIWeRCUGN-al_Q,2985
 iop/_business_process.py,sha256=tDgZSb8JhwzUAbBXvm9qKzbdlhaeXfVLoUIGOXCoeZs,8821
 iop/_business_service.py,sha256=3oSL4_Dam_WDD7J2BpYVd_WQKUPUnCcLH_bjwXvWqKc,3960
-iop/_cli.py,sha256=h_s2QZpl0DpeNB6228y3LJEeZDwfvDdJcKSQLkRRVzA,16030
-iop/_common.py,sha256=Vo_lrXNm0u_3naDku_Ma8gjBqN0-kpOIUR2vfBOcrrM,15772
+iop/_cli.py,sha256=O9VMWBZnuubA5CZmvp7rMJfcBfQPi7FhNkxHBs7ncXk,17072
+iop/_common.py,sha256=U10pvB1sSFhtJfJ7BzEo19XfNWAUDv54dqFFqp1Gl0g,19234
 iop/_debugpy.py,sha256=0UOLkOjXkJ24GxxyEnPckafrAtfVVUDYIedmLIznYfM,6067
 iop/_decorators.py,sha256=2UFV56sfopuBqgxTTj71XgAAwoQm1ijDi_3N-GIKbu8,2337
 iop/_director.py,sha256=dN_SGyUDPH19kUt7_AR6vBrDlKUg0RRgYVkvJFjsYOM,11855
@@ -44,17 +44,19 @@ iop/_dispatch.py,sha256=UjrQuia4lSgC3It07m9BqnEBhmqjdd9Hp_b2QVaj4zc,5825
 iop/_generator_request.py,sha256=2No4E2mjBr7bPwBljsKbWX3QxTrjgdyz683tynlg-OI,1339
 iop/_inbound_adapter.py,sha256=WErDcXzHhYNN0QanmTay34Zh_uUxlEykJ4YmevTVOyY,1654
 iop/_iris.py,sha256=Zc4IvMv3us3rrBNCba1AU8RSXvct2wZkCZVSWN84c-k,198
-iop/_local.py,sha256=7N-xEjVRQmP6h1fEHQBlsPKBBe2B90KbLqi53cvA7Yo,3636
+iop/_local.py,sha256=bGTxgI83qsT5IxA-hZXhXEDAICeYc3Lku2MM5A8ApBs,3676
 iop/_log_manager.py,sha256=Egrul1LCQlYrvIgcoF-LjXoeXaLLh_nD9bB4P-Y-q_E,3225
 iop/_message.py,sha256=fTHxYHBq42QIDGrtVuw-7NJAQ7bLIWPdbl5EmwiDhG0,1465
 iop/_message_validator.py,sha256=XzQ4qkHLYoai2_gPk3ItXHVgwz2WldiBcNE32yaxOVc,1540
 iop/_outbound_adapter.py,sha256=GSsr6z0gvVygNyr3YicHBt7i2ZJu3wJgrCpPqod7Z_U,732
 iop/_persistent_message.py,sha256=F1WsgNqSupyKPkldQNnY96cGtD2mRwR9qSVE8SI6nXU,16780
+iop/_polling_business_service.py,sha256=uElSd77H7YhE3hi24Zzyfc9BMP8HSzGyo4fRzW3e0eM,199
 iop/_private_session_duplex.py,sha256=SLqwnB4gLKqCt-DClIEFg_yWcQs16A4Va7lRyUg-18o,5289
 iop/_private_session_process.py,sha256=J1HjRIphg0iHHEIa6Rqa68vA22ODMN6BfNqAN4Ybi1U,1723
 iop/_remote.py,sha256=zE4eZtNuqQemtX2gBwu59n56ixBtwkV25GvZgqVKlMU,17395
 iop/_serialization.py,sha256=5ajXh99QVFRXuwhR7xex3rHF87l07o8Fth2VOMRj-YM,8778
-iop/_utils.py,sha256=qBV546JXjWFO_KWB0n4OcKTuaiNcDvD3IJt9jh0a_Oo,26615
+iop/_settings.py,sha256=ZoPbYllsJJ5uAwcg1z2Gp-PChOAnKwMLsFNXppBuUGM,5510
+iop/_utils.py,sha256=46EO1ugcylkd4oLodvTyp2-byutgePjITHv0fXUjscI,35460
 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
@@ -66,7 +68,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=NGnfi2Kif3OyYwR6pm5c_-UKm5vEwQyfzvJpZGxFeeA,18546
+iop/cls/IOP/Utils.cls,sha256=1ujVAaBAjFAbbyirD0aFzRQoQva6SR_qJJG_s03V1l8,19042
 iop/cls/IOP/Wrapper.cls,sha256=37fUol-EcktdfGhpfi4o12p04975lKGaRYEFhw-fuaM,1614
 iop/cls/IOP/Duplex/Operation.cls,sha256=K_fmgeLjPZQbHgNrc0kd6DUQoW0fDn1VHQjJxHo95Zk,525
 iop/cls/IOP/Duplex/Process.cls,sha256=xbefZ4z84a_IUhavWN6P_gZBzqkdJ5XRTXxro6iDvAg,6986
@@ -86,9 +88,9 @@ iop/cls/IOP/Service/WSGI.cls,sha256=VLNCXEwmHW9dBnE51uGE1nvGX6T4HjhqePT3LVhsjAE,
 iop/cls/IOP/Service/Remote/Handler.cls,sha256=JfsXse2jvoVvQfW8_rVEt2DCQJ9SVqReCcOUngOkpzE,938
 iop/cls/IOP/Service/Remote/Rest/v1.cls,sha256=DRaYNsbFmczdVltb-HMZvviy5EcjcJx7__zmnKANNm8,14429
 iop/wsgi/handlers.py,sha256=lcCZ1ixnYqdo9eNrBSsQbhS9ei2x11p9e4SHHb__zmY,2951
-iris_pex_embedded_python-3.7.2b1.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
-iris_pex_embedded_python-3.7.2b1.dist-info/METADATA,sha256=VNHpmk3bjgjjn-O8AU-7jwLP1vmvPajAYvoVfBo-8Sk,4310
-iris_pex_embedded_python-3.7.2b1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-iris_pex_embedded_python-3.7.2b1.dist-info/entry_points.txt,sha256=pj-i4LSDyiSP6xpHlVjMCbg1Pik7dC3_sdGY3Yp9Vhk,38
-iris_pex_embedded_python-3.7.2b1.dist-info/top_level.txt,sha256=4p0q6hCATmYIVMVi3I8hOUcJE1kwzyBeHygWv_rGvrU,13
-iris_pex_embedded_python-3.7.2b1.dist-info/RECORD,,
+iris_pex_embedded_python-3.7.2b2.dist-info/licenses/LICENSE,sha256=rZSiBFId_sfbJ6RL0GjjPX-InNLkNS9ou7eQsikciI8,1089
+iris_pex_embedded_python-3.7.2b2.dist-info/METADATA,sha256=9XMFl2HGKtXPzs9ATPRwuQmsuu_Na1hG9R9X_YdAhao,4310
+iris_pex_embedded_python-3.7.2b2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+iris_pex_embedded_python-3.7.2b2.dist-info/entry_points.txt,sha256=pj-i4LSDyiSP6xpHlVjMCbg1Pik7dC3_sdGY3Yp9Vhk,38
+iris_pex_embedded_python-3.7.2b2.dist-info/top_level.txt,sha256=4p0q6hCATmYIVMVi3I8hOUcJE1kwzyBeHygWv_rGvrU,13
+iris_pex_embedded_python-3.7.2b2.dist-info/RECORD,,