js7-client-python 2.0.1__py3-none-any.whl

js7/client/client.py

@@ -0,0 +1,250 @@
+from functools import cached_property
+from pathlib import Path
+from typing import Optional, Union
+
+from .context import Context
+from ..model.configuration.http_configuration import HTTPConfiguration
+from ..model.configuration.client_configuration import ClientConfiguration
+from ..model.configuration.auth_configuration import AuthConfiguration
+
+from .feature.inventory.inventory import Inventory
+from .feature.order.order import Order
+from .feature.joc.joc import JOC
+from .feature.agent.agent import Agent
+from .feature.task.task import Task
+from .feature.workflow.workflow import Workflow
+from .feature.controller.controller import Controller
+from .feature.iam.iam import IAM
+from .feature.daily_plan.daily_plan import DailyPlan
+
+from .action.helper.encrypt_action import encrypt_action
+from .action.helper.decrypt_action import decrypt_action
+
+
+class Client:
+    """
+    The `Client` class serves as the central entry point for interacting with JS7 JOC.
+
+    Args:
+        http_config (HTTPConfiguration):
+            Configuration of the HTTP connection to the JOC endpoint
+
+        auth_config (AuthConfiguration):
+            Configuration for authentication. Supported methods include
+            basic authentication and certificate-based authentication.
+
+        client_config (ClientConfiguration):
+            Configuration of the client’s behavior.
+
+    Returns:
+        Client:
+            An instance of the `Client` class that can be used to perform operations against JS7 JOC.
+    """
+    
+    def __init__(
+        self, 
+        *, 
+        http_config: HTTPConfiguration, 
+        auth_config: AuthConfiguration, 
+        client_config: ClientConfiguration = ClientConfiguration()
+    ):
+
+        self._ctx = Context(
+            http_config=http_config,
+            auth_config=auth_config,
+            client_config=client_config
+        )
+    
+    @cached_property
+    def inventory(self) -> Inventory:
+        return Inventory(context=self._ctx)
+    
+    @cached_property
+    def order(self) -> Order:
+        return Order(context=self._ctx)
+    
+    @cached_property
+    def joc(self) -> JOC:
+        return JOC(context=self._ctx)
+    
+    @cached_property
+    def agent(self) -> Agent:
+        return Agent(context=self._ctx)
+    
+    @cached_property
+    def task(self) -> Task:
+        return Task(context=self._ctx)
+    
+    @cached_property
+    def workflow(self) -> Workflow:
+        return Workflow(context=self._ctx)
+    
+    @cached_property
+    def controller(self) -> Controller:
+        return Controller(context=self._ctx)
+    
+    @cached_property
+    def iam(self) -> IAM:
+        return IAM(context=self._ctx)
+    
+    @cached_property
+    def daily_plan(self) -> DailyPlan:
+        return DailyPlan(context=self._ctx)
+        
+    def login(self, auth_config: Optional[AuthConfiguration] = None, force_server_login: bool = False) -> str:
+        """
+        Args:
+            auth_config (Optional[AuthConfiguration]):
+                Configuration object for authentication. Supported methods are
+                basic authentication and certificate-based authentication.
+
+            force_server_login (bool):
+                If set to ``True``, any existing stored session will be ignored
+                and a new login will be performed. In this case, ``auth_config``
+                must be provided.
+
+        Returns:
+            str:
+                The access token as a string.
+                
+        Raises:
+            ValueError:
+                If the provided input data is invalid.
+
+            RuntimeError:
+                If neither certificate-based authentication nor basic authentication
+                is available in exceptional cases.
+        """
+        
+        return self._ctx.auth_provider.login(auth_config=auth_config, force_server_login=force_server_login)
+
+    def logout(self) -> bool:
+        """
+        Logs the user out from the server and clears the local session.
+
+        Returns:
+            bool:
+                `True` if the server-side logout was successful, otherwise `False`.
+                The local session is always cleared, regardless of the server response.
+        """
+        
+        return self._ctx.auth_provider.logout()
+    
+    def encrypt(
+        self,
+        java_bin_path: Union[Path, str],
+        cert_file_path: Union[Path, str],
+        in_string: Optional[str] = None,
+        in_file: Optional[Union[Path, str]] = None,
+        out_path: Optional[Union[Path, str]] = None,
+    ) -> str:
+        """
+        Encrypts data using the JS7 Java encryption utility.
+
+        This method wraps the JS7 `com.sos.commons.encryption.executable.Encrypt`
+        class and executes it via a Java subprocess.
+
+        Args:
+            java_bin_path (Union[Path, str]):
+                Path to the Java executable (e.g. `/usr/bin/java` on Linux).
+
+            cert_file_path (Union[Path, str]):
+                Path to the X.509 certificate file containing the public key
+                used for encryption.
+
+            in_string (Optional[str]):
+                Plain text string to be encrypted.
+                Either `in_string` or `in_file` must be provided, but not both.
+
+            in_file (Optional[Union[Path, str]]):
+                Path to the file to be encrypted.
+                Either `in_string` or `in_file` must be provided, but not both.
+                If `in_file` is used, `out_path` may optionally be provided to
+                write the encrypted result to a file.
+
+            out_path (Optional[Union[Path, str]]):
+                Optional output file path where the encrypted result will be written.
+                If omitted, the encrypted value is returned from stdout.
+
+        Returns:
+            str:
+                The encrypted value as a string prefixed with `"enc:"`.
+
+        Raises:
+            ValueError:
+                If input parameters are invalid (e.g. missing required arguments,
+                non-existing paths, conflicting parameters).
+
+            RuntimeError:
+                If the underlying Java encryption process fails.
+        """
+        
+        return encrypt_action(
+            java_bin_path=java_bin_path,
+            cert_file_path=cert_file_path,
+            in_string=in_string,
+            in_file=in_file,
+            out_path=out_path
+        )
+        
+    def decrypt(
+        self,
+        java_bin_path: Union[Path, str],
+        key_file_path: Union[Path, str],
+        key_password: Optional[str] = None,
+        in_string: Optional[str] = None,
+        in_file: Optional[Union[Path, str]] = None,
+        out_path: Optional[Union[Path, str]] = None,
+    ) -> str:
+        """
+        Decrypts data using the JS7 Java decryption utility.
+
+        This method wraps the JS7 `com.sos.commons.encryption.executable.Decrypt`
+        class and executes it via a Java subprocess.
+
+        Args:
+            java_bin_path (Union[Path, str]):
+                Path to the Java executable (e.g. `/usr/bin/java` on Linux).
+
+            key_file_path (Union[Path, str]):
+                Path to the private key file used for decryption.
+
+            key_password (Optional[str]):
+                Optional password for the private key, if the key is encrypted.
+
+            in_string (Optional[str]):
+                Encrypted string to be decrypted. The value may optionally include
+                the `"enc:"` prefix. Either `in_string` or `in_file` must be provided,
+                but not both.
+
+            in_file (Optional[Union[Path, str]]):
+                Path to a file containing encrypted content.
+                Either `in_string` or `in_file` must be provided, but not both.
+                If `in_file` is used, `out_path` may optionally be provided to
+                write the decrypted result to a file.
+
+            out_path (Optional[Union[Path, str]]):
+                Optional output file path where the decrypted result will be written.
+                If omitted, the decrypted value is returned from stdout.
+
+        Returns:
+            str:
+                The decrypted plain text.
+
+        Raises:
+            ValueError:
+                If input parameters are invalid (e.g. missing required arguments,
+                non-existing paths, conflicting parameters).
+
+            RuntimeError:
+                If the underlying Java decryption process fails.
+        """
+        
+        return decrypt_action(
+            java_bin_path=java_bin_path,
+            key_file_path=key_file_path,
+            key_password=key_password,
+            in_string=in_string,
+            in_file=in_file,
+            out_path=out_path
+        )

