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

automizor/__init__.py

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

automizor/job/__init__.py

@@ -0,0 +1,50 @@
+from functools import lru_cache
+
+from ._exceptions import AutomizorJobError
+from ._job import JSON
+
+
+@lru_cache
+def _get_job():
+    from ._job import Job
+
+    return Job()
+
+
+def get_context() -> dict:
+    """
+    Retrieves the context of the current job, which contains necessary information
+    for job execution.
+
+    Returns:
+        A dictionary with the job's context.
+
+    Raises:
+        AutomizorJobError: If retrieving the job context fails.
+    """
+
+    job = _get_job()
+    return job.get_context()
+
+
+def set_result(name: str, value: JSON):
+    """
+    Saves the result of the job execution to a local JSON file (`output/result.json`).
+    The `Automizor Agent` uploads this file to the `Automizor Platform` after the job.
+
+    Parameters:
+        name: The key under which to store the result.
+        value: The result value, must be JSON serializable.
+
+    Note: Errors during file operations will raise unhandled exceptions.
+    """
+
+    job = _get_job()
+    return job.set_result(name, value)
+
+
+__all__ = [
+    "AutomizorJobError",
+    "get_context",
+    "set_result",
+]

automizor/job/_exceptions.py

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

automizor/job/_job.py

@@ -0,0 +1,134 @@
+import json
+import os
+from typing import Dict, List, Union
+
+import requests
+
+from ._exceptions import AutomizorJobError
+
+JSON = Union[str, int, float, bool, None, Dict[str, "JSON"], List["JSON"]]
+
+
+class Job:
+    """
+    `Job` is a class that facilitates interaction with job-specific data within the
+    `Automizor Platform`, allowing for the retrieval and updating of job context and
+    results. It provides mechanisms to access job context either from a local file or
+    directly from the `Automizor API`, based on the environment configuration. Additionally,
+    it offers functionality to save job results, enhancing automation workflows.
+
+    This class utilizes environment variables for configuration, specifically for setting
+    up the API host and API token, which are essential for authenticating requests made
+    to the `Automizor Storage API`. These variables are typically configured by the
+    `Automizor Agent`.
+
+    The job ID is required to fetch the job context from the `Automizor API`. If a job ID
+    is not available in the environment, the context can be read from a local file by setting
+    the `AUTOMIZOR_CONTEXT_FILE` environment variable. In this case, no other environment
+    variables are required.
+
+    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_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.
+
+    Example usage:
+
+    .. code-block:: python
+
+        from automizor import job
+
+        # Retrieving job context
+        context = job.get_context()
+        print(context)  # Output: {"key": "value"}
+
+        # Saving a job result
+        job.set_result("result_name", {"key": "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")
+
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Authorization": f"Token {self._api_token}",
+                "Content-Type": "application/json",
+            }
+        )
+
+    def get_context(self) -> dict:
+        """
+        Retrieves the context of the current job, which contains necessary information
+        for job execution. The context can be fetched from two sources based on the
+        environment configuration:
+
+        1. A local file specified by the `AUTOMIZOR_CONTEXT_FILE` environment variable.
+        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.
+
+        Returns:
+            A dictionary containing the job 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_result(self, name: str, value: JSON):
+        """
+        Saves the result of the job execution to a local JSON file (`output/result.json`).
+        The `Automizor Agent` uploads this file to the `Automizor Platform` after the job.
+
+        The result is stored as a key-value pair within the JSON file, where the key is the
+        name of the result and the value is the result itself. If the file already exists,
+        this method updates the file with the new result, merging it with any existing data.
+        If the file does not exist, it is created.
+
+        Parameters:
+            name: The name of the result, used as a key in the JSON file.
+            value: The result value, must be JSON serializable.
+
+        Note:
+            This method does not handle exceptions related to file access or JSON serialization
+            internally. It is the caller's responsibility to handle such exceptions as needed.
+        """
+
+        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 = self.session.get(url, 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/__init__.py

@@ -0,0 +1,81 @@
+from functools import lru_cache
+
+from ._exceptions import AutomizorStorageError
+from ._storage import JSON
+
+
+@lru_cache
+def _get_storage():
+    from ._storage import Storage
+
+    return Storage()
+
+
+def get_bytes(name: str) -> bytes:
+    """
+    Retrieves the specified asset as raw bytes.
+
+    Parameters:
+        name: The name identifier of the asset to retrieve.
+
+    Returns:
+        The raw byte content of the asset.
+    """
+
+    storage = _get_storage()
+    return storage.get_bytes(name)
+
+
+def get_file(name: str, path: str) -> str:
+    """
+    Downloads the specified asset and saves it to a file.
+
+    Parameters:
+        name: The name identifier of the asset to retrieve.
+        path: The filesystem path where the file will be saved.
+
+    Returns:
+        The path to the saved file, confirming the operation's success.
+    """
+
+    storage = _get_storage()
+    return storage.get_file(name, path)
+
+
+def get_json(name: str) -> JSON:
+    """
+    Retrieves the specified asset and parses it as JSON.
+
+    Parameters:
+        name: The name identifier of the asset to retrieve.
+
+    Returns:
+        The parsed JSON data, which can be a dict, list, or primitive data type.
+    """
+
+    storage = _get_storage()
+    return storage.get_json(name)
+
+
+def get_text(name: str) -> str:
+    """
+    Retrieves the specified asset as a text string.
+
+    Parameters:
+        name: The name identifier of the asset to retrieve.
+
+    Returns:
+        The content of the asset as a text string.
+    """
+
+    storage = _get_storage()
+    return storage.get_text(name)
+
+
+__all__ = [
+    "AutomizorStorageError",
+    "get_bytes",
+    "get_file",
+    "get_json",
+    "get_text",
+]

automizor/storage/_exceptions.py

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

automizor/storage/_storage.py

@@ -0,0 +1,165 @@
+import os
+from typing import Dict, List, Union
+
+import requests
+
+from ._exceptions import AutomizorStorageError
+
+JSON = Union[str, int, float, bool, None, Dict[str, "JSON"], List["JSON"]]
+
+
+class Storage:
+    """
+    `Storage` is a class designed to interact with the `Automizor Platform` for managing
+    digital assets, facilitating the retrieval of files in various formats such as bytes,
+    files, JSON, and text. It leverages the `Automizor Storage API` to access and download
+    these assets securely.
+
+    This class utilizes environment variables for configuration, specifically for setting
+    up the API host and API token, which are essential for authenticating requests made
+    to the `Automizor Storage API`. These variables are typically configured by the
+    `Automizor Agent`.
+
+    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.
+
+    Example usage:
+
+    .. code-block:: python
+
+        from automizor import storage
+
+        # To get bytes of an asset
+        bytes_data = storage.get_bytes("asset_name")
+
+        # To save an asset to a file
+        file_path = storage.get_file("asset_name", "/path/to/save/file")
+
+        # To retrieve an asset as JSON
+        json_data = storage.get_json("asset_name")
+
+        # To get the text content of an asset
+        text_data = storage.get_text("asset_name")
+    """
+
+    def __init__(self):
+        self._api_host = os.getenv("AUTOMIZOR_API_HOST")
+        self._api_token = os.getenv("AUTOMIZOR_API_TOKEN")
+
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Authorization": f"Token {self._api_token}",
+                "Content-Type": "application/json",
+            }
+        )
+
+    def get_bytes(self, name: str) -> bytes:
+        """
+        Retrieves the specified asset as raw bytes.
+
+        This function fetches the asset identified by `name` from the storage service
+        and returns it as a byte stream. It is useful for binary files or for data
+        that is intended to be processed or stored in its raw form.
+
+        Parameters:
+            name: The name identifier of the asset to retrieve.
+
+        Returns:
+            The raw byte content of the asset.
+        """
+
+        url = self._get_asset_url(name)
+        return self._download_file(url, mode="content")
+
+    def get_file(self, name: str, path: str) -> str:
+        """
+        Downloads the specified asset and saves it to a file.
+
+        This function fetches the asset identified by `name` and saves it directly
+        to the filesystem at the location specified by `path`. It is useful for
+        downloading files that need to be preserved in the file system, such as
+        documents, images, or other files.
+
+        Parameters:
+            name: The name identifier of the asset to retrieve.
+            path: The filesystem path where the file will be saved.
+
+        Returns:
+            The path to the saved file, confirming the operation's success.
+        """
+
+        url = self._get_asset_url(name)
+        content = self._download_file(url, mode="content")
+        with open(path, "wb") as file:
+            file.write(content)
+        return path
+
+    def get_json(self, name: str) -> JSON:
+        """
+        Retrieves the specified asset and parses it as JSON.
+
+        This function fetches the asset identified by `name` from the storage service
+        and parses it as JSON. It is useful for assets stored in JSON format, allowing
+        for easy access and manipulation of structured data.
+
+        Parameters:
+            name: The name identifier of the asset to retrieve.
+
+        Returns:
+            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")
+
+    def get_text(self, name: str) -> str:
+        """
+        Retrieves the specified asset as a text string.
+
+        This function fetches the asset identified by `name` from the storage service
+        and returns it as a text string. It is useful for text-based files, such as
+        configuration files, CSVs, or plain text documents.
+
+        Parameters:
+            name: The name identifier of the asset to retrieve.
+
+        Returns:
+            The content of the asset as a text string.
+        """
+
+        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.raise_for_status()
+
+            match mode:
+                case "content":
+                    return response.content
+                case "json":
+                    return response.json()
+                case "text":
+                    return response.text
+            raise RuntimeError(f"Invalid mode {mode}")
+        except Exception as exc:
+            raise AutomizorStorageError(f"Failed to download asset: {exc}") from exc
+
+    def _get_asset_url(self, name: str) -> str:
+        url = f"https://{self._api_host}/api/v1/storage/asset/{name}/"
+        try:
+            response = self.session.get(url, timeout=10)
+            response.raise_for_status()
+
+            url = response.json().get("file")
+            if url:
+                return url
+            raise RuntimeError("Url not found")
+        except Exception as exc:
+            raise AutomizorStorageError(f"Failed to get asset url: {exc}") from exc

automizor/vault/__init__.py

@@ -0,0 +1,57 @@
+from functools import lru_cache
+
+from ._container import SecretContainer
+from ._exceptions import AutomizorVaultError
+
+
+@lru_cache
+def _get_vault():
+    from ._vault import Vault
+
+    return Vault()
+
+
+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.
+
+    Args:
+        name: The name of the secret to retrieve.
+
+    Returns:
+        The retrieved secret.
+
+    Raises:
+        AutomizorVaultError: If retrieving the secret fails.
+    """
+
+    vault = _get_vault()
+    return vault.get_secret(name)
+
+
+def set_secret(secret: SecretContainer) -> SecretContainer:
+    """
+    Updates an existing secret. Updates to a local file or to the
+    `Automizor API`, based on configuration.
+
+    Args:
+        secret: The secret to update.
+
+    Returns:
+        The updated secret.
+
+    Raises:
+        AutomizorVaultError: If updating the secret fails.
+    """
+
+    vault = _get_vault()
+    return vault.set_secret(secret)
+
+
+__all__ = [
+    "AutomizorVaultError",
+    "SecretContainer",
+    "get_secret",
+    "set_secret",
+]

