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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 3.7.2b1
+Version: 4.0.0b1
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License
@@ -37,6 +37,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{iris_pex_embedded_python-3.7.2b1 → iris_pex_embedded_python-4.0.0b1}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.7.2b1"
+version = "4.0.0b1"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -20,6 +20,8 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Utilities"
 ]
 
@@ -42,10 +44,11 @@ repository = "https://github.com/grongierisc/interoperability-embedded-python"
 issues = "https://github.com/grongierisc/interoperability-embedded-python/issues"
 
 [project.scripts]
-iop = "iop._cli:main"
+iop = "iop.cli.main:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]
+include = ["iop*"]
 exclude = ["tests*"]
 
 [tool.setuptools.package-data]
@@ -59,3 +62,11 @@ markers = [
     "e2e_local: end-to-end test requiring a local IRIS instance",
     "e2e_remote: end-to-end test requiring a remote IRIS instance via REST API",
 ]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+ignore = ["E501"]

iris_pex_embedded_python-4.0.0b1/src/iop/__init__.py

@@ -0,0 +1,138 @@
+from iop.components.business_operation import _BusinessOperation
+from iop.components.business_process import _BusinessProcess
+from iop.components.business_service import _BusinessService
+from iop.components.inbound_adapter import _InboundAdapter
+from iop.components.outbound_adapter import _OutboundAdapter
+from iop.components.polling_business_service import _PollingBusinessServiceMixin
+from iop.components.private_session_duplex import _PrivateSessionDuplex
+from iop.components.private_session_process import _PrivateSessionProcess
+from iop.components.settings import Category as Category
+from iop.components.settings import Setting as Setting
+from iop.components.settings import controls as controls
+from iop.components.settings import setting as setting
+from iop.messages.base import (
+    _Message,
+    _PickleMessage,
+    _PydanticMessage,
+    _PydanticPickleMessage,
+)
+from iop.messages.persistent import Field as Field
+from iop.messages.persistent import Model as Model
+from iop.messages.persistent import _PersistentMessage
+from iop.migration.utils import _Utils
+from iop.migration.utils import bind_component as bind_component
+from iop.migration.utils import list_bindings as list_bindings
+from iop.migration.utils import register_component as register_component
+from iop.migration.utils import unbind_component as unbind_component
+from iop.migration.utils import unregister_component as unregister_component
+from iop.production import ComponentRef as ComponentRef
+from iop.production import Port as Port
+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 target as target
+from iop.runtime.director import _Director
+from iop.runtime.protocol import DirectorProtocol as DirectorProtocol
+
+__all__ = [
+    "BusinessOperation",
+    "BusinessProcess",
+    "BusinessService",
+    "Category",
+    "ComponentRef",
+    "Director",
+    "DirectorProtocol",
+    "DuplexOperation",
+    "DuplexProcess",
+    "DuplexService",
+    "Field",
+    "InboundAdapter",
+    "Message",
+    "Model",
+    "OutboundAdapter",
+    "PersistentMessage",
+    "PickleMessage",
+    "PollingBusinessService",
+    "Port",
+    "Production",
+    "ProductionDiff",
+    "ProductionDiffEntry",
+    "ProductionGraph",
+    "PydanticMessage",
+    "PydanticPickleMessage",
+    "Setting",
+    "Utils",
+    "bind_component",
+    "controls",
+    "list_bindings",
+    "register_component",
+    "setting",
+    "target",
+    "unbind_component",
+    "unregister_component",
+]
+
+
+class Utils(_Utils):
+    pass
+
+
+class InboundAdapter(_InboundAdapter):
+    pass
+
+
+class OutboundAdapter(_OutboundAdapter):
+    pass
+
+
+class BusinessService(_BusinessService):
+    pass
+
+
+class PollingBusinessService(_PollingBusinessServiceMixin, BusinessService):
+    pass
+
+
+class BusinessOperation(_BusinessOperation):
+    pass
+
+
+class BusinessProcess(_BusinessProcess):
+    pass
+
+
+class DuplexService(_PrivateSessionDuplex):
+    pass
+
+
+class DuplexOperation(_PrivateSessionDuplex):
+    pass
+
+
+class DuplexProcess(_PrivateSessionProcess):
+    pass
+
+
+class Message(_Message):
+    pass
+
+
+class PickleMessage(_PickleMessage):
+    pass
+
+
+class PydanticMessage(_PydanticMessage):
+    pass
+
+
+class PydanticPickleMessage(_PydanticPickleMessage):
+    pass
+
+
+class PersistentMessage(_PersistentMessage):
+    _iop_persistent_message_abstract = True
+
+
+class Director(_Director):
+    pass

iris_pex_embedded_python-4.0.0b1/src/iop/__main__.py

@@ -0,0 +1,5 @@
+# main entry is cli.main()
+if __name__ == "__main__":
+    from iop.cli.main import main
+
+    main()