js7/client/context.py

@@ -0,0 +1,40 @@
+from ..model.configuration.auth_configuration import AuthConfiguration
+from ..model.configuration.http_configuration import HTTPConfiguration
+from ..model.configuration.client_configuration import ClientConfiguration
+from .auth.auth_provider import AuthProvider
+from ..service.http_service import HTTPService
+from ..api.joc.interface.interface import Interface as JOCInterface
+
+from ..validator.http.joc_http_status_validator import joc_http_status_validator
+
+
+class Context:
+    def __init__(self, *, http_config: HTTPConfiguration, auth_config: AuthConfiguration, client_config: ClientConfiguration):
+        # Initializes the joc api interface with auto discovery
+        self.joc_api = JOCInterface(version=None)
+        self.client_config = client_config
+             
+        self.http_service = HTTPService(
+            configuration=http_config,
+            response_validator=joc_http_status_validator
+        )
+        
+        self.auth_provider = AuthProvider(
+            http_service=self.http_service, 
+            joc_version=None, 
+        )
+        
+        # Initial login
+        self.auth_provider.login(
+            auth_config=auth_config, 
+            force_server_login=True
+        )
+        
+        # Gets the joc version
+        from .action.joc.get_version_action import get_version_action
+        joc_version = get_version_action(context=self)
+        self.version = joc_version
+        
+        # Disables auto discovery with version parameter
+        self.joc_api.set_version(self.version)
+        

