iris-pex-embedded-python 3.5.6b10__tar.gz → 3.5.6b11__tar.gz

{iris_pex_embedded_python-3.5.6b10/src/iris_pex_embedded_python.egg-info → iris_pex_embedded_python-3.5.6b11}/PKG-INFO

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

{iris_pex_embedded_python-3.5.6b10 → iris_pex_embedded_python-3.5.6b11}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.5.6b10"
+version = "3.5.6b11"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [

{iris_pex_embedded_python-3.5.6b10 → iris_pex_embedded_python-3.5.6b11}/src/iop/_cli.py

@@ -11,7 +11,7 @@ from importlib.metadata import version
 
 from ._local import _LocalDirector
 from ._remote import _RemoteDirector, get_remote_settings
-from ._utils import _Utils
+from ._director_protocol import DirectorProtocol
 
 
 class CommandType(Enum):
@@ -67,7 +67,7 @@ class Command:
         # 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.director: DirectorProtocol = _LocalDirector()
             self._is_remote = False
         else:
             # Resolve absolute paths for --remote-settings and -m so
@@ -166,7 +166,13 @@ class Command:
         print(json.dumps(dikt, indent=4))
 
     def _handle_start(self) -> None:
-        production_name = self.args.start if self.args.start != 'not_set' else self.director.get_default_production()
+        if self.args.start != 'not_set':
+            production_name = self.args.start
+        else:
+            production_name = self.director.get_default_production()
+            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)
         if self.args.detach:
             self.director.start_production(production_name)
             print(f"Production {production_name} started")
@@ -219,7 +225,7 @@ class Command:
         if migrate_path is not None:
             if not os.path.isabs(migrate_path):
                 migrate_path = os.path.join(os.getcwd(), migrate_path)
-            _Utils.migrate_remote(migrate_path, force_local=self.args.force_local)
+            self.director.migrate(migrate_path)
 
     def _handle_log(self) -> None:
         if self.args.log == 'not_set':
@@ -228,10 +234,8 @@ class Command:
             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)
+        path = None if self.args.init == 'not_set' else self.args.init
+        self.director.setup(path)
 
     def _handle_help(self) -> None:
         create_parser().print_help()
@@ -239,9 +243,7 @@ class Command:
             print(f"\nMode: REMOTE ({os.environ.get('IOP_URL', 'via IOP_SETTINGS')})")
         try:
             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}")
+            print(f"\nNamespace: {self.director.namespace}")
         except Exception:
             logging.warning("Could not retrieve default production.")
 
@@ -350,12 +352,25 @@ def create_parser() -> argparse.ArgumentParser:
     return main_parser
 
 def main(argv=None) -> None:
+    import requests as _requests
     parser = create_parser()
     args = parser.parse_args(argv)
     cmd_args = CommandArgs(**vars(args))
-    
-    command = Command(cmd_args)
-    command.execute()
+
+    try:
+        command = Command(cmd_args)
+        command.execute()
+    except _requests.exceptions.ConnectionError as exc:
+        url = os.environ.get("IOP_URL", "")
+        msg = f"Connection error: could not reach {url!r}" if url else f"Connection error: {exc}"
+        print(f"Error: {msg}", file=sys.stderr)
+        sys.exit(1)
+    except _requests.exceptions.HTTPError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except RuntimeError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
     sys.exit(0)
 
 if __name__ == '__main__':

iris_pex_embedded_python-3.5.6b11/src/iop/_director_protocol.py