iris_pex_embedded_python-4.0.0b1/src/iop/cli/__init__.py

@@ -0,0 +1 @@
+from .main import main as main

iris_pex_embedded_python-4.0.0b1/src/iop/cli/formatting.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import dataclasses
+import json
+from typing import Any
+
+
+def format_test_response(response: Any) -> str:
+    """Pretty-print any test_component() return value."""
+    if isinstance(response, dict):
+        parts = []
+        if response.get("error"):
+            return f"Error: {response['error']}"
+        if response.get("classname"):
+            parts.append(f"classname: {response['classname']}")
+        body = response.get("body", "")
+        if body:
+            try:
+                parsed = json.loads(body)
+                parts.append("body:\n" + json.dumps(parsed, indent=4))
+            except (json.JSONDecodeError, TypeError):
+                parts.append(f"body: {body}")
+        if response.get("truncated"):
+            parts.append("(response body was truncated)")
+        return "\n".join(parts) if parts else str(response)
+
+    if isinstance(response, str):
+        if " : " in response:
+            classname_part, _, body_part = response.partition(" : ")
+            try:
+                parsed = json.loads(body_part)
+                return (
+                    f"classname: {classname_part.strip()}\n"
+                    f"body:\n{json.dumps(parsed, indent=4)}"
+                )
+            except (json.JSONDecodeError, TypeError):
+                pass
+        try:
+            return json.dumps(json.loads(response), indent=4)
+        except (json.JSONDecodeError, TypeError):
+            return response
+
+    if dataclasses.is_dataclass(response):
+        return json.dumps(dataclasses.asdict(response), indent=4)
+    return str(response)

iris_pex_embedded_python-3.7.2b1/src/iop/_cli.py → iris_pex_embedded_python-4.0.0b1/src/iop/cli/main.py

@@ -1,62 +1,23 @@
 from __future__ import annotations
-import argparse
+
 import json
 import logging
-import requests
 import os
-from dataclasses import dataclass
-from enum import Enum, auto
 import sys
-from typing import Optional
 from importlib.metadata import version
 
-from ._local import _LocalDirector
-from ._remote import _RemoteDirector, get_remote_settings
-from ._director_protocol import DirectorProtocol
-
-
-class CommandType(Enum):
-    DEFAULT = auto()
-    LIST = auto()
-    START = auto()
-    STOP = auto()
-    KILL = auto()
-    RESTART = auto()
-    STATUS = auto()
-    TEST = auto()
-    VERSION = auto()
-    EXPORT = auto()
-    MIGRATE = auto()
-    LOG = auto()
-    INIT = auto()
-    HELP = auto()
-    UPDATE = auto()
-
-
-@dataclass
-class CommandArgs:
-    """Container for parsed command arguments"""
-
-    default: Optional[str] = None
-    list: bool = False
-    start: Optional[str] = None
-    detach: bool = False
-    stop: bool = False
-    kill: bool = False
-    restart: bool = False
-    status: bool = False
-    migrate: Optional[str] = None
-    export: Optional[str] = None
-    version: bool = False
-    log: Optional[str] = None
-    init: Optional[str] = None
-    test: Optional[str] = None
-    classname: Optional[str] = None
-    body: Optional[str] = None
-    namespace: Optional[str] = None
-    force_local: bool = False
-    remote_settings: Optional[str] = None
-    update: bool = False
+import requests
+
+from ..migration import utils as migration_utils
+from ..production import Production
+from ..runtime.local import _LocalDirector
+from ..runtime.protocol import DirectorProtocol
+from ..runtime.remote import _RemoteDirector, get_remote_settings
+from .formatting import format_test_response
+from .parser import create_parser
+from .types import CommandArgs, CommandType
+
+_format_test_response = format_test_response
 
 
 class Command:
@@ -112,12 +73,18 @@ class Command:
                 self.args.export,
                 self.args.migrate,
                 self.args.log,
+                self.args.queue,
                 self.args.init,
+                self.args.bindings,
+                self.args.unbind is not None,
                 self.args.update,
             ]
         )
 
     def execute(self) -> None:
+        if self.args.unused and not self.args.bindings:
+            raise ValueError("--unused can only be used with --bindings.")
+
         if self.args.namespace == "not_set" and not self._has_primary_command():
             print(os.getenv("IRISNAMESPACE", "not set"))
             return
@@ -136,7 +103,10 @@ class Command:
             CommandType.EXPORT: self._handle_export,
             CommandType.MIGRATE: self._handle_migrate,
             CommandType.LOG: self._handle_log,
+            CommandType.QUEUE: self._handle_queue,
             CommandType.INIT: self._handle_init,
+            CommandType.BINDINGS: self._handle_bindings,
+            CommandType.UNBIND: self._handle_unbind,
             CommandType.HELP: self._handle_help,
             CommandType.UPDATE: self._handle_update,
         }
