automizor 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

automizor/__init__.py

@@ -1 +1 @@
-version = "0.3.1"
+version = "0.4.0"

automizor/exceptions.py

@@ -0,0 +1,69 @@
+from requests import Response
+
+
+class AutomizorError(Exception):
+    def __init__(self, message, error=None):
+        if error:
+            message = f"{message}: {error}"
+        super().__init__(message)
+
+    def __str__(self):
+        return f"{self.args[0]}"
+
+    @classmethod
+    def from_response(cls, response: Response, message: str):
+        _STATUS_EXCEPTION_MAP = {
+            400: InvalidRequest,
+            401: Unauthorized,
+            403: Forbidden,
+            404: NotFound,
+            429: RateLimitExceeded,
+            500: InternalServerError,
+            502: BadGateway,
+            503: ServiceUnavailable,
+        }
+
+        try:
+            error = dict(response.json()).get("detail", "Unknown error.")
+        except Exception:  # pylint: disable=broad-except
+            error = response.text
+
+        return _STATUS_EXCEPTION_MAP.get(response.status_code, UnexpectedError)(
+            message, error
+        )
+
+
+class BadGateway(AutomizorError):
+    pass
+
+
+class Forbidden(AutomizorError):
+    pass
+
+
+class InternalServerError(AutomizorError):
+    pass
+
+
+class InvalidRequest(AutomizorError):
+    pass
+
+
+class NotFound(AutomizorError):
+    pass
+
+
+class RateLimitExceeded(AutomizorError):
+    pass
+
+
+class ServiceUnavailable(AutomizorError):
+    pass
+
+
+class Unauthorized(AutomizorError):
+    pass
+
+
+class UnexpectedError(AutomizorError):
+    pass

automizor/job/__init__.py

@@ -1,6 +1,5 @@
 from functools import lru_cache
 
-from ._exceptions import AutomizorJobError
 from ._job import JSON
 
 
@@ -44,7 +43,6 @@ def set_result(name: str, value: JSON):
 
 
 __all__ = [
-    "AutomizorJobError",
     "get_context",
     "set_result",
 ]

automizor/job/_job.py

@@ -4,7 +4,8 @@ from typing import Dict, List, Union
 
 import requests
 
-from ._exceptions import AutomizorJobError
+from automizor.exceptions import AutomizorError
+from automizor.utils import get_api_config, get_headers
 
 JSON = Union[str, int, float, bool, None, Dict[str, "JSON"], List["JSON"]]
 
@@ -30,8 +31,7 @@ class Job:
     To use this class effectively, ensure that the following environment variables are
     set in your environment:
 
-    - ``AUTOMIZOR_API_HOST``: The URL of the `Automizor API` host.
-    - ``AUTOMIZOR_API_TOKEN``: The authentication token for API access.
+    - ``AUTOMIZOR_AGENT_TOKEN``: The token for authenticating against the `Automizor API`.
     - ``AUTOMIZOR_CONTEXT_FILE``: The path to a local file containing job context, if used.
     - ``AUTOMIZOR_JOB_ID``: The identifier for the current job, used when fetching context via API.
 
@@ -50,18 +50,12 @@ class Job:
     """
 
     def __init__(self):
-        self._api_host = os.getenv("AUTOMIZOR_API_HOST")
-        self._api_token = os.getenv("AUTOMIZOR_API_TOKEN")
-        self._context_file = os.getenv("AUTOMIZOR_CONTEXT_FILE")
-        self._job_id = os.getenv("AUTOMIZOR_JOB_ID")
+        self._context_file = os.getenv("AUTOMIZOR_CONTEXT_FILE", None)
+        self._job_id = os.getenv("AUTOMIZOR_JOB_ID", None)
 
+        self.url, self.token = get_api_config()
         self.session = requests.Session()
-        self.session.headers.update(
-            {
-                "Authorization": f"Token {self._api_token}",
-                "Content-Type": "application/json",
-            }
-        )
+        self.session.headers.update(get_headers(self.token))
 
     def get_context(self) -> dict:
         """
@@ -73,8 +67,7 @@ class Job:
         This is useful in environments where direct access to the `Automizor API` is
         not possible or preferred.
         2. The `Automizor API`, using the job ID (`AUTOMIZOR_JOB_ID`) to fetch the specific
-        job context. This requires valid API host (`AUTOMIZOR_API_HOST`) and token
-        (`AUTOMIZOR_API_TOKEN`) settings.
+        job context.
 
         Returns:
             A dictionary containing the job context.
@@ -125,10 +118,14 @@ class Job:
             return json.load(file)
 
     def _read_job_context(self) -> dict:
-        url = f"https://{self._api_host}/api/v1/rpa/job/{self._job_id}/"
+        url = f"https://{self.url}/api/v1/rpa/job/{self._job_id}/"
         try:
             response = self.session.get(url, timeout=10)
             response.raise_for_status()
             return response.json().get("context", {})
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to get job context"
+            ) from exc
         except Exception as exc:
-            raise AutomizorJobError(f"Failed to get job context: {exc}") from exc
+            raise AutomizorError("Failed to get job context") from exc

automizor/storage/__init__.py

@@ -1,6 +1,8 @@
+import json
+import mimetypes
 from functools import lru_cache
+from pathlib import Path
 
-from ._exceptions import AutomizorStorageError
 from ._storage import JSON
 
 
@@ -11,6 +13,30 @@ def _get_storage():
     return Storage()
 
 