@@ -0,0 +1,75 @@
+"""Structural interface shared by _LocalDirector and _RemoteDirector.
+
+Use ``DirectorProtocol`` for type annotations instead of the concrete union
+``_LocalDirector | _RemoteDirector``.  Any object that implements all the
+methods below will satisfy the protocol at type-check time (no inheritance
+required).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class DirectorProtocol(Protocol):
+    """Interface that both _LocalDirector and _RemoteDirector must satisfy."""
+
+    # ------------------------------------------------------------------
+    # Production lifecycle
+    # ------------------------------------------------------------------
+
+    def get_default_production(self) -> str: ...
+    def set_default_production(self, production_name: str = "") -> None: ...
+    def list_productions(self) -> dict: ...
+    def status_production(self) -> dict: ...
+    def start_production(self, production_name: Optional[str] = None) -> None: ...
+    def start_production_with_log(self, production_name: Optional[str] = None) -> None: ...
+    def stop_production(self) -> None: ...
+    def shutdown_production(self) -> None: ...
+    def restart_production(self) -> None: ...
+    def update_production(self) -> None: ...
+
+    # ------------------------------------------------------------------
+    # Logging
+    # ------------------------------------------------------------------
+
+    def log_production_top(self, top: int = 10) -> None: ...
+    def log_production(self) -> None: ...
+
+    # ------------------------------------------------------------------
+    # Test
+    # ------------------------------------------------------------------
+
+    def test_component(
+        self,
+        target: Optional[str],
+        message=None,
+        classname: Optional[str] = None,
+        body: "str | dict | None" = None,
+    ) -> Any: ...
+
+    # ------------------------------------------------------------------
+    # Export
+    # ------------------------------------------------------------------
+
+    def export_production(self, production_name: str) -> dict: ...
+
+    # ------------------------------------------------------------------
+    # Init / setup
+    # ------------------------------------------------------------------
+
+    def setup(self, path: Optional[str] = None) -> None: ...
+
+    # ------------------------------------------------------------------
+    # Migrate
+    # ------------------------------------------------------------------
+
+    def migrate(self, path: str) -> None: ...
+
+    # ------------------------------------------------------------------
+    # Metadata
+    # ------------------------------------------------------------------
+
+    @property
+    def namespace(self) -> str: ...

{iris_pex_embedded_python-3.5.6b10 → iris_pex_embedded_python-3.5.6b11}/src/iop/_local.py

@@ -6,13 +6,17 @@ _LocalDirector and _RemoteDirector without any branching.
 
 from __future__ import annotations
 
+import json
+import os
 from typing import Optional
 
 from ._director import _Director
 from ._utils import _Utils
+from ._director_protocol import DirectorProtocol as _DirectorProtocol  # noqa: F401 --- IGNORE ---
 
 
-class _LocalDirector:
+class _LocalDirector(_DirectorProtocol):
+    """Local director: thin instance-method wrapper around static _Director calls."""
 
     # ------------------------------------------------------------------
     # Production lifecycle
@@ -67,7 +71,8 @@ class _LocalDirector:
         target: Optional[str],
         message=None,
         classname: Optional[str] = None,
-        body: Optional[str] = None,
+        body: "str | dict | None" = None,
+        restart: bool = True,  # ignored locally — included to satisfy DirectorProtocol
     ):
         return _Director.test_component(target, message, classname, body)
 
@@ -76,4 +81,26 @@ class _LocalDirector:
     # ------------------------------------------------------------------
 
     def export_production(self, production_name: str) -> dict:
-        return _Utils.export_production(production_name)
+        return json.loads(_Utils.export_production(production_name))
+
+    # ------------------------------------------------------------------
+    # Init / setup
+    # ------------------------------------------------------------------
+
+    def setup(self, path: Optional[str] = None) -> None:
+        _Utils.setup(path)
+
+    # ------------------------------------------------------------------
+    # Migrate
+    # ------------------------------------------------------------------
+
+    def migrate(self, path: str) -> None:
+        _Utils.migrate(path)
+
+    # ------------------------------------------------------------------
+    # Metadata
+    # ------------------------------------------------------------------
+
+    @property
+    def namespace(self) -> str:
+        return os.getenv('IRISNAMESPACE', 'not set')

{iris_pex_embedded_python-3.5.6b10 → iris_pex_embedded_python-3.5.6b11}/src/iop/_remote.py

@@ -16,17 +16,19 @@ import json
 import os
 import signal
 import time
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 import requests
 import urllib3
 
+from ._director_protocol import DirectorProtocol as _DirectorProtocol  # noqa: F401 --- IGNORE ---
 
-class _RemoteDirector:
-    """Implements the same interface as _Director but dispatches over HTTP."""
+class _RemoteDirector(_DirectorProtocol):
+    """Implements DirectorProtocol over the IOP REST API."""
 
     def __init__(self, remote_settings: Dict[str, Any]) -> None:
-        self._base = remote_settings["url"].rstrip("/") + "/api/iop"
+        self._url = remote_settings["url"].rstrip("/")
+        self._base = self._url + "/api/iop"
         self._auth = (
             remote_settings.get("username", ""),
             remote_settings.get("password", ""),
@@ -40,13 +42,27 @@ class _RemoteDirector:
     # Internal helpers
     # ------------------------------------------------------------------
 
+    @staticmethod
+    def _raise_for_status(resp: requests.Response) -> None:
+        """Like resp.raise_for_status() but includes the response body error message."""
+        if not resp.ok:
+            try:
+                body = resp.json()
+                error = body.get("error") or body.get("message") or resp.text
+            except Exception:
+                error = resp.text or resp.reason
+            raise requests.exceptions.HTTPError(
+                f"{resp.status_code} {resp.reason}: {error}",
+                response=resp,
+            )
+
     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()
+        self._raise_for_status(resp)
         return resp.json()
 
     def _post(self, path: str, body: Optional[dict] = None) -> Any:
@@ -55,7 +71,7 @@ class _RemoteDirector:
             params={"namespace": self._namespace},
             auth=self._auth, verify=self._verify, timeout=30,
         )
-        resp.raise_for_status()
+        self._raise_for_status(resp)
         return resp.json()
 
     def _put(self, path: str, body: Optional[dict] = None) -> Any:
@@ -64,7 +80,7 @@ class _RemoteDirector:
             params={"namespace": self._namespace},
             auth=self._auth, verify=self._verify, timeout=30,
         )
-        resp.raise_for_status()
+        self._raise_for_status(resp)
         return resp.json()
 
     def _check_error(self, data: Any) -> Any:
@@ -131,11 +147,11 @@ class _RemoteDirector:
     def shutdown_production(self) -> None:
         self._check_error(self._post("/kill"))
 
-    def restart_production(self) -> dict:
-        return self._check_error(self._post("/restart"))
+    def restart_production(self) -> None:
+        self._check_error(self._post("/restart"))
 
-    def update_production(self) -> dict:
-        return self._check_error(self._post("/update"))
+    def update_production(self) -> None:
+        self._check_error(self._post("/update"))
 
     # ------------------------------------------------------------------
     # Logging
@@ -190,7 +206,7 @@ class _RemoteDirector:
         target: Optional[str],
         message=None,           # ignored remotely — not serialisable over HTTP
         classname: Optional[str] = None,
-        body: Optional[Union[str, dict]] = None,
+        body: "str | dict | None" = None,
         restart: bool = True,
     ) -> dict:
         """Returns a dict: {"classname": "...", "body": "...", "truncated": false}.