automizor/vault/_container.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass, fields
+
+
+def ignore_extra_fields(cls):
+    original_post_init = getattr(cls, "__post_init__", None)
+
+    def __init__(self, **kwargs):
+        cls_fields = {field.name: field for field in fields(cls)}
+        for name, value in kwargs.items():
+            if name in cls_fields:
+                setattr(self, name, value)
+        if original_post_init:
+            original_post_init(self)
+
+    setattr(cls, "__init__", __init__)
+    return cls
+
+
+@ignore_extra_fields
+@dataclass
+class SecretContainer:
+    """
+    Represents a secret, comprising a name and its associated values.
+
+    Attributes:
+        description: A description of the secret.
+        name: The name of the secret.
+        value: The secret's values, stored in a dictionary as key-value pairs.
+    """
+
+    name: str
+    value: dict
+    description: str = ""
+
+    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 keys(self):
+        """Secret.keys() -> a set-like object providing a view on secret's keys."""
+        return self.value.keys()
+
+    def update(self, pairs: dict) -> None:
+        """Update the secret's dictionary with the key-value pairs from pairs."""
+        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.keys())
+        return f"Secret(name={self.name}, keys=[{keys}])"

automizor/vault/_exceptions.py

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

automizor/vault/_secret.py

@@ -0,0 +1,45 @@
+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/_vault.py