@@ -169,8 +139,14 @@ class Command:
             return CommandType.MIGRATE
         if self.args.log:
             return CommandType.LOG
+        if self.args.queue:
+            return CommandType.QUEUE
         if self.args.init:
             return CommandType.INIT
+        if self.args.bindings:
+            return CommandType.BINDINGS
+        if self.args.unbind is not None:
+            return CommandType.UNBIND
         if self.args.update:
             return CommandType.UPDATE
         return CommandType.HELP
@@ -228,13 +204,13 @@ class Command:
             filepath = body[1:]
             if not os.path.isabs(filepath):
                 filepath = os.path.join(os.getcwd(), filepath)
-            with open(filepath, "r", encoding="utf-8") as fh:
+            with open(filepath, encoding="utf-8") as fh:
                 body = fh.read()
 
         response = self.director.test_component(
             test_name, classname=classname, body=body
         )
-        print(_format_test_response(response))
+        print(format_test_response(response))
 
     def _handle_version(self) -> None:
         print(version("iris-pex-embedded-python"))
@@ -245,14 +221,46 @@ class Command:
             if self.args.export == "not_set"
             else self.args.export
         )
-        print(json.dumps(self.director.export_production(export_name), indent=4))
+        export_format = self.args.export_format or "json"
+        if export_format == "json":
+            print(json.dumps(self.director.export_production(export_name), indent=4))
+            return
+
+        production = Production.from_iris(export_name, director=self.director)
+        if export_format == "python":
+            print(production.to_python(), end="")
+            return
+        if export_format == "graph":
+            print(production.graph())
+            return
+        raise ValueError(f"Unsupported export format: {export_format}")
 
     def _handle_migrate(self) -> None:
         migrate_path = self.args.migrate
         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(
+                    migration_utils.explain_migration(
+                        migrate_path, mode=mode, namespace=self.director.namespace
+                    )
+                )
+                return
+            if self._is_remote:
+                print(
+                    migration_utils.explain_migration(
+                        migrate_path, mode=mode, namespace=self.director.namespace
+                    )
+                )
             self.director.migrate(migrate_path)
+            if self._is_remote:
+                print(
+                    migration_utils.format_migration_success(
+                        migrate_path, namespace=self.director.namespace
+                    )
+                )
 
     def _handle_log(self) -> None:
         if self.args.log == "not_set":
@@ -260,10 +268,43 @@ class Command:
         elif self.args.log is not None:
             self.director.log_production_top(int(self.args.log))
 
+    def _handle_queue(self) -> None:
+        production_name = (
+            self.director.get_default_production()
+            if self.args.queue == "not_set"
+            else self.args.queue
+        )
+        if not production_name or production_name == "Not defined":
+            print(
+                "Error: no production name provided and no default production is defined.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        print(
+            json.dumps(
+                self.director.export_production_queue_info(production_name),
+                indent=4,
+            )
+        )
+
     def _handle_init(self) -> None:
         path = None if self.args.init == "not_set" else self.args.init
         self.director.setup(path)
 
+    def _handle_bindings(self) -> None:
+        print(
+            json.dumps(
+                self.director.list_bindings(unused_only=self.args.unused),
+                indent=4,
+            )
+        )
+
+    def _handle_unbind(self) -> None:
+        if not self.args.unbind:
+            raise ValueError("IRIS class name is required.")
+        self.director.unbind_component(self.args.unbind)
+        print(f"Removed binding {self.args.unbind}.")
+
     def _handle_help(self) -> None:
         create_parser().print_help()
         if self._is_remote:
@@ -275,154 +316,6 @@ class Command:
             logging.warning("Could not retrieve default production.")
 
 