js7/client/feature/agent/agent.py

@@ -0,0 +1,26 @@
+from functools import cached_property
+
+from .deploy import Deploy
+from .manage import Manage
+from .operate import Operate
+
+from ....client.context import Context
+
+
+class Agent:
+    def __init__(self, context: Context):
+        self._ctx = context
+    
+    @cached_property
+    def deploy(self) -> Deploy:
+        return Deploy(context=self._ctx)
+    
+    @cached_property
+    def manage(self) -> Manage:
+        return Manage(context=self._ctx)
+    
+    @cached_property
+    def operate(self) -> Operate:
+        return Operate(context=self._ctx)
+    
+    

js7/client/feature/agent/deploy.py

@@ -0,0 +1,134 @@
+from typing import List, Optional
+
+from ....model.public.client.common.audit_log import AuditLog
+from ....client.context import Context
+
+from ...action.agent.deploy_cluster_agents_action import deploy_cluster_agents_action
+from ...action.agent.deploy_standalone_agents_action import deploy_standalone_agents_action
+from ...action.agent.deploy_subagent_clusters_action import deploy_subagent_clusters_action
+
+class Deploy:
+    def __init__(self, context: Context):
+        self._ctx = context
+        
+    def cluster_agents(
+        self,
+        controller_id: str, 
+        agent_ids: List[str],
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Deploy cluster agents to a controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller to which the cluster agents
+                should be deployed.
+
+            agent_ids (List[str]):
+                A collection of cluster agent IDs to be deployed.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns True if the operation was successful.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the server version is incompatible or if an unexpected
+                response is returned.
+        """
+        
+        return deploy_cluster_agents_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            agent_ids=agent_ids,
+            audit_log=audit_log
+        )
+        
+    def standalone_agents(
+        self,
+        controller_id: str,
+        agent_ids: List[str],
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Deploy standalone agents to a controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller to which the agents should be deployed.
+
+            agent_ids (List[str]):
+                A collection of standalone agent IDs to be deployed.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns True if the operation was successful.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the server version is incompatible or if an unexpected
+                response is returned.
+        """
+        
+        return deploy_standalone_agents_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            agent_ids=agent_ids,
+            audit_log=audit_log
+        )
+    
+    def subagent_clusters(
+        self,
+        controller_id: str,
+        subagent_cluster_ids: List[str],
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Deploy subagent clusters to a controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller to which the subagent clusters
+                should be deployed.
+
+            subagent_cluster_ids (List[str]):
+                A collection of subagent cluster IDs to be deployed.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns True if the operation was successful.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the server version is incompatible or if an unexpected
+                response is returned.
+        """
+        
+        return deploy_subagent_clusters_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            subagent_cluster_ids=subagent_cluster_ids,
+            audit_log=audit_log
+        )