+def list_assets() -> list[str]:
+    """
+    Retrieves a list of all asset names.
+
+    Returns:
+        A list of all asset names.
+    """
+
+    storage = _get_storage()
+    return storage.list_assets()
+
+
+def delete_asset(name: str) -> None:
+    """
+    Deletes the specified asset.
+
+    Parameters:
+        name: The name identifier of the asset to delete.
+    """
+
+    storage = _get_storage()
+    storage.delete_asset(name)
+
+
 def get_bytes(name: str) -> bytes:
     """
     Retrieves the specified asset as raw bytes.
@@ -72,10 +98,82 @@ def get_text(name: str) -> str:
     return storage.get_text(name)
 
 
+def set_bytes(name: str, data: bytes, content_type="application/octet-stream") -> None:
+    """
+    Uploads raw bytes as an asset.
+
+    Parameters:
+        name: The name identifier of the asset to upload.
+        data: The raw byte content to upload.
+        content_type: The MIME type of the asset.
+    """
+
+    storage = _get_storage()
+    storage.set_bytes(name, data, content_type)
+
+
+def set_file(name: str, path: str, content_type: str = None) -> None:
+    """
+    Uploads a file as an asset.
+
+    Parameters:
+        name: The name identifier of the asset to upload.
+        path: The filesystem path of the file to upload.
+        content_type: The MIME type of the asset.
+    """
+
+    content = Path(path).read_bytes()
+    if content_type is None:
+        content_type, _ = mimetypes.guess_type(path)
+        if content_type is None:
+            content_type = "application/octet-stream"
+
+    storage = _get_storage()
+    storage.set_bytes(name, content, content_type)
+
+
+def set_json(name: str, value: JSON, **kwargs) -> None:
+    """
+    Uploads JSON data as an asset.
+
+    Parameters:
+        name: The name identifier of the asset to upload.
+        value: The JSON data to upload.
+        kwargs: Additional keyword arguments to pass to json.dumps.
+    """
+
+    content = json.dumps(value, **kwargs).encode("utf-8")
+    content_type = "application/json"
+
+    storage = _get_storage()
+    storage.set_bytes(name, content, content_type)
+
+
+def set_text(name: str, text: str) -> None:
+    """
+    Uploads text content as an asset.
+
+    Parameters:
+        name: The name identifier of the asset to upload.
+        text: The text content to upload.
+    """
+
+    content = text.encode("utf-8")
+    content_type = "text/plain"
+
+    storage = _get_storage()
+    storage.set_bytes(name, content, content_type)
+
+
 __all__ = [
-    "AutomizorStorageError",
+    "list_assets",
+    "delete_asset",
     "get_bytes",
     "get_file",
     "get_json",
     "get_text",
+    "set_bytes",
+    "set_file",
+    "set_json",
+    "set_text",
 ]

automizor/storage/_storage.py

@@ -1,9 +1,9 @@
-import os
 from typing import Dict, List, Union
 
 import requests
 
-from ._exceptions import AutomizorStorageError
+from automizor.exceptions import AutomizorError, NotFound
+from automizor.utils import get_api_config, get_headers
 
 JSON = Union[str, int, float, bool, None, Dict[str, "JSON"], List["JSON"]]
 
@@ -23,8 +23,7 @@ class Storage:
     To use this class effectively, ensure that the following environment variables are
     set in your environment:
 
-    - ``AUTOMIZOR_API_HOST``: Specifies the host URL of the `Automizor Storage API`.
-    - ``AUTOMIZOR_API_TOKEN``: Provides the token required for API authentication.
+    - ``AUTOMIZOR_AGENT_TOKEN``: The token for authenticating against the `Automizor API`.
 
     Example usage:
 
@@ -32,30 +31,82 @@ class Storage:
 
         from automizor import storage
 
-        # To get bytes of an asset
-        bytes_data = storage.get_bytes("asset_name")
+        # To list all assets
+        asset_names = storage.list_assets()
 
-        # To save an asset to a file
-        file_path = storage.get_file("asset_name", "/path/to/save/file")
+        # To delete an asset
+        storage.delete_asset("AssetName")
 
-        # To retrieve an asset as JSON
-        json_data = storage.get_json("asset_name")
+        # Save an asset
+        storage.set_bytes("AssetName", b"Hello, World!")
+        storage.set_file("AssetName", "/path/to/file")
+        storage.set_json("AssetName", {"key": "value"})
+        storage.set_text("AssetName", "Hello, World!")
 
-        # To get the text content of an asset
-        text_data = storage.get_text("asset_name")
+        # Get an asset
+        bytes_data = storage.get_bytes("AssetName")
+        file_path = storage.get_file("AssetName", "/path/to/save/file")
+        json_data = storage.get_json("AssetName")
+        text_data = storage.get_text("AssetName")
     """
 
     def __init__(self):
-        self._api_host = os.getenv("AUTOMIZOR_API_HOST")
-        self._api_token = os.getenv("AUTOMIZOR_API_TOKEN")
-
+        self.url, self.token = get_api_config()
         self.session = requests.Session()