-def _format_test_response(response) -> str:
-    """Pretty-print any test_component() return value.
-
-    Handles three cases:
-    - dict  : remote response with ``classname`` / ``body`` keys
-    - str   : local response in ``"ClassName : {json}"`` format
-    - other : Python dataclass / object returned by the local director
-    """
-    if isinstance(response, dict):
-        parts = []
-        if response.get("error"):
-            return f"Error: {response['error']}"
-        if response.get("classname"):
-            parts.append(f"classname: {response['classname']}")
-        body = response.get("body", "")
-        if body:
-            try:
-                parsed = json.loads(body)
-                parts.append("body:\n" + json.dumps(parsed, indent=4))
-            except (json.JSONDecodeError, TypeError):
-                parts.append(f"body: {body}")
-        if response.get("truncated"):
-            parts.append("(response body was truncated)")
-        return "\n".join(parts) if parts else str(response)
-
-    if isinstance(response, str):
-        # Try to detect the "ClassName : {json_body}" pattern from local mode
-        if " : " in response:
-            classname_part, _, body_part = response.partition(" : ")
-            try:
-                parsed = json.loads(body_part)
-                return (
-                    f"classname: {classname_part.strip()}\n"
-                    f"body:\n{json.dumps(parsed, indent=4)}"
-                )
-            except (json.JSONDecodeError, TypeError):
-                pass
-        # Plain string — try JSON pretty-print
-        try:
-            return json.dumps(json.loads(response), indent=4)
-        except (json.JSONDecodeError, TypeError):
-            return response
-
-    # Python dataclass / arbitrary object
-    try:
-        import dataclasses
-
-        if dataclasses.is_dataclass(response):
-            return json.dumps(dataclasses.asdict(response), indent=4)
-    except Exception:
-        pass
-    return str(response)
-
-
-def create_parser() -> argparse.ArgumentParser:
-    """Create and configure argument parser"""
-    main_parser = argparse.ArgumentParser(
-        epilog=(
-            "Remote mode: set IOP_URL (e.g. http://localhost:8080) to run all commands\n"
-            "against a remote IRIS instance via its REST API. Optional env vars:\n"
-            "  IOP_USERNAME, IOP_PASSWORD, IOP_NAMESPACE (default: USER),\n"
-            "  IOP_VERIFY_SSL (set to 0 to disable TLS verification).\n"
-            "Alternatively use -R /path/to/settings.py or set IOP_SETTINGS=\n"
-            "(file must contain a REMOTE_SETTINGS dict with at least 'url').\n"
-            "Use --force-local to suppress remote mode entirely."
-        ),
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser = main_parser.add_mutually_exclusive_group()
-
-    # Main commands
-    parser.add_argument(
-        "-d", "--default", help="set the default production", nargs="?", const="not_set"
-    )
-    parser.add_argument("-l", "--list", help="list productions", action="store_true")
-    parser.add_argument(
-        "-s", "--start", help="start a production", nargs="?", const="not_set"
-    )
-    parser.add_argument("-S", "--stop", help="stop a production", action="store_true")
-    parser.add_argument("-k", "--kill", help="kill a production", action="store_true")
-    parser.add_argument(
-        "-r", "--restart", help="restart a production", action="store_true"
-    )
-    parser.add_argument(
-        "-x", "--status", help="status a production", action="store_true"
-    )
-    parser.add_argument(
-        "-m",
-        "-M",
-        "--migrate",
-        help="migrate production and classes with settings file",
-    )
-    parser.add_argument(
-        "-e", "--export", help="export a production", nargs="?", const="not_set"
-    )
-    parser.add_argument("-v", "--version", help="display version", action="store_true")
-    parser.add_argument("-L", "--log", help="display log", nargs="?", const="not_set")
-    parser.add_argument(
-        "-i", "--init", help="init the pex module in iris", nargs="?", const="not_set"
-    )
-    parser.add_argument(
-        "-t", "--test", help="test the pex module in iris", nargs="?", const="not_set"
-    )
-    parser.add_argument(
-        "-u", "--update", help="update a production", action="store_true"
-    )
-
-    # Command groups
-    start = main_parser.add_argument_group("start arguments")
-    start.add_argument(
-        "-D", "--detach", help="start a production in detach mode", action="store_true"
-    )
-
-    test = main_parser.add_argument_group("test arguments")
-    test.add_argument(
-        "-C", "--classname", help="test classname", nargs="?", const="not_set"
-    )
-    test.add_argument(
-        "-B",
-        "--body",
-        help="test body (JSON string or @path/to/file.json)",
-        nargs="?",
-        const="not_set",
-    )
-
-    migrate = main_parser.add_argument_group("migrate arguments")
-    migrate.add_argument(
-        "--force-local",
-        help="force local mode, skip remote even if REMOTE_SETTINGS or IOP_URL is present",
-        action="store_true",
-    )
-
-    remote = main_parser.add_argument_group("remote arguments")
-    remote.add_argument(
-        "-R",
-        "--remote-settings",
-        help="path to a settings.py containing REMOTE_SETTINGS (overrides IOP_SETTINGS env var)",
-        metavar="FILE",
-    )
-
-    namespace = main_parser.add_argument_group("namespace arguments")
-    namespace.add_argument(
-        "-n", "--namespace", help="set namespace", nargs="?", const="not_set"
-    )
-
-    return main_parser
-
-
 def main(argv=None) -> None:
     parser = create_parser()
     args = parser.parse_args(argv)
@@ -443,7 +336,7 @@ def main(argv=None) -> None:
     except requests.exceptions.HTTPError as exc:
         print(f"Error: {exc}", file=sys.stderr)
         sys.exit(1)
-    except RuntimeError as exc:
+    except (RuntimeError, ValueError) as exc:
         print(f"Error: {exc}", file=sys.stderr)
         sys.exit(1)
     sys.exit(0)