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

iop/{_cli.py → cli/main.py}

@@ -1,64 +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
-from ._utils import _Utils
-
-
-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
-    migration_plan: bool = False
+import requests
+
+from ..migration import utils as migration_utils
+from ..production import Production, ProductionChangePlan
+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:
@@ -114,12 +73,23 @@ 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,
+                self.args.plan,
+                self.args.review_plan,
+                self.args.apply_plan,
+                self.args.verify_plan,
+                self.args.rollback_backup,
             ]
         )
 
     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
@@ -138,9 +108,17 @@ 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,
+            CommandType.PLAN: self._handle_plan,
+            CommandType.REVIEW_PLAN: self._handle_review_plan,
+            CommandType.APPLY_PLAN: self._handle_apply_plan,
+            CommandType.VERIFY_PLAN: self._handle_verify_plan,
+            CommandType.ROLLBACK_BACKUP: self._handle_rollback_backup,
         }
         handler = command_handlers.get(command_type)
         if handler:
@@ -171,10 +149,26 @@ 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
+        if self.args.plan:
+            return CommandType.PLAN
+        if self.args.review_plan:
+            return CommandType.REVIEW_PLAN
+        if self.args.apply_plan:
+            return CommandType.APPLY_PLAN
+        if self.args.verify_plan:
+            return CommandType.VERIFY_PLAN
+        if self.args.rollback_backup:
+            return CommandType.ROLLBACK_BACKUP
         return CommandType.HELP
 
     def _handle_default(self) -> None:
@@ -230,13 +224,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"))
@@ -247,7 +241,25 @@ 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 == "class":
+            print(production.to_class(), end="")
+            return
+        if export_format == "graph":
+            print(production.graph())
+            return
+        if export_format == "mermaid":
+            print(production.to_mermaid(), end="")
+            return
+        raise ValueError(f"Unsupported export format: {export_format}")
 
     def _handle_migrate(self) -> None:
         migrate_path = self.args.migrate
@@ -257,21 +269,37 @@ class Command:
             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
+                    migration_utils.explain_migration(
+                        migrate_path,
+                        mode=mode,
+                        namespace=self.director.namespace,
+                        strict_production_validation=(
+                            self.args.strict_production_validation
+                        ),
                     )
                 )
                 return
             if self._is_remote:
                 print(
-                    _Utils.explain_migration(
-                        migrate_path, mode=mode, namespace=self.director.namespace
+                    migration_utils.explain_migration(
+                        migrate_path,
+                        mode=mode,
+                        namespace=self.director.namespace,
+                        strict_production_validation=(
+                            self.args.strict_production_validation
+                        ),
                     )
                 )
-            self.director.migrate(migrate_path)
+            if self.args.strict_production_validation:
+                self.director.migrate(
+                    migrate_path,
+                    strict_production_validation=True,
+                )
+            else:
+                self.director.migrate(migrate_path)
             if self._is_remote:
                 print(
-                    _Utils.format_migration_success(
+                    migration_utils.format_migration_success(
                         migrate_path, namespace=self.director.namespace
                     )
                 )
@@ -282,10 +310,92 @@ 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_plan(self) -> None:
+        production = self._load_production_from_settings(
+            self.args.plan,
+            self.args.production,
+        )
+        plan = production.plan()
+        if self.args.out:
+            plan.save(self._absolute_path(self.args.out))
+            print(f"Production change plan written to {self.args.out}")
+        else:
+            print(plan)
+
+    def _handle_review_plan(self) -> None:
+        plan = ProductionChangePlan.load(self._absolute_path(self.args.review_plan))
+        print(plan)
+
+    def _handle_apply_plan(self) -> None:
+        if not self.args.settings:
+            raise ValueError("--apply-plan requires --settings.")
+        plan = ProductionChangePlan.load(self._absolute_path(self.args.apply_plan))
+        production = self._load_production_from_settings(
+            self.args.settings,
+            self.args.production or plan.production_name,
+        )
+        result = production.apply(
+            plan,
+            allow_destructive=self.args.allow_destructive,
+            backup_dir=self.args.backup_dir,
+        )
+        print(result)
+
+    def _handle_verify_plan(self) -> None:
+        plan = ProductionChangePlan.load(self._absolute_path(self.args.verify_plan))
+        production = Production(
+            self.args.production or plan.production_name,
+            namespace=self.director.namespace,
+            director=self.director,
+        )
+        print(production.verify(plan))
+
+    def _handle_rollback_backup(self) -> None:
+        result = Production.rollback_backup(
+            self._absolute_path(self.args.rollback_backup),
+            director=self.director,
+            namespace=self.director.namespace,
+            allow_destructive=self.args.allow_destructive,
+        )
+        print(result)
+
     def _handle_help(self) -> None:
         create_parser().print_help()
         if self._is_remote:
@@ -296,161 +406,73 @@ class Command:
         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
+    def _load_production_from_settings(
+        self,
+        settings_file: str | None,
+        production_name: str | None,
+    ) -> Production:
+        if not settings_file:
+            raise ValueError("A settings.py file is required.")
+        settings_path = self._absolute_path(settings_file)
+        settings, path_added = migration_utils._load_settings(settings_path)
         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",
-    )
-    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(
-        "-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"
+            production = _select_production(
+                getattr(settings, "PRODUCTIONS", None),
+                production_name,
+                director=self.director,
+                namespace=self.director.namespace,
+            )
+            production.with_director(self.director)
+            if not production.namespace:
+                production.in_namespace(self.director.namespace)
+            return production
+        finally:
+            migration_utils._cleanup_sys_path(path_added)
+
+    @staticmethod
+    def _absolute_path(path: str | None) -> str:
+        if not path:
+            raise ValueError("Path is required.")
+        if os.path.isabs(path):
+            return path
+        return os.path.join(os.getcwd(), path)
+
+
+def _select_production(
+    productions,
+    production_name: str | None,
+    *,
+    director: DirectorProtocol,
+    namespace: str | None,
+) -> Production:
+    if not isinstance(productions, list):
+        raise ValueError("settings.py must define PRODUCTIONS as a list.")
+    candidates: list[Production] = []
+    for entry in productions:
+        if isinstance(entry, Production):
+            candidate = entry
+        elif isinstance(entry, dict):
+            candidate = Production.from_dict(
+                entry,
+                director=director,
+                namespace=namespace,
+            )
+        else:
+            continue
+        candidates.append(candidate)
+    if production_name:
+        for candidate in candidates:
+            if candidate.name == production_name:
+                return candidate
+        raise ValueError(f"Production {production_name!r} not found in settings.")
+    if len(candidates) == 1:
+        return candidates[0]
+    names = ", ".join(candidate.name for candidate in candidates) or "none"
+    raise ValueError(
+        "Production name is required when settings.py contains multiple "
+        f"productions ({names})."
     )
 
-    return main_parser
-
 
 def main(argv=None) -> None:
     parser = create_parser()
@@ -472,7 +494,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)