iris-pex-embedded-python 4.0.0b7__tar.gz → 4.0.0b9__tar.gz

{iris_pex_embedded_python-4.0.0b7/src/iris_pex_embedded_python.egg-info → iris_pex_embedded_python-4.0.0b9}/PKG-INFO

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

{iris_pex_embedded_python-4.0.0b7 → iris_pex_embedded_python-4.0.0b9}/pyproject.toml

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

{iris_pex_embedded_python-4.0.0b7 → iris_pex_embedded_python-4.0.0b9}/src/iop/__init__.py

@@ -32,9 +32,13 @@ from iop.production import OperationItem as OperationItem
 from iop.production import Port as Port
 from iop.production import ProcessItem as ProcessItem
 from iop.production import Production as Production
+from iop.production import ProductionApplyResult as ProductionApplyResult
+from iop.production import ProductionChangePlan as ProductionChangePlan
 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 ProductionPlanOperation as ProductionPlanOperation
+from iop.production import ProductionVerifyResult as ProductionVerifyResult
 from iop.production import ProductionValidationError as ProductionValidationError
 from iop.production import ProductionValidationIssue as ProductionValidationIssue
 from iop.production import ProductionValidationReport as ProductionValidationReport
@@ -70,9 +74,13 @@ __all__ = [
     "Port",
     "ProcessItem",
     "Production",
+    "ProductionApplyResult",
+    "ProductionChangePlan",
     "ProductionDiff",
     "ProductionDiffEntry",
     "ProductionGraph",
+    "ProductionPlanOperation",
+    "ProductionVerifyResult",
     "ProductionValidationError",
     "ProductionValidationIssue",
     "ProductionValidationReport",

{iris_pex_embedded_python-4.0.0b7 → iris_pex_embedded_python-4.0.0b9}/src/iop/cli/main.py

@@ -9,7 +9,7 @@ from importlib.metadata import version
 import requests
 
 from ..migration import utils as migration_utils
-from ..production import Production
+from ..production import Production, ProductionChangePlan
 from ..runtime.local import _LocalDirector
 from ..runtime.protocol import DirectorProtocol
 from ..runtime.remote import _RemoteDirector, get_remote_settings
@@ -78,6 +78,11 @@ class Command:
                 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,
             ]
         )
 
@@ -109,6 +114,11 @@ class Command:
             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:
@@ -149,6 +159,16 @@ class Command:
             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:
@@ -324,6 +344,55 @@ class Command:
         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:
@@ -334,6 +403,73 @@ class Command:
         except Exception:
             logging.warning("Could not retrieve default production.")
 
+    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:
+            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})."
+    )
+
 
 def main(argv=None) -> None:
     parser = create_parser()

{iris_pex_embedded_python-4.0.0b7 → iris_pex_embedded_python-4.0.0b9}/src/iop/cli/parser.py

@@ -64,6 +64,17 @@ def create_parser() -> argparse.ArgumentParser:
         "-t", "--test", help="test the iop module in iris", nargs="?", const="not_set"
     )
     parser.add_argument("-u", "--update", help="update a production", action="store_true")
+    parser.add_argument(
+        "--plan",
+        help="build a conservative production change plan from a Python settings file",
+    )
+    parser.add_argument("--review-plan", help="print a saved production change plan")
+    parser.add_argument("--apply-plan", help="apply a saved production change plan")
+    parser.add_argument("--verify-plan", help="verify a saved production change plan")
+    parser.add_argument(
+        "--rollback-backup",
+        help="restore a production from a plan/apply backup directory",
+    )
 
     start = main_parser.add_argument_group("start arguments")
     start.add_argument(
@@ -117,6 +128,27 @@ def create_parser() -> argparse.ArgumentParser:
         action="store_true",
     )
 