@@ -223,6 +239,156 @@ class _RemoteDirector:
             self._get("/export", {"production": production_name})
         )
 
+    # ------------------------------------------------------------------
+    # Migrate
+    # ------------------------------------------------------------------
+
+    def migrate(self, path: str) -> None:
+        """Upload .py and .cls files from *path*'s folder to remote IRIS via the IOP migrate API.
+
+        *path* must be an absolute path to a ``settings.py`` file whose directory
+        (and sub-directories) will be walked for ``.py`` / ``.cls`` files.
+        ``REMOTE_SETTINGS`` fields (package, namespace, remote_folder) are read
+        from that same settings file when present; otherwise the director's own
+        namespace / defaults are used.
+        """
+        import importlib.util
+
+        folder = os.path.dirname(path)
+
+        # Try to read optional keys from the settings file
+        package = 'python'
+        remote_folder = ''
+        try:
+            spec = importlib.util.spec_from_file_location('_iop_migrate_settings', path)
+            mod = importlib.util.module_from_spec(spec)  # type: ignore[arg-type]
+            spec.loader.exec_module(mod)  # type: ignore[union-attr]
+            rs = getattr(mod, 'REMOTE_SETTINGS', {})
+            package = rs.get('package', package)
+            remote_folder = rs.get('remote_folder', remote_folder)
+        except Exception:
+            pass
+
+        body: List[dict] = []
+        for dirpath, _, filenames in os.walk(folder):
+            for fname in sorted(filenames):
+                if not (fname.endswith('.py') or fname.endswith('.cls')):
+                    continue
+                full = os.path.join(dirpath, fname)
+                rel = os.path.relpath(full, folder).replace(os.sep, '/')
+                with open(full, encoding='utf-8') as fh:
+                    body.append({'name': rel, 'data': fh.read()})
+
+        payload = {
+            'namespace': self._namespace,
+            'package': package,
+            'remote_folder': remote_folder,
+            'body': body,
+        }
+        resp = requests.put(
+            f"{self._base}/migrate",
+            json=payload,
+            params={"namespace": self._namespace},
+            auth=self._auth,
+            verify=self._verify,
+            timeout=30,
+        )
+        self._raise_for_status(resp)
+        # Server returns $$$OK (the integer 1) on success — not meaningful to print
+
+    # ------------------------------------------------------------------
+    # Init / setup — uploads .cls files via the Atelier API
+    # ------------------------------------------------------------------
+
+    def setup(self, path: Optional[str] = None) -> None:
+        """Upload and compile IOP .cls files to remote IRIS via the Atelier REST API.
+
+        When *path* is ``None`` the bundled ``iop/cls/`` directory (and the
+        optional ``grongier/cls/`` directory for retrocompatibility) is used.
+        Any explicit *path* must point to a directory containing ``.cls`` files.
+        """
+        import importlib.resources
+
+        paths_to_upload: List[str] = []
+        if path is None:
+            try:
+                paths_to_upload.append(
+                    str(importlib.resources.files('iop').joinpath('cls'))
+                )
+            except ModuleNotFoundError:
+                pass
+            try:  # retrocompatibility with the grongier.pex package
+                paths_to_upload.append(
+                    str(importlib.resources.files('grongier').joinpath('cls'))
+                )
+            except ModuleNotFoundError:
+                pass
+        else:
+            paths_to_upload.append(path)
+
+        atelier_base = f"{self._url}/api/atelier/v1"
+        doc_names: List[str] = []
+
+        for cls_root in paths_to_upload:
+            for dirpath, _, filenames in os.walk(cls_root):
+                for fname in sorted(filenames):
+                    if not fname.endswith('.cls'):
+                        continue
+                    full_path = os.path.join(dirpath, fname)
+                    doc_name = os.path.relpath(full_path, cls_root).replace(os.sep, '/')
+                    with open(full_path, encoding='utf-8') as fh:
+                        content = fh.read().splitlines()
+                    resp = requests.put(
+                        f"{atelier_base}/{self._namespace}/doc/{doc_name}",
+                        json={"enc": False, "content": content},
+                        params={"ignoreConflict": "1"},
+                        auth=self._auth,
+                        verify=self._verify,
+                        timeout=30,
+                    )
+                    self._raise_for_status(resp)
+                    result = resp.json()
+                    doc_status = (result.get('result') or {}).get('status') or ''
+                    if doc_status:
+                        raise RuntimeError(f"Error uploading {doc_name}: {doc_status}")
+                    doc_names.append(doc_name)
+                    print(f"Uploaded: {doc_name}")
+
+        if not doc_names:
+            raise RuntimeError("No .cls files found to upload.")
+
+        # Compile all uploaded documents in one request
+        resp = requests.post(
+            f"{atelier_base}/{self._namespace}/action/compile",
+            json=doc_names,
+            params={"flags": "cuk"},
+            auth=self._auth,
+            verify=self._verify,
+            timeout=120,
+        )
+        self._raise_for_status(resp)
+        result = resp.json()
+        for line in result.get('console', []):
+            if line:
+                print(line)
+        errors = result.get('status', {}).get('errors', [])
+        if errors:
+            raise RuntimeError(f"Compilation errors: {errors}")
+        print(
+            "\n.cls files uploaded and compiled successfully."
+            "\nNext step: ensure the 'iop' Python package is installed on the IRIS server:"
+            "\n  python3 -m pip install iris-pex-embedded-python"
+            "\nThis is required for full IOP Support; without it, only the migrate() and export_production() methods will work remotely."
+        )
+
+    # ------------------------------------------------------------------
+    # Metadata
+    # ------------------------------------------------------------------
+
+    @property
+    def namespace(self) -> str:
+        return self._namespace
+
 
 # ------------------------------------------------------------------
 # Shared helpers