@@ -0,0 +1,139 @@
+import json
+import os
+from dataclasses import asdict
+
+import requests
+
+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.
+
+    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.
+
+    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"
+            }
+        }
+
+    Example usage:
+
+    .. code-block:: python
+
+        from automizor import vault
+
+        # Retrieve a secret by its name
+        secret = vault.get_secret("my_secret_name")
+        print(secret["key"])  # Output: "value"
+
+        # Update a existing 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")
+
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Authorization": f"Token {self._api_token}",
+                "Content-Type": "application/json",
+            }
+        )
+
+    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.
+
+        Args:
+            name: The name of the secret to retrieve.
+
+        Returns:
+            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: SecretContainer) -> SecretContainer:
+        """
+        Updates an existing secret. Updates to a local file or to the
+        `Automizor API`, based on configuration.
+
+        Args:
+            secret: The secret to update.
+
+        Returns:
+            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) -> 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 _read_vault_secret(self, name: str) -> SecretContainer:
+        url = f"https://{self._api_host}/api/v1/vault/secret/{name}/"
+        try:
+            response = self.session.get(url, timeout=10)
+            response.raise_for_status()
+            return SecretContainer(**response.json())
+        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}/"
+        try:
+            response = self.session.put(url, timeout=10, json=asdict(secret))
+            response.raise_for_status()
+            return SecretContainer(**response.json())
+        except Exception as exc:
+            raise AutomizorVaultError(f"Failed to set secret: {exc}") from exc

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

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

automizor-0.3.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+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,,

automizor-0.2.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-automizor/__init__.py,sha256=XQVhijSHeIVMVzY2S4fY9BKxV2XHSTr9VVHsYltGPvQ,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-0.2.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-automizor-0.2.0.dist-info/METADATA,sha256=aRwuipXNcIswJop_TAGjrlM4ZigW7eI8oqWIeI936vc,661
-automizor-0.2.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-automizor-0.2.0.dist-info/top_level.txt,sha256=gScDy4I3tP6BMYAsTAlBXrxVh3E00zV0UioxwXJOI3Y,10
-automizor-0.2.0.dist-info/RECORD,,