+    plan = main_parser.add_argument_group("production plan arguments")
+    plan.add_argument(
+        "--production",
+        help="target production name for --plan, or override the plan production",
+    )
+    plan.add_argument("--out", help="write --plan JSON to this path")
+    plan.add_argument(
+        "--settings",
+        help="settings.py file containing the desired Production for --apply-plan",
+    )
+    plan.add_argument(
+        "--backup-dir",
+        default=".iop/backups",
+        help="directory for apply backup artifacts",
+    )
+    plan.add_argument(
+        "--allow-destructive",
+        help="allow destructive plan operations or rollback",
+        action="store_true",
+    )
+
     remote = main_parser.add_argument_group("remote arguments")
     remote.add_argument(
         "-R",

{iris_pex_embedded_python-4.0.0b7 → iris_pex_embedded_python-4.0.0b9}/src/iop/cli/types.py

@@ -23,6 +23,11 @@ class CommandType(Enum):
     UNBIND = auto()
     HELP = auto()
     UPDATE = auto()
+    PLAN = auto()
+    REVIEW_PLAN = auto()
+    APPLY_PLAN = auto()
+    VERIFY_PLAN = auto()
+    ROLLBACK_BACKUP = auto()
 
 
 @dataclass
@@ -56,3 +61,13 @@ class CommandArgs:
     update: bool = False
     migration_plan: bool = False
     strict_production_validation: bool = False
+    plan: str | None = None
+    production: str | None = None
+    out: str | None = None
+    review_plan: str | None = None
+    apply_plan: str | None = None
+    verify_plan: str | None = None
+    rollback_backup: str | None = None
+    settings: str | None = None
+    backup_dir: str = ".iop/backups"
+    allow_destructive: bool = False

{iris_pex_embedded_python-4.0.0b7 → iris_pex_embedded_python-4.0.0b9}/src/iop/cls/IOP/Utils.cls

@@ -878,6 +878,333 @@ ClassMethod ExportProductionQueueInfo(pProductionName As %String) As %String
 	Return result.%ToJSON()
 }
 
