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

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

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

{iris_pex_embedded_python-3.5.6b1 → iris_pex_embedded_python-3.5.6b2}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.5.6b1"
+version = "3.5.6b2"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [
@@ -54,4 +54,10 @@ exclude = ["tests*"]
 "*" = ["*.cls"]
 
 [tool.pytest.ini_options]
-asyncio_default_fixture_loop_scope = "class"
+asyncio_default_fixture_loop_scope = "class"
+testpaths = ["src/tests"]
+markers = [
+    "unit: pure unit test - no IRIS instance required (all IRIS calls mocked)",
+    "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",
+]

{iris_pex_embedded_python-3.5.6b1 → iris_pex_embedded_python-3.5.6b2}/src/iop/_cli.py

@@ -6,10 +6,11 @@ import os
 from dataclasses import dataclass
 from enum import Enum, auto
 import sys
-from typing import Optional, Callable
+from typing import Optional
 from importlib.metadata import version
 
-from ._director import _Director
+from ._local import _LocalDirector
+from ._remote import _RemoteDirector, get_remote_settings
 from ._utils import _Utils
 
 
@@ -51,6 +52,7 @@ class CommandArgs:
     body: Optional[str] = None
     namespace: Optional[str] = None
     force_local: bool = False
+    remote_settings: Optional[str] = None
     update: bool = False
 
 class Command:
@@ -61,6 +63,36 @@ class Command:
             # set environment variable IRISNAMESPACE
             os.environ['IRISNAMESPACE'] = self.args.namespace
 
+        # Resolve director: remote when IOP_URL / IOP_SETTINGS env vars are set
+        # or when the -m settings.py file contains REMOTE_SETTINGS.
+        # --force-local overrides everything and always uses the local director.
+        if self.args.force_local:
+            self.director: _LocalDirector | _RemoteDirector = _LocalDirector()
+            self._is_remote = False
+        else:
+            # Resolve absolute paths for --remote-settings and -m so
+            # get_remote_settings can load them regardless of cwd.
+            explicit_path = self.args.remote_settings
+            if explicit_path and not os.path.isabs(explicit_path):
+                explicit_path = os.path.join(os.getcwd(), explicit_path)
+
+            migrate_path = self.args.migrate
+            if migrate_path and not os.path.isabs(migrate_path):
+                migrate_path = os.path.join(os.getcwd(), migrate_path)
+
+            remote_settings = get_remote_settings(
+                explicit_settings_path=explicit_path,
+                fallback_settings_path=migrate_path,
+            )
+            if remote_settings:
+                if self.args.namespace and self.args.namespace != 'not_set':
+                    remote_settings['namespace'] = self.args.namespace
+                self.director = _RemoteDirector(remote_settings)
+                self._is_remote = True
+            else:
+                self.director = _LocalDirector()
+                self._is_remote = False
+
     def _has_primary_command(self) -> bool:
         return any([
             self.args.default,
@@ -125,53 +157,62 @@ class Command:
 
     def _handle_default(self) -> None:
         if self.args.default == 'not_set':
-            print(_Director.get_default_production())
+            print(self.director.get_default_production())
         elif self.args.default is not None:
-            _Director.set_default_production(self.args.default)
+            self.director.set_default_production(self.args.default)
 
     def _handle_list(self) -> None:
-        dikt = _Director.list_productions()
+        dikt = self.director.list_productions()
         print(json.dumps(dikt, indent=4))
 
     def _handle_start(self) -> None:
-        production_name = self.args.start if self.args.start != 'not_set' else _Director.get_default_production()
+        production_name = self.args.start if self.args.start != 'not_set' else self.director.get_default_production()
         if self.args.detach:
-            _Director.start_production(production_name)
+            self.director.start_production(production_name)
             print(f"Production {production_name} started")
         else:
-            _Director.start_production_with_log(production_name)
+            self.director.start_production_with_log(production_name)
 
     def _handle_stop(self) -> None:
-        _Director.stop_production()
-        print(f"Production {_Director.get_default_production()} stopped")
+        self.director.stop_production()
+        print(f"Production {self.director.get_default_production()} stopped")
 
     def _handle_kill(self) -> None:
-        _Director.shutdown_production()
+        self.director.shutdown_production()
 
     def _handle_restart(self) -> None:
-        _Director.restart_production()
+        self.director.restart_production()
 
     def _handle_status(self) -> None:
-        print(json.dumps(_Director.status_production(), indent=4))
+        print(json.dumps(self.director.status_production(), indent=4))
 
     def _handle_update(self) -> None:
-        _Director.update_production()
+        self.director.update_production()
 
     def _handle_test(self) -> None:
         test_name = None if self.args.test == 'not_set' else self.args.test
-        response = _Director.test_component(
-            test_name,
-            classname=self.args.classname if self.args.classname != 'not_set' else None,
-            body=self.args.body if self.args.body != 'not_set' else None
+        classname = self.args.classname if self.args.classname != 'not_set' else None
+        body = self.args.body if self.args.body != 'not_set' else None
+
+        # Support @filename.json body expansion
+        if body and body.startswith('@'):
+            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:
+                body = fh.read()
+
+        response = self.director.test_component(
+            test_name, classname=classname, body=body
         )
-        print(response)
+        print(_format_test_response(response))
 
     def _handle_version(self) -> None:
         print(version('iris-pex-embedded-python'))
 
     def _handle_export(self) -> None:
-        export_name = _Director.get_default_production() if self.args.export == 'not_set' else self.args.export
-        print(json.dumps(_Utils.export_production(export_name), indent=4))
+        export_name = self.director.get_default_production() if self.args.export == 'not_set' else self.args.export
+        print(json.dumps(self.director.export_production(export_name), indent=4))
 
     def _handle_migrate(self) -> None:
         migrate_path = self.args.migrate
@@ -182,24 +223,95 @@ class Command:
 
     def _handle_log(self) -> None:
         if self.args.log == 'not_set':
-            print(_Director.log_production())
+            self.director.log_production()
         elif self.args.log is not None:
-            print(_Director.log_production_top(int(self.args.log)))
+            self.director.log_production_top(int(self.args.log))
 
     def _handle_init(self) -> None:
+        if self._is_remote:
+            logging.warning("'init' is a local-only command and cannot be run remotely.")
+            return
         _Utils.setup(None)
 
     def _handle_help(self) -> None:
         create_parser().print_help()
+        if self._is_remote:
+            print(f"\nMode: REMOTE ({os.environ.get('IOP_URL', 'via IOP_SETTINGS')})")
         try:
-            print(f"\nDefault production: {_Director.get_default_production()}")
-            print(f"\nNamespace: {os.getenv('IRISNAMESPACE','not set')}")
+            print(f"\nDefault production: {self.director.get_default_production()}")
+            ns = (self.director._namespace  # type: ignore[union-attr]
+                  if self._is_remote else os.getenv('IRISNAMESPACE', 'not set'))
+            print(f"\nNamespace: {ns}")
         except Exception:
             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()
+    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
@@ -224,10 +336,13 @@ def create_parser() -> argparse.ArgumentParser:
     
     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', 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 migration, skip remote even if REMOTE_SETTINGS is present', action='store_true')
+    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')

iris_pex_embedded_python-3.5.6b2/src/iop/_local.py

@@ -0,0 +1,79 @@
+"""Local director: thin instance-method wrapper around static _Director calls.
+
+This gives the CLI a uniform interface so it can swap between
+_LocalDirector and _RemoteDirector without any branching.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from ._director import _Director
+from ._utils import _Utils
+
+
+class _LocalDirector:
+
+    # ------------------------------------------------------------------
+    # Production lifecycle
+    # ------------------------------------------------------------------
+
+    def get_default_production(self) -> str:
+        return _Director.get_default_production()
+
+    def set_default_production(self, production_name: str = "") -> None:
+        _Director.set_default_production(production_name)
+
+    def list_productions(self) -> dict:
+        return _Director.list_productions()
+
+    def status_production(self) -> dict:
+        return _Director.status_production()
+
+    def start_production(self, production_name: Optional[str] = None) -> None:
+        _Director.start_production(production_name)
+
+    def start_production_with_log(self, production_name: Optional[str] = None) -> None:
+        _Director.start_production_with_log(production_name)
+
+    def stop_production(self) -> None:
+        _Director.stop_production()
+
+    def shutdown_production(self) -> None:
+        _Director.shutdown_production()
+
+    def restart_production(self) -> None:
+        _Director.restart_production()
+
+    def update_production(self) -> None:
+        _Director.update_production()
+
+    # ------------------------------------------------------------------
+    # Logging
+    # ------------------------------------------------------------------
+
+    def log_production_top(self, top: int = 10) -> None:
+        _Director.log_production_top(top)
+
+    def log_production(self) -> None:
+        _Director.log_production()
+
+    # ------------------------------------------------------------------
+    # Test
+    # ------------------------------------------------------------------
+
+    def test_component(
+        self,
+        target: Optional[str],
+        message=None,
+        classname: Optional[str] = None,
+        body: Optional[str] = None,
+    ):
+        return _Director.test_component(target, message, classname, body)
+
+    # ------------------------------------------------------------------
+    # Export
+    # ------------------------------------------------------------------
+
+    def export_production(self, production_name: str) -> dict:
+        return _Utils.export_production(production_name)

iris_pex_embedded_python-3.5.6b2/src/iop/_remote.py

@@ -0,0 +1,293 @@
+"""Remote director: mirrors _Director's interface over the IOP REST API.
+
+Configure via environment variables:
+    IOP_URL          Required. e.g. http://localhost:8080
+    IOP_USERNAME     Optional. Default: ""
+    IOP_PASSWORD     Optional. Default: ""
+    IOP_NAMESPACE    Optional. Default: "USER"
+    IOP_VERIFY_SSL   Optional. "0"/"false" to disable TLS verification.
+
+Or pass a RemoteSettings dict directly (same shape as REMOTE_SETTINGS in settings.py).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import signal
+import time
+from typing import Any, Dict, List, Optional
+
+import requests
+import urllib3
+
+
+class _RemoteDirector:
+    """Implements the same interface as _Director but dispatches over HTTP."""
+
+    def __init__(self, remote_settings: Dict[str, Any]) -> None:
+        self._base = remote_settings["url"].rstrip("/") + "/api/iop"
+        self._auth = (
+            remote_settings.get("username", ""),
+            remote_settings.get("password", ""),
+        )
+        self._namespace: str = remote_settings.get("namespace", "USER")
+        self._verify: bool = remote_settings.get("verify_ssl", True)
+        if not self._verify:
+            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _get(self, path: str, params: Optional[dict] = None) -> Any:
+        p = {"namespace": self._namespace, **(params or {})}
+        resp = requests.get(
+            f"{self._base}{path}", params=p, auth=self._auth,
+            verify=self._verify, timeout=30,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def _post(self, path: str, body: Optional[dict] = None) -> Any:
+        b = {"namespace": self._namespace, **(body or {})}
+        resp = requests.post(
+            f"{self._base}{path}", json=b, auth=self._auth,
+            verify=self._verify, timeout=30,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def _put(self, path: str, body: Optional[dict] = None) -> Any:
+        b = {"namespace": self._namespace, **(body or {})}
+        resp = requests.put(
+            f"{self._base}{path}", json=b, auth=self._auth,
+            verify=self._verify, timeout=30,
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def _check_error(self, data: Any) -> Any:
+        if isinstance(data, dict) and "error" in data:
+            raise RuntimeError(data["error"])
+        return data
+
+    # ------------------------------------------------------------------
+    # Production lifecycle
+    # ------------------------------------------------------------------
+
+    def get_default_production(self) -> str:
+        data = self._check_error(self._get("/default"))
+        return data.get("production") or "Not defined"
+
+    def set_default_production(self, production_name: str = "") -> None:
+        self._check_error(self._put("/default", {"production": production_name}))
+
+    def list_productions(self) -> dict:
+        return self._check_error(self._get("/list"))
+
+    def status_production(self) -> dict:
+        data = self._check_error(self._get("/status"))
+        if not data.get("production"):
+            data["production"] = self.get_default_production()
+        return data
+
+    def start_production(self, production_name: Optional[str] = None) -> None:
+        body: dict = {}
+        if production_name:
+            body["production"] = production_name
+        self._check_error(self._post("/start", body))
+
+    def start_production_with_log(self, production_name: Optional[str] = None) -> None:
+        """Start remotely then stream the log until Ctrl-C (which also stops)."""
+        self.start_production(production_name)
+        prod = production_name or self.get_default_production()
+        print(f"Production '{prod}' started. Streaming log — Ctrl-C to stop.")
+        running = True
+
+        def _sigint(sig, frame):  # pragma: no cover
+            nonlocal running
+            running = False
+
+        signal.signal(signal.SIGINT, _sigint)
+
+        last_id = 0
+        for entry in self._get_log_entries(top=10):
+            _print_log_entry(entry)
+            last_id = max(last_id, entry.get("id", 0))
+
+        while running:
+            time.sleep(1)
+            entries = self._get_log_entries(since_id=last_id)
+            for entry in entries:
+                _print_log_entry(entry)
+                last_id = max(last_id, entry.get("id", 0))
+
+        self.stop_production()
+
+    def stop_production(self) -> None:
+        self._check_error(self._post("/stop"))
+
+    def shutdown_production(self) -> None:
+        self._check_error(self._post("/kill"))
+
+    def restart_production(self) -> dict:
+        return self._check_error(self._post("/restart"))
+
+    def update_production(self) -> dict:
+        return self._check_error(self._post("/update"))
+
+    # ------------------------------------------------------------------
+    # Logging
+    # ------------------------------------------------------------------
+
+    def _get_log_entries(
+        self,
+        top: int = 10,
+        since_id: Optional[int] = None,
+    ) -> List[dict]:
+        params: dict = {}
+        if since_id is not None:
+            params["since_id"] = since_id
+        else:
+            params["top"] = top
+        data = self._check_error(self._get("/log", params))
+        return data if isinstance(data, list) else []
+
+    def log_production_top(self, top: int = 10) -> None:
+        entries = self._get_log_entries(top=top)
+        for entry in reversed(entries):
+            _print_log_entry(entry)
+
+    def log_production(self) -> None:
+        """Stream log continuously until Ctrl-C."""
+        running = True
+
+        def _sigint(sig, frame):  # pragma: no cover
+            nonlocal running
+            running = False
+
+        signal.signal(signal.SIGINT, _sigint)
+
+        last_id = 0
+        for entry in self._get_log_entries(top=10):
+            _print_log_entry(entry)
+            last_id = max(last_id, entry.get("id", 0))
+
+        while running:
+            time.sleep(1)
+            entries = self._get_log_entries(since_id=last_id)
+            for entry in entries:
+                _print_log_entry(entry)
+                last_id = max(last_id, entry.get("id", 0))
+
+    # ------------------------------------------------------------------
+    # Test
+    # ------------------------------------------------------------------
+
+    def test_component(
+        self,
+        target: Optional[str],
+        message=None,           # ignored remotely — not serialisable over HTTP
+        classname: Optional[str] = None,
+        body: Optional[str] = None,
+    ) -> dict:
+        """Returns a dict: {"classname": "...", "body": "...", "truncated": false}"""
+        payload: dict = {"target": target or ""}
+        if classname:
+            payload["classname"] = classname
+        if body:
+            payload["body"] = body
+        try:
+            return self._check_error(self._post("/test", payload))
+        except requests.exceptions.HTTPError as exc:
+            raise RuntimeError(str(exc)) from exc
+
+    # ------------------------------------------------------------------
+    # Export
+    # ------------------------------------------------------------------
+
+    def export_production(self, production_name: str) -> dict:
+        import xmltodict  # already required by _utils
+
+        data = self._check_error(
+            self._get("/export", {"production": production_name})
+        )
+        xml = data.get("xml", "")
+        if not xml:
+            return {}
+
+        def _postprocessor(path, key, value):
+            return key, "" if value is None else value
+
+        return xmltodict.parse(xml, postprocessor=_postprocessor)
+
+
+# ------------------------------------------------------------------
+# Shared helpers
+# ------------------------------------------------------------------
+
+def _print_log_entry(entry: dict) -> None:
+    print(
+        entry.get("time_logged", ""),
+        entry.get("type", ""),
+        entry.get("config_name", ""),
+        entry.get("job", ""),
+        entry.get("message_id", ""),
+        entry.get("session_id", ""),
+        entry.get("source_class", ""),
+        entry.get("source_method", ""),
+        entry.get("text", ""),
+    )
+
+
+def _load_remote_settings_from_file(settings_path: str) -> Optional[Dict[str, Any]]:
+    """Load a ``REMOTE_SETTINGS`` dict from an arbitrary settings.py file."""
+    try:
+        import importlib.util
+        spec = importlib.util.spec_from_file_location("_iop_settings_remote", settings_path)
+        mod = importlib.util.module_from_spec(spec)  # type: ignore[arg-type]
+        spec.loader.exec_module(mod)  # type: ignore[union-attr]
+        remote = getattr(mod, "REMOTE_SETTINGS", None)
+        if isinstance(remote, dict) and "url" in remote:
+            return remote
+    except Exception:
+        pass
+    return None
+
+
+def get_remote_settings(
+    explicit_settings_path: Optional[str] = None,
+    fallback_settings_path: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    """Detect remote settings from the environment or an explicit file.
+
+    Priority:
+    1. ``IOP_URL`` env var (direct inline configuration).
+    2. ``explicit_settings_path`` — the file supplied via ``--remote-settings``.
+    3. ``IOP_SETTINGS`` env var pointing to a settings.py with ``REMOTE_SETTINGS``.
+    4. ``fallback_settings_path`` — e.g. the file passed via ``-m settings.py``;
+       its ``REMOTE_SETTINGS`` dict is used when present.
+    """
+    url = os.environ.get("IOP_URL")
+    if url:
+        verify_raw = os.environ.get("IOP_VERIFY_SSL", "1")
+        return {
+            "url": url,
+            "username": os.environ.get("IOP_USERNAME", ""),
+            "password": os.environ.get("IOP_PASSWORD", ""),
+            "namespace": os.environ.get("IOP_NAMESPACE", "USER"),
+            "verify_ssl": verify_raw.lower() not in ("0", "false"),
+        }
+
+    for path in filter(None, [
+        explicit_settings_path,
+        os.environ.get("IOP_SETTINGS"),
+        fallback_settings_path,
+    ]):
+        result = _load_remote_settings_from_file(path)
+        if result:
+            return result
+
+    return None
+