-        self.session.headers.update(
-            {
-                "Authorization": f"Token {self._api_token}",
-                "Content-Type": "application/json",
-            }
-        )
+        self.session.headers.update(get_headers(self.token))
+
+    def list_assets(self) -> List[str]:
+        """
+        Retrieves a list of all asset names.
+
+        This function fetches the names of all assets stored in the storage service,
+        providing a convenient way to list and identify the available assets.
+
+        Returns:
+            A list of all asset names.
+        """
+        url = f"https://{self.url}/api/v1/storage/asset/"
+        asset_names = []
+
+        try:
+            while url:
+                response = self.session.get(url, timeout=10)
+                response.raise_for_status()
+                data = response.json()
+
+                for asset in data["results"]:
+                    asset_names.append(asset["name"])
+                url = data["next"]
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to list assets"
+            ) from exc
+        except Exception as exc:
+            raise AutomizorError("Failed to list assets") from exc
+        return asset_names
+
+    def delete_asset(self, name: str) -> None:
+        """
+        Deletes the specified asset.
+
+        This function deletes the asset identified by `name` from the storage service.
+        It is useful for removing assets that are no longer needed or should be cleaned
+        up to free up storage space.
+
+        Parameters:
+            name: The name identifier of the asset to delete.
+        """
+
+        url = f"https://{self.url}/api/v1/storage/asset/{name}/"
+        try:
+            response = self.session.delete(url, timeout=10)
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to delete asset"
+            ) from exc
+        except Exception as exc:
+            raise AutomizorError("Failed to delete asset") from exc
 
     def get_bytes(self, name: str) -> bytes:
         """
@@ -72,8 +123,7 @@ class Storage:
             The raw byte content of the asset.
         """
 
-        url = self._get_asset_url(name)
-        return self._download_file(url, mode="content")
+        return self._download_file(name, mode="content")
 
     def get_file(self, name: str, path: str) -> str:
         """
@@ -92,8 +142,7 @@ class Storage:
             The path to the saved file, confirming the operation's success.
         """
 
-        url = self._get_asset_url(name)
-        content = self._download_file(url, mode="content")
+        content = self._download_file(name, mode="content")
         with open(path, "wb") as file:
             file.write(content)
         return path
@@ -113,8 +162,7 @@ class Storage:
             The parsed JSON data, which can be a dict, list, or primitive data type.
         """
 
-        url = self._get_asset_url(name)
-        return self._download_file(url, mode="json")
+        return self._download_file(name, mode="json")
 
     def get_text(self, name: str) -> str:
         """
@@ -131,13 +179,62 @@ class Storage:
             The content of the asset as a text string.
         """
 
+        return self._download_file(name, mode="text")
+
+    def set_bytes(self, name: str, content: bytes, content_type: str) -> None:
+        """
+        Uploads the specified content as a new asset.
+
+        This function uploads the provided `content` as a new asset with the specified
+        `name`. It is useful for creating new assets or updating existing ones with
+        fresh content.
+
+        Parameters:
+            name: The name identifier of the asset to create.
+            content: The raw byte content of the asset.
+            content_type: The MIME type of the asset content.
+        """
+
+        try:
+            self._update_asset(name, content, content_type)
+        except NotFound:
+            self._create_asset(name, content, content_type)
+
+    def _create_asset(self, name: str, content: bytes, content_type: str) -> None:
+        """
+        Creates a new asset with the specified content.
+
+        This function creates a new asset with the specified `name` and `content` in the
+        storage service. It is useful for uploading new assets or updating existing ones
+        with fresh content.
+
+        Parameters:
+            name: The name identifier of the asset to create.
+            content: The raw byte content of the asset.
+            content_type: The MIME type of the asset content.
+        """
+
+        url = f"https://{self.url}/api/v1/storage/asset/"
+        try:
+            data = {
+                "content_type": content_type,
+                "name": name,
+            }
+            files = {"file": ("text.txt", content, content_type)}
+            response = self.session.post(url, files=files, data=data, timeout=10)
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to create asset"
+            ) from exc
+        except Exception as exc:
+            raise AutomizorError("Failed to create asset") from exc
+
+    def _download_file(self, name: str, mode: str = "content"):
         url = self._get_asset_url(name)
-        return self._download_file(url, mode="text")
 
-    def _download_file(self, url: str, mode: str = "content"):
         try:
-            session = requests.Session()
-            response = session.get(url, timeout=10)
+            response = requests.get(url=url, timeout=10)
             response.raise_for_status()
 
             match mode:
@@ -148,11 +245,15 @@ class Storage:
                 case "text":
                     return response.text
             raise RuntimeError(f"Invalid mode {mode}")
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to download asset"
+            ) from exc
         except Exception as exc:
-            raise AutomizorStorageError(f"Failed to download asset: {exc}") from exc
+            raise AutomizorError("Failed to download asset") from exc
 
     def _get_asset_url(self, name: str) -> str:
-        url = f"https://{self._api_host}/api/v1/storage/asset/{name}/"
+        url = f"https://{self.url}/api/v1/storage/asset/{name}/"
         try:
             response = self.session.get(url, timeout=10)
             response.raise_for_status()
@@ -161,5 +262,39 @@ class Storage:
             if url:
                 return url
             raise RuntimeError("Url not found")
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to get asset URL"
+            ) from exc
+        except Exception as exc:
+            raise AutomizorError("Failed to get asset URL") from exc
+
+    def _update_asset(self, name: str, content: bytes, content_type: str) -> None:
+        """
+        Updates the specified asset with new content.
+
+        This function updates the asset identified by `name` with fresh content
+        provided as `content`. It is useful for modifying existing assets without
+        creating a new asset, ensuring that the asset's content is up-to-date.
+
+        Parameters:
+            name: The name identifier of the asset to update.
+            content: The raw byte content of the asset.
+            content_type: The MIME type of the asset content.
+        """
+
+        url = f"https://{self.url}/api/v1/storage/asset/{name}/"
+        try:
+            data = {
+                "content_type": content_type,
+                "name": name,
+            }
+            files = {"file": ("text.txt", content, content_type)}
+            response = self.session.put(url, files=files, data=data, timeout=10)
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to update asset"
+            ) from exc
         except Exception as exc:
-            raise AutomizorStorageError(f"Failed to get asset url: {exc}") from exc
+            raise AutomizorError("Failed to update asset") from exc

automizor/utils/__init__.py

@@ -0,0 +1,31 @@
+import os
+import platform
+
+from automizor import version
+from automizor.exceptions import AutomizorError
+
+OS_SYSTEM, OS_RELEASE, _ = platform.system_alias(
+    platform.system(), platform.release(), platform.version()
+)
+
+
+def get_api_config() -> tuple[str, str]:
+    token_string = os.getenv("AUTOMIZOR_AGENT_TOKEN")
+
+    if not token_string:
+        raise AutomizorError("AUTOMIZOR_AGENT_TOKEN is not set.")
+
+    try:
+        token, url = token_string.strip().split("@")
+    except ValueError as exc:
+        raise AutomizorError(
+            "AUTOMIZOR_AGENT_TOKEN is not in the correct format."
+        ) from exc
+    return url, token
+
+
+def get_headers(token: str) -> dict:
+    return {
+        "Authorization": f"Token {token}",
+        "User-Agent": f"Automizor/{version} {OS_SYSTEM}/{OS_RELEASE}",
+    }

automizor/vault/__init__.py

@@ -1,7 +1,7 @@
 from functools import lru_cache
+from typing import Any, Dict
 
 from ._container import SecretContainer
-from ._exceptions import AutomizorVaultError
 
 
 @lru_cache
@@ -11,10 +11,40 @@ def _get_vault():
     return Vault()
 
 
+def create_secret(
+    name: str,
+    value: Dict[str, Any],
+    description: str = "",
+) -> SecretContainer:
+    """
+    Creates a new secret. Stores the secret in the `Automizor API`.
+    If the secret already exists, it will be updated.
+
+    Args:
+        name: The name of the secret.
+        value: The value of the secret.
+        description: The description of the secret.
+
+    Returns:
+        The created secret.
+
+    Raises:
+        AutomizorVaultError: If creating the secret fails.
+    """
+
+    secret = SecretContainer(
+        name=name,
+        description=description,
+        value=value,
+    )
+
+    vault = _get_vault()
+    return vault.create_secret(secret)
+
+
 def get_secret(name: str) -> SecretContainer:
     """