+/// Apply a conservative granular production change plan.
+ClassMethod ApplyProductionPlan(
+	pProductionName As %String,
+	pPlan As %String,
+	pAllowDestructive As %Boolean = 0) As %String
+{
+	Set result = {}
+	Set result.production = pProductionName
+	Set result.operations = []
+	Try {
+		Set plan = {}.%FromJSON(pPlan)
+		Set operations = plan.%Get("operations")
+		Set production = ##class(Ens.Config.Production).%OpenId(pProductionName)
+		If '$IsObject(production) {
+			Set loaded = ##class(Ens.Config.Production).LoadFromClass(pProductionName)
+			If $IsObject(loaded) {
+				Set production = loaded
+			} Else {
+				$$$ThrowStatus($$$ERROR($$$EnsErrGeneral,"Production could not be loaded: "_pProductionName))
+			}
+		}
+		If $IsObject(operations) {
+			For i=0:1:operations.%Size()-1 {
+				Set operation = operations.%Get(i)
+				Set opResult = {}
+				Set opResult.id = operation.%Get("id")
+				Set opResult."op_type" = operation.%Get("op_type")
+				Set opResult.path = operation.%Get("path")
+				Set risk = operation.%Get("risk")
+				If risk = "unsupported" {
+					Set opResult.status = "skipped"
+					Set opResult.message = $Select(operation.%Get("reason")'="":operation.%Get("reason"),1:"unsupported operation")
+				} ElseIf (risk = "destructive") && ('pAllowDestructive) {
+					Set opResult.status = "skipped"
+					Set opResult.message = "requires allow_destructive"
+				} Else {
+					Try {
+						$$$ThrowOnError(..ApplyProductionPlanOperation(production, operation))
+						Set opResult.status = "applied"
+					} Catch opEx {
+						Set opResult.status = "failed"
+						Set opResult.message = opEx.DisplayString()
+					}
+				}
+				Do result.operations.%Push(opResult)
+			}
+		}
+		$$$ThrowOnError(production.SaveToClass())
+		$$$ThrowOnError($System.OBJ.Compile(pProductionName,"k-d"))
+	} Catch ex {
+		Set result.error = ex.DisplayString()
+	}
+	Return result.%ToJSON()
+}
+
+ClassMethod ApplyProductionPlanOperation(
+	pProduction As Ens.Config.Production,
+	pOperation) As %Status [ Internal, Private ]
+{
+	Set opType = pOperation.%Get("op_type")
+	If opType = "add_item" {
+		Return ..ApplyPlanAddItem(pProduction,pOperation)
+	}
+	If opType = "delete_item" {
+		Return ..ApplyPlanDeleteItem(pProduction,pOperation.%Get("item"))
+	}
+	If opType = "set_item_field" {
+		Return ..ApplyPlanSetItemField(pProduction,pOperation)
+	}
+	If opType = "replace_item_class" {
+		Return ..ApplyPlanSetItemField(pProduction,pOperation)
+	}
+	If opType = "set_production_field" {
+		Return ..ApplyPlanSetProductionField(pProduction,pOperation)
+	}
+	If opType = "set_setting" {
+		If pOperation.%Get("target") = "Other" {
+			Return ..ReplaceOtherSettings(..FindProductionItem(pProduction,pOperation.%Get("item")),pOperation.%Get("after"))
+		}
+		Return ..SetConfigSetting(..FindProductionItem(pProduction,pOperation.%Get("item")),pOperation.%Get("target"),pOperation.%Get("setting"),pOperation.%Get("after"))
+	}
+	If opType = "remove_setting" {
+		Return ..RemoveConfigSetting(..FindProductionItem(pProduction,pOperation.%Get("item")),pOperation.%Get("target"),pOperation.%Get("setting"))
+	}
+	If opType = "set_route_setting" {
+		Return ..SetConfigSetting(..FindProductionItem(pProduction,pOperation.%Get("source_item")),"Host",pOperation.%Get("source_port"),..DynamicArrayToCSV(pOperation.%Get("after")))
+	}
+	If opType = "remove_route" {
+		Return ..RemoveConfigSetting(..FindProductionItem(pProduction,pOperation.%Get("source_item")),"Host",pOperation.%Get("source_port"))
+	}
+	Quit $$$ERROR($$$EnsErrGeneral,"Unsupported production plan operation: "_opType)
+}
+
+ClassMethod ApplyPlanAddItem(
+	pProduction As Ens.Config.Production,
+	pOperation) As %Status [ Internal, Private ]
+{
+	Set itemName = pOperation.%Get("item")
+	If itemName = "" {
+		Quit $$$ERROR($$$EnsErrGeneral,"Plan item name is required.")
+	}
+	If $IsObject(..FindProductionItem(pProduction,itemName,0)) {
+		Quit $$$ERROR($$$EnsErrGeneral,"Production item already exists: "_itemName)
+	}
+	Set data = pOperation.%Get("after")
+	Set item = ##class(Ens.Config.Item).%New()
+	Set item.Name = itemName
+	Set item.ClassName = data.%Get("class_name")
+	Set item.Category = data.%Get("category")
+	Set item.PoolSize = +data.%Get("pool_size")
+	Set item.Enabled = ..BooleanValue(data.%Get("enabled"))
+	Set item.Foreground = ..BooleanValue(data.%Get("foreground"))
+	Set item.Comment = data.%Get("comment")
+	Set item.LogTraceEvents = ..BooleanValue(data.%Get("log_trace_events"))
+	Set item.Schedule = data.%Get("schedule")
+	Set item.Production = pProduction
+	$$$ThrowOnError(..SetSettingsFromMap(item,"Host",data.%Get("host_settings")))
+	$$$ThrowOnError(..SetSettingsFromMap(item,"Adapter",data.%Get("adapter_settings")))
+	$$$ThrowOnError(..ReplaceOtherSettings(item,data.%Get("other_settings")))
+	Do pProduction.Items.Insert(item)
+	Quit $$$OK
+}
+
+ClassMethod ApplyPlanDeleteItem(
+	pProduction As Ens.Config.Production,
+	pItemName As %String) As %Status [ Internal, Private ]
+{
+	Set index = ..FindProductionItemIndex(pProduction,pItemName)
+	If index < 1 {
+		Quit $$$OK
+	}
+	Do pProduction.Items.RemoveAt(index)
+	Quit $$$OK
+}
+
+ClassMethod ApplyPlanSetItemField(
+	pProduction As Ens.Config.Production,
+	pOperation) As %Status [ Internal, Private ]
+{
+	Set item = ..FindProductionItem(pProduction,pOperation.%Get("item"))
+	Set field = pOperation.%Get("field")
+	Set value = pOperation.%Get("after")
+	If field = "class_name" {
+		Set item.ClassName = value
+	} ElseIf field = "category" {
+		Set item.Category = value
+	} ElseIf field = "pool_size" {
+		Set item.PoolSize = +value
+	} ElseIf field = "enabled" {
+		Set item.Enabled = ..BooleanValue(value)
+	} ElseIf field = "foreground" {
+		Set item.Foreground = ..BooleanValue(value)
+	} ElseIf field = "comment" {
+		Set item.Comment = value
+	} ElseIf field = "log_trace_events" {
+		Set item.LogTraceEvents = ..BooleanValue(value)
+	} ElseIf field = "schedule" {
+		Set item.Schedule = value
+	} Else {
+		Quit $$$ERROR($$$EnsErrGeneral,"Unsupported item field: "_field)
+	}
+	Quit $$$OK
+}
+
+ClassMethod ApplyPlanSetProductionField(
+	pProduction As Ens.Config.Production,
+	pOperation) As %Status [ Internal, Private ]
+{
+	Set field = pOperation.%Get("field")
+	Set value = pOperation.%Get("after")
+	If field = "testing_enabled" {
+		Set pProduction.TestingEnabled = ..BooleanValue(value)
+	} ElseIf field = "log_general_trace_events" {
+		Set pProduction.LogGeneralTraceEvents = ..BooleanValue(value)
+	} ElseIf field = "actor_pool_size" {
+		Set pProduction.ActorPoolSize = +value
+	} ElseIf field = "description" {
+		Set pProduction.Description = value
+	} Else {
+		Set settingName = ..ProductionSettingName(field)
+		If settingName = "" {
+			Quit $$$ERROR($$$EnsErrGeneral,"Unsupported production field: "_field)
+		}
+		$$$ThrowOnError(..SetConfigSetting(pProduction,"",settingName,value))
+	}
+	Quit $$$OK
+}
+
+ClassMethod ProductionSettingName(pField As %String) As %String [ Internal, Private ]
+{
+	Quit $Select(
+		pField="shutdown_timeout":"ShutdownTimeout",
+		pField="update_timeout":"UpdateTimeout",
+		pField="alert_notification_manager":"AlertNotificationManager",
+		pField="alert_notification_operation":"AlertNotificationOperation",
+		pField="alert_notification_recipients":"AlertNotificationRecipients",
+		pField="alert_action_window":"AlertActionWindow",
+		1:"")
+}
+
+ClassMethod FindProductionItem(
+	pProduction As Ens.Config.Production,
+	pItemName As %String,
+	pThrow As %Boolean = 1) [ Internal, Private ]
+{
+	Set index = ..FindProductionItemIndex(pProduction,pItemName)
+	If index > 0 {
+		Quit pProduction.Items.GetAt(index)
+	}
+	If pThrow {
+		$$$ThrowStatus($$$ERROR($$$EnsErrGeneral,"Production item does not exist: "_pItemName))
+	}
+	Quit ""
+}
+
+ClassMethod FindProductionItemIndex(
+	pProduction As Ens.Config.Production,
+	pItemName As %String) As %Integer [ Internal, Private ]
+{
+	For i=1:1:pProduction.Items.Count() {
+		Set item = pProduction.Items.GetAt(i)
+		If $IsObject(item), item.Name = pItemName {
+			Return i
+		}
+	}
+	Quit 0
+}
+
+ClassMethod SetSettingsFromMap(
+	pOwner,
+	pTarget As %String,
+	pMap) As %Status [ Internal, Private ]
+{
+	If '$IsObject(pMap) {
+		Quit $$$OK
+	}
+	Set iterator = pMap.%GetIterator()
+	While iterator.%GetNext(.key,.value) {
+		$$$ThrowOnError(..SetConfigSetting(pOwner,pTarget,key,value))
+	}
+	Quit $$$OK
+}
+
+ClassMethod SetConfigSetting(
+	pOwner,
+	pTarget As %String,
+	pName As %String,
+	pValue) As %Status [ Internal, Private ]
+{
+	Set index = ..FindConfigSettingIndex(pOwner,pTarget,pName)
+	If index > 0 {
+		Set setting = pOwner.Settings.GetAt(index)
+	} Else {
+		Set setting = ##class(Ens.Config.Setting).%New()
+		Set setting.Target = pTarget
+		Set setting.Name = pName
+		Do pOwner.Settings.Insert(setting)
+	}
+	Set setting.Value = pValue
+	Quit $$$OK
+}
+
+ClassMethod RemoveConfigSetting(
+	pOwner,
+	pTarget As %String,
+	pName As %String) As %Status [ Internal, Private ]
+{
+	Set index = ..FindConfigSettingIndex(pOwner,pTarget,pName)
+	If index > 0 {
+		Do pOwner.Settings.RemoveAt(index)
+	}
+	Quit $$$OK
+}
+
+ClassMethod ReplaceOtherSettings(
+	pOwner,
+	pSettings) As %Status [ Internal, Private ]
+{
+	For i=pOwner.Settings.Count():-1:1 {
+		Set setting = pOwner.Settings.GetAt(i)
+		If $IsObject(setting), setting.Target '= "Host", setting.Target '= "Adapter" {
+			Do pOwner.Settings.RemoveAt(i)
+		}
+	}
+	If '$IsObject(pSettings) {
+		Quit $$$OK
+	}
+	For i=0:1:pSettings.%Size()-1 {
+		Set data = pSettings.%Get(i)
+		Set setting = ##class(Ens.Config.Setting).%New()
+		Set setting.Target = ..DynamicGet(data,"@Target","")
+		Set setting.Name = ..DynamicGet(data,"@Name","")
+		Set setting.Value = ..DynamicGet(data,"#text","")
+		Do pOwner.Settings.Insert(setting)
+	}
+	Quit $$$OK
+}
+
+ClassMethod FindConfigSettingIndex(
+	pOwner,
+	pTarget As %String,
+	pName As %String) As %Integer [ Internal, Private ]
+{
+	For i=1:1:pOwner.Settings.Count() {
+		Set setting = pOwner.Settings.GetAt(i)
+		If $IsObject(setting), setting.Target = pTarget, setting.Name = pName {
+			Return i
+		}
+	}
+	Quit 0
+}
+
+ClassMethod DynamicArrayToCSV(pArray) As %String [ Internal, Private ]
+{
+	If '$IsObject(pArray) {
+		Quit pArray
+	}
+	Set value = ""
+	For i=0:1:pArray.%Size()-1 {
+		If value '= "" {
+			Set value = value_","
+		}
+		Set value = value_pArray.%Get(i)
+	}
+	Quit value
+}
+
 ClassMethod dispatchTestComponent(
 	pTargetName As %String,
 	pInput As Ens.Request) As Ens.Response