{iris_pex_embedded_python-3.5.6b10 → iris_pex_embedded_python-3.5.6b11}/src/iop/_utils.py

@@ -6,25 +6,14 @@ import importlib.resources
 import json
 import inspect
 import ast
-from typing import Any, Dict, Optional, Union, Tuple, TypedDict
+from typing import Any, Dict, Optional, Tuple
 
 import xmltodict
-import requests
 from pydantic import TypeAdapter
 
 from . import _iris
 from ._message import _Message, _PydanticMessage
 
-class RemoteSettings(TypedDict, total=False):
-    """Typed dictionary for remote migration settings."""
-    url: str  # Required: the host url to connect to
-    namespace: str  # Optional: the namespace to use (default: 'USER')
-    package: str  # Optional: the package to use (default: 'python')
-    remote_folder: str  # Optional: the folder to use (default: '')
-    username: str  # Optional: the username to use to connect (default: '')
-    password: str  # Optional: the password to use to connect (default: '')
-    verify_ssl: bool  # Optional: verify SSL certificates (default: True, set to False for self-signed certs)
-
 class _Utils():
     @staticmethod
     def raise_on_error(sc):
@@ -265,102 +254,6 @@ class _Utils():
 
         return module
 
-    @staticmethod
-    def migrate_remote(filename=None, force_local=False):
-        """
-        Read a settings file from the filename
-        If the settings.py file has a key 'REMOTE_SETTINGS' then it will use the value of that key
-        as the remote host to connect to.
-        the REMOTE_SETTINGS is a RemoteSettings dictionary with the following keys:
-            * 'url': the host url to connect to (mandatory)
-            * 'namespace': the namespace to use (optional, default is 'USER')
-            * 'package': the package to use (optional, default is 'python')
-            * 'remote_folder': the folder to use (optional, default is '')
-            * 'username': the username to use to connect (optional, default is '')
-            * 'password': the password to use to connect (optional, default is '')
-            * 'verify_ssl': verify SSL certificates (optional, default is True)
-        
-        The remote host is a rest API that will be used to register the components
-        The payload will be a json object with the following keys:
-            * 'namespace': the namespace to use
-            * 'package': the package to use
-            * 'body': the body of the request, it will be a json object with the following keys:
-                * 'name': name of the file
-                * 'data': the data of the file, it will be an UTF-8 encoded string
-
-        'body' will be constructed with all the files in the folder if the folder is not empty else use root folder of settings.py
-        
-        Args:
-            filename: Path to the settings file
-            force_local: If True, skip remote migration even if REMOTE_SETTINGS is present
-        """
-        settings, path = _Utils._load_settings(filename)
-        remote_settings: Optional[RemoteSettings] = getattr(settings, 'REMOTE_SETTINGS', None) if settings else None
-
-        if not remote_settings or force_local:
-            _Utils.migrate(filename)
-            return
-        
-        # Validate required fields
-        if 'url' not in remote_settings:
-            raise ValueError("REMOTE_SETTINGS must contain 'url' field")
-        
-        # prepare the payload with defaults
-        payload = {
-            'namespace': remote_settings.get('namespace', 'USER'),
-            'package': remote_settings.get('package', 'python'),
-            'remote_folder': remote_settings.get('remote_folder', ''),
-            'body': []
-        }
-        
-        # get the folder to register
-        folder = _Utils._get_folder_path(filename, path)
-
-        # iterate over all files in the folder
-        for root, _, files in os.walk(folder):
-            for file in files:
-                if file.endswith('.py') or file.endswith('.cls'):
-                    file_path = os.path.join(root, file)
-                    relative_path = os.path.relpath(file_path, folder)
-                    # Normalize path separators for cross-platform compatibility
-                    relative_path = relative_path.replace(os.sep, '/')
-                    with open(file_path, 'r', encoding='utf-8') as f:
-                        data = f.read()
-                        payload['body'].append({
-                            'name': relative_path,
-                            'data': data
-                        })
-        
-        # Get SSL verification setting (default to True for security)
-        verify_ssl = remote_settings.get('verify_ssl', True)
-        
-        # Disable SSL warnings if verify_ssl is False
-        if not verify_ssl:
-            import urllib3
-            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-        
-        # send the request to the remote settings
-        try:
-            response = requests.put(
-                url=f"{remote_settings['url']}/api/iop/migrate",
-                json=payload,
-                headers={
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json'
-                },
-                auth=(remote_settings.get('username', ''), remote_settings.get('password', '')),
-                timeout=10,
-                verify=verify_ssl
-            )
-
-            print(f"Response from remote migration:\n{response.text}")
-
-            response.raise_for_status()  # Raise an error for bad responses
-        except requests.exceptions.SSLError as e:
-            print(f"SSL Error: {e}")
-            print("If you're using a self-signed certificate, set 'verify_ssl': False in REMOTE_SETTINGS")
-            raise
-
     @staticmethod
     def migrate(filename=None):
         """ 

{iris_pex_embedded_python-3.5.6b10 → iris_pex_embedded_python-3.5.6b11}/src/iop/cls/IOP/Service/Remote/Rest/v1.cls

@@ -81,6 +81,7 @@ ClassMethod PostStart() As %Status
 		Set production = dyna.%Get("production")
 		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
 		If production = "" { Set production = $Get(^Ens.Configuration("csp","LastProduction")) }
+		If production = "" { Throw $$$ERROR("NoProductionSpecified") }
 		$$$ThrowOnError(##class(Ens.Director).StartProduction(production))
 		Return ..%WriteResponse({"status": "started", "production": (production)}.%ToJSON())
 	} Catch ex {

{iris_pex_embedded_python-3.5.6b10 → iris_pex_embedded_python-3.5.6b11/src/iris_pex_embedded_python.egg-info}/PKG-INFO

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

{iris_pex_embedded_python-3.5.6b10 → iris_pex_embedded_python-3.5.6b11}/src/iris_pex_embedded_python.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ src/iop/_common.py
 src/iop/_debugpy.py
 src/iop/_decorators.py
 src/iop/_director.py
+src/iop/_director_protocol.py
 src/iop/_dispatch.py
 src/iop/_generator_request.py
 src/iop/_inbound_adapter.py