-    Retrieves a secret by its name. Fetches from a local file or queries the
-    `Automizor API`, based on configuration.
+    Retrieves a secret by its name. Fetches from the `Automizor API`.
 
     Args:
         name: The name of the secret to retrieve.
@@ -32,8 +62,7 @@ def get_secret(name: str) -> SecretContainer:
 
 def set_secret(secret: SecretContainer) -> SecretContainer:
     """
-    Updates an existing secret. Updates to a local file or to the
-    `Automizor API`, based on configuration.
+    Updates an existing secret. Updates to the `Automizor API`.
 
     Args:
         secret: The secret to update.
@@ -50,8 +79,8 @@ def set_secret(secret: SecretContainer) -> SecretContainer:
 
 
 __all__ = [
-    "AutomizorVaultError",
     "SecretContainer",
+    "create_secret",
     "get_secret",
     "set_secret",
 ]

automizor/vault/_container.py

@@ -1,4 +1,5 @@
 from dataclasses import dataclass, fields
+from typing import Any, Dict
 
 
 def ignore_extra_fields(cls):
@@ -29,7 +30,7 @@ class SecretContainer:
     """
 
     name: str
-    value: dict
+    value: Dict[str, Any]
     description: str = ""
 
     def get(self, key, default=None):
@@ -44,7 +45,7 @@ class SecretContainer:
         """Secret.keys() -> a set-like object providing a view on secret's keys."""
         return self.value.keys()
 
-    def update(self, pairs: dict) -> None:
+    def update(self, pairs: Dict[str, Any]) -> None:
         """Update the secret's dictionary with the key-value pairs from pairs."""
         self.value.update(pairs)
 

automizor/vault/_vault.py

@@ -1,42 +1,26 @@
-import json
-import os
 from dataclasses import asdict
 
 import requests
 
+from automizor.exceptions import AutomizorError, NotFound
+from automizor.utils import get_api_config, get_headers
+
 from ._container import SecretContainer
-from ._exceptions import AutomizorVaultError
 
 
 class Vault:
     """
     `Vault` is a secure storage class within the `Automizor Platform` for managing
     secrets such as API keys, passwords, and other sensitive information. It offers
-    functionality to securely retrieve and update secrets, either through direct
-    interaction with the `Automizor API` or via a local secrets file, depending on
-    the operational environment and configuration.
+    functionality to securely retrieve and update secrets through direct interaction
+    with the `Automizor API`.
 
     Configuration for accessing and manipulating these secrets is driven by environment
     variables, which are essential for specifying the API's host and token for
-    authentication purposes, alongside the location of a local secrets file, should
-    local storage be preferred over API interaction.
+    authentication purposes.
 
     Environment variables requisite for operation include:
-    - ``AUTOMIZOR_API_HOST``: The host URL for the `Automizor API`.
-    - ``AUTOMIZOR_API_TOKEN``: The token for authenticate against the `Automizor API`.
-    - ``AUTOMIZOR_SECRET_FILE``: Optionally specifies the path to a local file where
-      secrets are stored, enabling operations in environments where direct API access
-      may be restricted or unavailable.
-
-    Example of a local secret file:
-
-    .. code-block:: json
-
-        {
-            "my_secret_name": {
-                "key": "value"
-            }
-        }
+    - ``AUTOMIZOR_AGENT_TOKEN``: The token for authenticating against the `Automizor API`.
 
     Example usage:
 
@@ -44,33 +28,48 @@ class Vault:
 
         from automizor import vault
 
+        # Create a new secret
+        vault.create_secret(name="MySecret", value={"username": "admin", "password": "*****"})
+
         # Retrieve a secret by its name
-        secret = vault.get_secret("my_secret_name")
-        print(secret["key"])  # Output: "value"
+        secret = vault.get_secret("MySecret")
+        print(secret.get("username"))  # Output: "admin"
+        print(secret.get("password"))  # Output: "*****"
 
         # Update a existing secret
-        secret = vault.get_secret("my_secret_name")
-        secret["new_key"] = "new_value"
+        secret = vault.get_secret("MySecret")
+        secret.update({"username": "user"})
         vault.set_secret(secret)
     """
 
     def __init__(self):
