iris-pex-embedded-python 3.7.2b1__tar.gz → 3.7.2b2__tar.gz

{iris_pex_embedded_python-3.7.2b1/src/iris_pex_embedded_python.egg-info → iris_pex_embedded_python-3.7.2b2}/PKG-INFO

@@ -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 → iris_pex_embedded_python-3.7.2b2}/pyproject.toml

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

{iris_pex_embedded_python-3.7.2b1 → iris_pex_embedded_python-3.7.2b2}/src/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
 

{iris_pex_embedded_python-3.7.2b1 → iris_pex_embedded_python-3.7.2b2}/src/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
 

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

{iris_pex_embedded_python-3.7.2b1 → iris_pex_embedded_python-3.7.2b2}/src/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

{iris_pex_embedded_python-3.7.2b1 → iris_pex_embedded_python-3.7.2b2}/src/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

iris_pex_embedded_python-3.7.2b2/src/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"

iris_pex_embedded_python-3.7.2b2/src/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()