{iris_pex_embedded_python-4.0.0b7 → iris_pex_embedded_python-4.0.0b9}/src/iop/migration/utils.py

@@ -1009,6 +1009,27 @@ def export_production_queue_info(production_name):
     return json.loads(data)
 
 
+def apply_production_plan(plan: dict, allow_destructive: bool = False) -> dict:
+    """
+    Apply a conservative granular production change plan locally in IRIS.
+    """
+    production_name = plan.get("production") or plan.get("production_name")
+    if not production_name:
+        raise ValueError("Production plan is missing the production name.")
+    data = (
+        _iris.get_iris()
+        .cls("IOP.Utils")
+        .ApplyProductionPlan(
+            production_name,
+            json.dumps(plan),
+            1 if allow_destructive else 0,
+        )
+    )
+    if isinstance(data, dict):
+        return data
+    return json.loads(data)
+
+
 def xml_to_json(xml_string: str) -> str:
     return _xml_to_json(xml_string)
 

{iris_pex_embedded_python-4.0.0b7 → iris_pex_embedded_python-4.0.0b9}/src/iop/production/__init__.py

@@ -7,6 +7,10 @@ from .declarations import ProcessItem as ProcessItem
 from .declarations import Route as Route
 from .declarations import ServiceItem as ServiceItem
 from .model import Production as Production
+from .planning import ProductionApplyResult as ProductionApplyResult
+from .planning import ProductionChangePlan as ProductionChangePlan
+from .planning import ProductionPlanOperation as ProductionPlanOperation
+from .planning import ProductionVerifyResult as ProductionVerifyResult
 from .runtime import resolve_target as resolve_target
 from .types import GraphEdge as GraphEdge
 from .types import GraphNode as GraphNode
@@ -32,9 +36,13 @@ __all__ = [
     "Port",
     "ProcessItem",
     "Production",
+    "ProductionApplyResult",
+    "ProductionChangePlan",
     "ProductionDiff",
     "ProductionDiffEntry",
     "ProductionGraph",
+    "ProductionPlanOperation",
+    "ProductionVerifyResult",
     "ProductionValidationError",
     "ProductionValidationIssue",
     "ProductionValidationReport",