-        self._api_host = os.getenv("AUTOMIZOR_API_HOST")
-        self._api_token = os.getenv("AUTOMIZOR_API_TOKEN")
-        self._secret_file = os.getenv("AUTOMIZOR_SECRET_FILE")
-
+        self.url, self.token = get_api_config()
         self.session = requests.Session()
-        self.session.headers.update(
-            {
-                "Authorization": f"Token {self._api_token}",
-                "Content-Type": "application/json",
-            }
-        )
+        self.session.headers.update(get_headers(self.token))
+
+    def create_secret(self, secret: SecretContainer) -> SecretContainer:
+        """
+        Creates a new secret. Stores the secret in the `Automizor API`.
+        If the secret already exists, it will be updated.
+
+        Args:
+            secret: The secret to create.
+
+        Returns:
+            The created secret.
+
+        Raises:
+            AutomizorVaultError: If creating the secret fails.
+        """
+
+        try:
+            return self._update_secret(secret)
+        except NotFound:
+            return self._create_secret(secret)
 
     def get_secret(self, name) -> SecretContainer:
         """
-        Retrieves a secret by its name. Fetches from a local file or queries the
-        `Automizor API`, based on configuration.
+        Retrieves a secret by its name. Fetches from the `Automizor API`.
 
         Args:
             name: The name of the secret to retrieve.
@@ -82,14 +81,11 @@ class Vault:
             AutomizorVaultError: If retrieving the secret fails.
         """
 
-        if self._secret_file:
-            return self._read_file_secret(name)
-        return self._read_vault_secret(name)
+        return self._get_secret(name)
 
     def set_secret(self, secret: SecretContainer) -> SecretContainer:
         """
-        Updates an existing secret. Updates to a local file or to the
-        `Automizor API`, based on configuration.
+        Updates an existing secret. Updates to the `Automizor API`.
 
         Args:
             secret: The secret to update.
@@ -101,39 +97,43 @@ class Vault:
             AutomizorVaultError: If updating the secret fails.
         """
 
-        if self._secret_file:
-            return self._write_file_secret(secret)
-        return self._write_vault_secret(secret)
+        return self._update_secret(secret)
 
-    def _read_file_secret(self, name: str) -> SecretContainer:
-        with open(self._secret_file, "r", encoding="utf-8") as file:
-            secrets = json.load(file)
-            value = secrets.get(name, {})
-        return SecretContainer(name=name, value=value)
+    def _create_secret(self, secret: SecretContainer) -> SecretContainer:
+        url = f"https://{self.url}/api/v1/vault/secret/"
+        try:
+            response = self.session.post(url, timeout=10, json=asdict(secret))
+            response.raise_for_status()
+            return SecretContainer(**response.json())
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to create secret"
+            ) from exc
+        except Exception as exc:
+            raise AutomizorError("Failed to create secret") from exc
 
-    def _read_vault_secret(self, name: str) -> SecretContainer:
-        url = f"https://{self._api_host}/api/v1/vault/secret/{name}/"
+    def _get_secret(self, name: str) -> SecretContainer:
+        url = f"https://{self.url}/api/v1/vault/secret/{name}/"
         try:
             response = self.session.get(url, timeout=10)
             response.raise_for_status()
             return SecretContainer(**response.json())
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to get secret"
+            ) from exc
         except Exception as exc:
-            raise AutomizorVaultError(f"Failed to get secret: {exc}") from exc
-
-    def _write_file_secret(self, secret: SecretContainer):
-        with open(self._secret_file, "r+", encoding="utf-8") as file:
-            secrets = json.load(file)
-            secrets[secret.name] = secret.value
-            file.seek(0)
-            file.write(json.dumps(secrets, indent=4))
-            file.truncate()
-        return secret
-
-    def _write_vault_secret(self, secret: SecretContainer) -> SecretContainer:
-        url = f"https://{self._api_host}/api/v1/vault/secret/{secret.name}/"
+            raise AutomizorError("Failed to get secret") from exc
+
+    def _update_secret(self, secret: SecretContainer) -> SecretContainer:
+        url = f"https://{self.url}/api/v1/vault/secret/{secret.name}/"
         try:
             response = self.session.put(url, timeout=10, json=asdict(secret))
             response.raise_for_status()
             return SecretContainer(**response.json())
+        except requests.HTTPError as exc:
+            raise AutomizorError.from_response(
+                exc.response, "Failed to update secret"
+            ) from exc
         except Exception as exc:
-            raise AutomizorVaultError(f"Failed to set secret: {exc}") from exc
+            raise AutomizorError("Failed to update secret") from exc

