ctm-python-client 2.4.6__tar.gz → 2.4.8__tar.gz

{ctm_python_client-2.4.6 → ctm_python_client-2.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: ctm-python-client
-Version: 2.4.6
+Version: 2.4.8
 Summary: Python Workflows for Control-M
 Author: BMC Software
 License: BSD 3-Clause
@@ -22,6 +22,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{ctm_python_client-2.4.6 → ctm_python_client-2.4.8}/setup.py

@@ -8,7 +8,7 @@ setup(
     name="ctm-python-client",
     packages=find_packages(where="src"),
     package_dir={"": "src"},
-    version="2.4.6",
+    version="2.4.8",
     description="Python Workflows for Control-M",
     long_description=long_description,
     long_description_content_type='text/markdown',

ctm_python_client-2.4.8/src/aapi/bases.py

@@ -0,0 +1,140 @@
+import enum
+import json
+import random
+import typing
+
+import attrs
+
+from ctm_python_client.core.comm import Environment
+from ctm_python_client.core.monitoring import RunMonitor
+
+
+class AAPIJob:
+    pass
+
+
+class AAPIObject:
+    def as_aapi_dict(self, ignore_event_type=True):
+        
+        # Import inside the method to prevent circular import issues
+        from aapi.ifbase import IfCompletionStatus  
+        
+        res = {}
+
+        if '_type' in attrs.fields_dict(self.__class__):
+            is_condition_or_event = self._type.startswith(('Condition', 'Event'))
+    
+            if ignore_event_type:
+                if not is_condition_or_event:
+                    res['Type'] = self._type
+            elif self._type.startswith('Event'):
+                res['Type'] = self._type
+
+                
+        if attrs.has(self):
+            for field in attrs.fields(self.__class__):
+                value = self.__getattribute__(field.name)
+                aapi_repr = field.metadata.get("_aapi_repr_")
+
+                if value in [None, [], {}]:
+                    continue
+
+                if aapi_repr:
+                    if "_type_aapi_" in field.metadata:
+                        if "_hide_type_" in field.metadata:
+                            if "Type" in res:
+                                res.__delitem__("Type")
+                        continue
+                    if "as_aapi_dict" in dir(value):
+                        res[aapi_repr] = value.as_aapi_dict()
+                    elif isinstance(value, list):
+                        res[aapi_repr] = [
+                            (o.as_aapi_dict() if "as_aapi_dict" in dir(o) else o)
+                            for o in value
+                        ]
+                    elif isinstance(value, enum.Enum):
+                        res[aapi_repr] = value.value
+                    else:
+                        res[aapi_repr] = value
+
+                elif field.metadata.get("_abstract_aapi_container_"):
+                    for obj in value:
+                        obj_ignore_type = ignore_event_type
+                        if isinstance(self, IfCompletionStatus):
+                            obj_ignore_type = False  
+                        res[obj.object_name] = obj.as_aapi_dict(ignore_event_type=obj_ignore_type)
+
+        else:
+            res["attrsibutes_valid"] = False
+
+        return res
+
+    def dumps_aapi(self, indent=None):
+        return json.dumps(self.as_aapi_dict(), indent=indent)
+
+    def dump_aapi(self, f, indent=None):
+        return json.dump(self.as_aapi_dict(), f, indent=indent)
+
+    def as_dict(self):
+        return attrs.asdict(self)
+
+    def run_on_demand(
+        self,
+        environment: Environment,
+        skip_initial_authentication: bool = False,
+        inpath: str = f"run_on_demand{random.randint(100,999)}",
+        controlm_server: str = None,
+        run_as: str = None,
+        host: str = None,
+        application: str = None,
+        sub_application: str = None,
+        skip_login: bool = False,
+        file_path: str = None,
+        delete_afterwards: bool = True,
+        open_in_browser: str = None,
+    ) -> RunMonitor:
+        # Import circular dependency
+        from aapi import Folder
+        from ctm_python_client.core.workflow import Workflow, WorkflowDefaults
+
+        if (hasattr(self, "_type") and "Job" in self._type) or (
+            hasattr(self, "job_list")
+            and self.job_list is not None
+            and len(self.job_list) > 0
+        ):
+            try:
+                on_demand_workflow = Workflow(
+                    environment,
+                    WorkflowDefaults(
+                        controlm_server=controlm_server,
+                        run_as=run_as,
+                        host=host,
+                        application=application,
+                        sub_application=sub_application,
+                    ),
+                    skip_initial_authentication=skip_initial_authentication,
+                )
+                if isinstance(self, Folder):
+                    on_demand_workflow.add(self)
+                else:
+                    on_demand_workflow.add(self, inpath=inpath)
+
+                return on_demand_workflow.run_on_demand(
+                    skip_login=skip_login,
+                    file_path=file_path,
+                    delete_afterwards=delete_afterwards,
+                    open_in_browser=open_in_browser,
+                )
+            except Exception as e:
+                if hasattr(e, "body"):
+                    errors = [
+                        err.get("message", "") + " " + err.get("item", "")
+                        for err in json.loads(e.body)["errors"]
+                    ]
+                    raise RuntimeError(f"AAPI request failed: {', '.join(errors)}")
+                else:
+                    raise e
+            finally:
+                on_demand_workflow.clear_all()
+        else:
+            raise Exception("Run is not allowed for json without jobs")

ctm_python_client-2.4.8/src/aapi/ifbase.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import enum
+import typing
+
+import attrs
+
+from aapi import *
+
+
+@attrs.define
+class IfBase(AAPIObject):
+
+    _type: str = attrs.field(
+        init=False,
+        default="IfBase",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "IfBase"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    on_list: typing.List[On] = attrs.field(
+        kw_only=True, factory=list, metadata={"_abstract_aapi_container_": True}
+    )
+    do_list: typing.List[Do] = attrs.field(
+        kw_only=True, factory=list, metadata={"_abstract_aapi_container_": True}
+    )
+
+
+@attrs.define
+class IfBaseFolder(IfBase):
+
+    _type: str = attrs.field(
+        init=False,
+        default="IfBase:Folder",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "IfBase:Folder"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+
+
+@attrs.define
+class IfOutput(IfBaseFolder):
+
+    _type: str = attrs.field(
+        init=False,
+        default="If:Output",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "If:Output"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    code: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "Code"}
+    )
+    statement: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "Statement"}
+    )
+
+
+@attrs.define
+class IfCompletionStatus(IfBaseFolder):
+
+    _type: str = attrs.field(
+        init=False,
+        default="If:CompletionStatus",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "If:CompletionStatus"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    completion_status: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "CompletionStatus"}
+    )
+
+
+@attrs.define
+class IfNumberOfReruns(IfBaseFolder):
+
+    _type: str = attrs.field(
+        init=False,
+        default="If:NumberOfReruns",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "If:NumberOfReruns"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    number_of_reruns: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "NumberOfReruns"}
+    )
+
+
+@attrs.define
+class IfNumberOfExecutions(IfBaseFolder):
+
+    _type: str = attrs.field(
+        init=False,
+        default="If:NumberOfExecutions",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "If:NumberOfExecutions"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    number_of_executions: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "NumberOfExecutions"}
+    )
+
+
+@attrs.define
+class IfNumberOfFailures(IfBaseFolder):
+
+    _type: str = attrs.field(
+        init=False,
+        default="If:NumberOfFailures",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "If:NumberOfFailures"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    number_of_failures: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "NumberOfFailures"}
+    )
+
+
+@attrs.define
+class IfJobNotSubmitted(IfBase):
+
+    _type: str = attrs.field(
+        init=False,
+        default="If:JobNotSubmitted",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "If:JobNotSubmitted"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    job_not_submitted: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "JobNotSubmitted"}
+    )
+
+
+@attrs.define
+class IfJobOutputNotFound(IfBase):
+
+    _type: str = attrs.field(
+        init=False,
+        default="If:JobOutputNotFound",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "If:JobOutputNotFound"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    job_output_not_found: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "JobOutputNotFound"}
+    )
+
+
+@attrs.define
+class IfVariableValue(IfBase):
+
+    @attrs.define
+    class RangeVariableValue(AAPIObject):
+
+        min: str = attrs.field(
+            kw_only=True, default=None, metadata={"_aapi_repr_": "Min"}
+        )
+        max: str = attrs.field(
+            kw_only=True, default=None, metadata={"_aapi_repr_": "Max"}
+        )
+
+    class Operator(enum.Enum):
+
+        NotEqualTo = "NotEqualTo"
+        GreaterThanOrEqual = "GreaterThanOrEqual"
+        LessThanOrEqual = "LessThanOrEqual"
+        GreaterThan = "GreaterThan"
+        LessThan = "LessThan"
+        EqualTo = "EqualTo"
+        InRange = "InRange"
+        NotInRange = "NotInRange"
+        Like = "Like"
+        NotLike = "NotLike"
+        IsExactly = "IsExactly"
+        IsNotExactly = "IsNotExactly"
+        StartsWith = "StartsWith"
+        EndWith = "EndWith"
+        Contains = "Contains"
+        DoesNotContain = "DoesNotContain"
+        IsEmpty = "IsEmpty"
+        IsNotEmpty = "IsNotEmpty"
+
+    _type: str = attrs.field(
+        init=False,
+        default="If:VariableValue",
+        metadata={"_aapi_repr_": "Type", "_type_aapi_": "If:VariableValue"},
+    )
+    object_name: str = attrs.field(metadata={"_aapi_name_": True})
+    variable_name: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "VariableName"}
+    )
+    range_variable_value: RangeVariableValue = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "RangeVariableValue"}
+    )
+    variable_value: str = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "VariableValue"}
+    )
+    operator: Operator = attrs.field(
+        kw_only=True, default=None, metadata={"_aapi_repr_": "Operator"}
+    )