{automizor-0.3.1.dist-info → automizor-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: automizor
-Version: 0.3.1
+Version: 0.4.0
 Summary: Python Automizor framework
 Home-page: https://github.com/automizor/automizor
 Author: Christian Fischer

automizor-0.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+automizor/__init__.py,sha256=yhiWOz0HoJGRRI9-JQ2eh_0AbByy-6psK08-kpTSHJw,18
+automizor/exceptions.py,sha256=P5imySIOtG3ZIk2kh41Yod4RnlgTj7Vf0P3M-RuxQJs,1382
+automizor/job/__init__.py,sha256=DNRuT6cyPQBaPRG4vNalCmEvcJQl-73b5ZDFOfNOwIg,1019
+automizor/job/_job.py,sha256=62T_eMEqsJlxhlQ8_3nupTvvwsEysgx5JZAz7ui1WLo,5245
+automizor/storage/__init__.py,sha256=DUVVvetBgsrF69mfiM9iu1PvSBjFPLxrgH1o18mvReA,4000
+automizor/storage/_storage.py,sha256=rKWxaCA_kFr5cW_RrHqL4uEVzNqdWjTQAOXFTfIxlfY,11021
+automizor/utils/__init__.py,sha256=2trRoR5lljYKbYdxmioSlvzajjQM0Wnoq3bvF9lEZ6w,811
+automizor/vault/__init__.py,sha256=UjRiW3J0R9ABXc1gXIPyS3cqNCwMWxx0l-C0PsIg7R0,1699
+automizor/vault/_container.py,sha256=TXwNhjK-qrfu_5iDJm1J0Kkuyq22dLdES1DqjAAKnWA,1953
+automizor/vault/_vault.py,sha256=uRsjOjzsstZpYwJoHNg_cpv803Dzo4T2oF6hwiG3Eww,4688
+automizor-0.4.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+automizor-0.4.0.dist-info/METADATA,sha256=Ky_rwJrB2JUutCKAYo9Rzkwo_j6UPyQaS8HRORjr6O8,661
+automizor-0.4.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+automizor-0.4.0.dist-info/top_level.txt,sha256=gScDy4I3tP6BMYAsTAlBXrxVh3E00zV0UioxwXJOI3Y,10
+automizor-0.4.0.dist-info/RECORD,,

{automizor-0.3.1.dist-info → automizor-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

automizor/job/_exceptions.py

@@ -1,2 +0,0 @@
-class AutomizorJobError(RuntimeError):
-    """Exception raised for errors encountered while interacting with the Job."""

automizor/job.py

@@ -1,132 +0,0 @@
-import json
-import os
-from typing import Any, Dict, List, Union
-
-import requests
-
-JSONType = Union[str, int, float, bool, None, Dict[str, Any], List[Any]]
-
-
-class AutomizorJobError(RuntimeError):
-    """Exception raised for errors encountered while interacting with the Job."""
-
-
-class Job:
-    """
-    Represents a job in the `Automizor Platform`, managing the retrieval and storage of job
-    context and results.
-
-    This class provides functionality to interact with the `Automizor API` or local files to
-    obtain job context and persist job results.
-
-    For testing purposes, you may want to set the environment variables in your local environment.
-    The required variables are:
-
-    - ``AUTOMIZOR_API_HOST``: The host URL of the `Automizor API`
-    - ``AUTOMIZOR_API_TOKEN``: The token used for authenticating with the `Automizor API`
-    - ``AUTOMIZOR_JOB_ID``: The ID of the job from which to retrieve context
-
-    Additionally, you can specify a local context file; in this case, you don't need to set the
-    above environment variables:
-
-    - ``AUTOMIZOR_CONTEXT_FILE``: The path to a local file containing the job context.
-
-    Example of a local context file:
-
-    .. code-block:: json
-
-        {
-            "key": "value"
-        }
-
-    Example usage:
-
-    .. code-block:: python
-
-        from automizor.job import Job
-
-        job = Job()
-
-        def read_context():
-            context = job.get_job_context()
-            print(context["key"])  # Output: "value"
-
-        def save_result():
-            job.set_job_result("result_key", "result_value")
-
-    """
-
-    def __init__(self):
-        self._api_host = os.getenv("AUTOMIZOR_API_HOST")
-        self._api_token = os.getenv("AUTOMIZOR_API_TOKEN")
-        self._context_file = os.getenv("AUTOMIZOR_CONTEXT_FILE")
-        self._job_id = os.getenv("AUTOMIZOR_JOB_ID")
-
-    @property
-    def headers(self) -> dict:
-        """Headers for API requests, including Authorization and Content-Type."""
-        return {
-            "Authorization": f"Token {self._api_token}",
-            "Content-Type": "application/json",
-        }
-
-    def get_job_context(self) -> dict:
-        """
-        Retrieves the job's context from either a local file or via an API call, based on
-        the configuration.
-
-        If a local context file is specified (via `AUTOMIZOR_CONTEXT_FILE`), it reads the context
-        from the file. Otherwise, it fetches the context from the Automizor API using the job ID
-        and API credentials.
-
-        Returns:
-            A dictionary with the job's context.
-
-        Raises:
-            AutomizorJobError: If retrieving the job context fails.
-        """
-
-        if self._context_file:
-            return self._read_file_context()
-        return self._read_job_context()
-
-    def set_job_result(self, name: str, value: JSONType):
-        """
-        Saves a job result into a JSON file (`output/result.json`).
-
-        Updates the file with the new result, creating or overwriting the file as necessary.
-        If the file exists and contains data, it merges the new result with the existing data.
-
-        Parameters:
-            name (str): The key under which to store the result.
-            value (JSONType): The result value, must be JSON serializable.
-
-        Note: Errors during file operations will raise unhandled exceptions.
-        """
-
-        data = {}
-        file_path = "output/result.json"
-        try:
-            if os.path.exists(file_path):
-                with open(file_path, "r", encoding="utf-8") as file:
-                    data = json.load(file)
-        except json.JSONDecodeError:
-            pass
-
-        data[name] = value
-
-        with open(file_path, "w", encoding="utf-8") as file:
-            json.dump(data, file, ensure_ascii=False, indent=4)
-
-    def _read_file_context(self) -> dict:
-        with open(self._context_file, "r", encoding="utf-8") as file:
-            return json.load(file)
-
-    def _read_job_context(self) -> dict:
-        url = f"https://{self._api_host}/api/v1/rpa/job/{self._job_id}/"
-        try:
-            response = requests.get(url, headers=self.headers, timeout=10)
-            response.raise_for_status()
-            return response.json().get("context", {})
-        except Exception as exc:
-            raise AutomizorJobError(f"Failed to get job context: {exc}") from exc

automizor/storage/_exceptions.py

@@ -1,2 +0,0 @@
-class AutomizorStorageError(RuntimeError):
-    """Exception raised for errors encountered while interacting with the Storage."""

automizor/vault/_exceptions.py

@@ -1,2 +0,0 @@
-class AutomizorVaultError(RuntimeError):
-    """Exception raised for errors encountered while interacting with the Vault."""

automizor/vault/_secret.py

@@ -1,45 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class Secret:
-    """
-    Represents a secret, comprising a name and its associated values.
-
-    Attributes:
-        name: The name of the secret.
-        value: The secret's values, stored in a dictionary as key-value pairs.
-    """
-
-    name: str
-    value: dict
-
-    def get(self, key, default=None):
-        """Return the value for key if key is in the dictionary, else default."""
-        return self.value.get(key, default)
-
-    def items(self):
-        """secret.items() -> a set-like object providing a view on secret's items."""
-        return self.value.items()
-
-    def update(self, pairs: dict) -> None:
-        self.value.update(pairs)
-
-    def __getitem__(self, key):
-        return self.value[key]
-
-    def __setitem__(self, key, value):
-        self.value[key] = value
-
-    def __contains__(self, key):
-        return key in self.value
-
-    def __iter__(self):
-        return iter(self.value)
-
-    def __len__(self):
-        return len(self.value)
-
-    def __repr__(self):
-        keys = ", ".join(self.value.keys())
-        return f"Secret(name={self.name}, keys={keys})"

automizor/vault.py

@@ -1,190 +0,0 @@
-import json
-import os
-from dataclasses import asdict, dataclass
-
-import requests
-
-
-class AutomizorVaultError(RuntimeError):
-    """Exception raised for errors encountered while interacting with the Vault."""
-
-
-@dataclass
-class Secret:
-    """
-    Represents a secret, comprising a name and its associated values.
-
-    Attributes:
-        name (str): The name of the secret.
-        value (dict): The secret's values, stored in a dictionary as key-value pairs.
-    """
-
-    name: str
-    value: dict
-
-    def get(self, key, default=None):
-        """Return the value for key if key is in the dictionary, else default."""
-        return self.value.get(key, default)
-
-    def items(self):
-        """secret.items() -> a set-like object providing a view on secret's items."""
-        return self.value.items()
-
-    def update(self, pairs: dict) -> None:
-        self.value.update(pairs)
-
-    def __getitem__(self, key):
-        return self.value[key]
-
-    def __setitem__(self, key, value):
-        self.value[key] = value
-
-    def __contains__(self, key):
-        return key in self.value
-
-    def __iter__(self):
-        return iter(self.value)
-
-    def __len__(self):
-        return len(self.value)
-
-    def __repr__(self):
-        keys = ", ".join(self.value.keys())
-        return f"Secret(name={self.name}, keys={keys})"
-
-
-class Vault:
-    """
-    `Vault` is a library to manage secrets within an the `Automizor Platform`,
-    providing functionality to retrieve and update secrets. It supports interaction
-    with the `Vault API` (by default) or a local file for secret storage, determined
-    by environment variable configuration.
-
-    The Vault class uses environment variables to configure the API host, API token,
-    which are set by the `Automizor Agent`.
-
-    You may want to set the environment variables in your local environment for testing
-    purposes. The variables which must exist are:
-
-    - ``AUTOMIZOR_API_HOST``: The host URL of the `Automizor API`
-    - ``AUTOMIZOR_API_TOKEN``: The token used for authenticating with the `Automizor API`
-
-    In addition, you can set the following environment variable to use a local file for
-    secret storage:
-
-    - ``AUTOMIZOR_SECRET_FILE``: The path to a local file where secrets are stored.
-
-    Example of a local secret file:
-
-    .. code-block:: json
-
-        {
-            "my_secret_name": {
-                "key": "value"
-            }
-        }
-
-    Example usage:
-
-    .. code-block:: python
-
-        from automizor.vault import Vault
-
-        vault = Vault()
-
-        def read_secret():
-            secret = vault.get_secret("my_secret_name")
-            print(secret["key"])  # Output: "value"
-
-        def update_secret():
-            secret = vault.get_secret("my_secret_name")
-            secret["new_key"] = "new_value"
-            vault.set_secret(secret)
-
-    """
-
-    def __init__(self):
-        self._api_host = os.getenv("AUTOMIZOR_API_HOST")
-        self._api_token = os.getenv("AUTOMIZOR_API_TOKEN")
-        self._secret_file = os.getenv("AUTOMIZOR_SECRET_FILE")
-
-    @property
-    def headers(self) -> dict:
-        """Headers for API requests, including Authorization and Content-Type."""
-        return {
-            "Authorization": f"Token {self._api_token}",
-            "Content-Type": "application/json",
-        }
-
-    def get_secret(self, name) -> Secret:
-        """
-        Retrieves a secret by its name. Fetches from a local file or queries the
-        `Automizor API`, based on configuration.
-
-        Args:
-            name (str): The name of the secret to retrieve.
-
-        Returns:
-            Secret: The retrieved secret.
-
-        Raises:
-            AutomizorVaultError: If retrieving the secret fails.
-        """
-
-        if self._secret_file:
-            return self._read_file_secret(name)
-        return self._read_vault_secret(name)
-
-    def set_secret(self, secret: Secret) -> Secret:
-        """
-        Updates a secret. Writes to a local file or sends to the `Automizor API`,
-        based on configuration.
-
-        Args:
-            secret (Secret): The secret to update.
-
-        Returns:
-            Secret: The updated secret.
-
-        Raises:
-            AutomizorVaultError: If updating the secret fails.
-        """
-
-        if self._secret_file:
-            return self._write_file_secret(secret)
-        return self._write_vault_secret(secret)
-
-    def _read_file_secret(self, name: str) -> Secret:
-        with open(self._secret_file, "r", encoding="utf-8") as file:
-            secrets = json.load(file)
-            value = secrets.get(name, {})
-        return Secret(name=name, value=value)
-
-    def _read_vault_secret(self, name: str) -> Secret:
-        url = f"https://{self._api_host}/api/v1/vault/secret/{name}/"
-        try:
-            response = requests.get(url, headers=self.headers, timeout=10)
-            response.raise_for_status()
-            return Secret(**response.json())
-        except Exception as exc:
-            raise AutomizorVaultError(f"Failed to get secret: {exc}") from exc
-
-    def _write_file_secret(self, secret: Secret):
-        with open(self._secret_file, "r+", encoding="utf-8") as file:
-            secrets = json.load(file)
-            secrets[secret.name] = secret.value
-            file.seek(0)
-            file.write(json.dumps(secrets, indent=4))
-            file.truncate()
-        return secret
-
-    def _write_vault_secret(self, secret: Secret) -> Secret:
-        url = f"https://{self._api_host}/api/v1/vault/secret/{secret.name}/"
-        try:
-            response = requests.put(
-                url, headers=self.headers, timeout=10, json=asdict(secret)
-            )
-            response.raise_for_status()
-            return Secret(**response.json())
-        except Exception as exc:
-            raise AutomizorVaultError(f"Failed to set secret: {exc}") from exc

automizor-0.3.1.dist-info/RECORD

@@ -1,20 +0,0 @@
-automizor/__init__.py,sha256=sEAhGxRzEBE5t0VjAcJ-336II62pGIQ0eLrs42I-sGU,18
-automizor/job.py,sha256=L2NkM-BkvJpeO_SH0BMgternD9M83K_Yv_ANhf1k3FI,4354
-automizor/storage.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-automizor/vault.py,sha256=mluaCcJCMxu2g0iTBJ6ntoZATn8eotfZb4rdzWsBslU,5845
-automizor/job/__init__.py,sha256=g-n56j50AGPCE23Nm0QFZCrkCa-c_weqvPcEX3I1NQY,1087
-automizor/job/_exceptions.py,sha256=zngd7Vv4dkCfwmkigaHiyu5gKAgmcRHt095h55KlbDg,121
-automizor/job/_job.py,sha256=NkoNnJxmdkqdF-Qxm4taal-Go0COVFo57tZAaWM1ihI,5365
-automizor/storage/__init__.py,sha256=KuWO-Pb4FQXj68Ewv8QZR9XeKsROCR-wusdWf0osaLw,1674
-automizor/storage/_exceptions.py,sha256=LOtgshWg3gOFhDZlcMWhXLT_q11zpTBEA85NqKnSi4A,129
-automizor/storage/_storage.py,sha256=IwTw6PYYNwJtGI4ZfiqY0-SkgCoaYnykkP_hHVuy9IU,5777
-automizor/vault/__init__.py,sha256=Y3FsdG5cdksVO8nBzIPt8Wwxg8VkFtkpu-kn1xWxrGo,1140
-automizor/vault/_container.py,sha256=QgTZtBQrX8wZSEjJqTkn2_S-rwIRxukdBQYIRd7md_g,1904
-automizor/vault/_exceptions.py,sha256=Wblvmaj6F0pIiTAH7X3JuxqTprUA5tvuuRAs9YgbiBI,125
-automizor/vault/_secret.py,sha256=pks_3uvD1IhYirOaZ2cAOxX2r9vzvXqLa-aDzJysreE,1136
-automizor/vault/_vault.py,sha256=G1IryuPfXeMUMoAFmGgPibD70zn307KQLNcNitd3D1A,4825
-automizor-0.3.1.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-automizor-0.3.1.dist-info/METADATA,sha256=SkNNe2kHyA9aGX2275j7RFOy6GqKb9eN3WwQBT3sRpM,661
-automizor-0.3.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-automizor-0.3.1.dist-info/top_level.txt,sha256=gScDy4I3tP6BMYAsTAlBXrxVh3E00zV0UioxwXJOI3Y,10
-automizor-0.3.1.dist-info/RECORD,,