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

automizor/__init__.py

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

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.
@@ -118,17 +111,21 @@ class Job:
         data[name] = value
 
         with open(file_path, "w", encoding="utf-8") as file:
-            json.dump(data, file, ensure_ascii=False, indent=4)
+            json.dump(data, file, ensure_ascii=False)
 
     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}/"
+        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/log/__init__.py

@@ -0,0 +1,95 @@
+from functools import lru_cache
+
+from ._log import JSON
+
+
+@lru_cache
+def _get_log():
+    from ._log import Log
+
+    return Log()
+
+
+def debug(msg: JSON):
+    """
+    Writes a debug log message with a level of "DEBUG".
+
+    Parameters:
+        msg (JSON): The log message to write. This can be a string, number, boolean, dictionary,
+            list, or None.
+    """
+
+    _get_log().write_log("DEBUG", msg)
+
+
+def info(msg: JSON):
+    """
+    Writes an info log message with a level of "INFO".
+
+    Parameters:
+        msg (JSON): The log message to write. This can be a string, number, boolean, dictionary,
+            list, or None.
+    """
+
+    _get_log().write_log("INFO", msg)
+
+
+def warning(msg: JSON):
+    """
+    Writes a warning log message with a level of "WARNING".
+
+    Parameters:
+        msg (JSON): The log message to write. This can be a string, number, boolean, dictionary,
+            list, or None.
+    """
+
+    _get_log().write_log("WARNING", msg)
+
+
+def error(msg: JSON):
+    """
+    Writes an error log message with a level of "ERROR".
+
+    Parameters:
+        msg (JSON): The log message to write. This can be a string, number, boolean, dictionary,
+            list, or None.
+    """
+
+    _get_log().write_log("ERROR", msg)
+
+
+def critical(msg: JSON):
+    """
+    Writes a critical log message with a level of "CRITICAL".
+
+    Parameters:
+        msg (JSON): The log message to write. This can be a string, number, boolean, dictionary,
+            list, or None.
+    """
+
+    _get_log().write_log("CRITICAL", msg)
+
+
+def set_level(level: str):
+    """
+    Set the log level for filtering log messages.
+
+    Parameters:
+        level (str): The log level to set. Valid log levels are "DEBUG", "INFO",
+            "WARNING", "ERROR", and "CRITICAL".
+
+    Raises:
+        ValueError: If an invalid log level is provided.
+    """
+
+    _get_log().set_level(level)
+
+
+__all__ = [
+    "debug",
+    "info",
+    "warning",
+    "error",
+    "critical",
+    "set_level",
+]

automizor/log/_log.py

@@ -0,0 +1,91 @@
+import json
+import os
+from typing import Dict, List, Union
+
+LOG_LEVELS = {
+    "DEBUG": 1,
+    "INFO": 2,
+    "WARNING": 3,
+    "ERROR": 4,
+    "CRITICAL": 5,
+}
+
+JSON = Union[str, int, float, bool, None, Dict[str, "JSON"], List["JSON"]]
+
+
+class Log:
+    """
+    `Log` is a class that facilitates logging messages to a local file, which can be
+    useful for debugging and monitoring purposes. It provides a simple interface for
+    writing log messages with different levels, such as "info", "warning", "error", etc.
+
+    The log messages are stored in a JSON file, which can be easily parsed and analyzed
+    later. This class does not provide any log rotation or cleanup mechanisms, so it is
+    recommended to manage log files manually or use external log management tools.
+
+    Example usage:
+
+    .. code-block:: python
+
+        from automizor import log
+
+        # Set log level to INFO
+        log.set_level("INFO")
+
+        # Write a log message
+        log.info({"key": "value"})
+    """
+
+    def __init__(self):
+        self.level = "INFO"
+
+    def set_level(self, level: str):
+        """
+        Set the log level for filtering log messages.
+
+        Parameters:
+            level (str): The log level to set. Valid log levels are "DEBUG", "INFO",
+                "WARNING", "ERROR", and "CRITICAL".
+
+        Raises:
+            ValueError: If an invalid log level is provided.
+        """
+
+        if level not in LOG_LEVELS:
+            raise ValueError(f"Invalid log level: {level}")
+
+        self.level = level
+
+    def write_log(self, level: str, msg: JSON):
+        """
+        Write a log message with the specified log level.
+
+        Parameters:
+            level (str): The log level of the message. Valid log levels are "DEBUG", "INFO",
+                "WARNING", "ERROR", and "CRITICAL".
+            msg (JSON): The log message to write. This can be a string, number, boolean, dictionary,
+                list, or None.
+
+        Raises:
+            ValueError: If an invalid log level is provided.
+        """
+
+        if level not in LOG_LEVELS:
+            raise ValueError(f"Invalid log level: {level}")
+
+        if LOG_LEVELS[level] < LOG_LEVELS[self.level]:
+            return
+
+        data = []
+        file_path = "output/log.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.append({"level": level, "msg": msg})
+
+        with open(file_path, "w", encoding="utf-8") as file:
+            json.dump(data, file, ensure_ascii=False)

automizor/storage/__init__.py

@@ -1,6 +1,9 @@
+import json
+import mimetypes
 from functools import lru_cache
+from pathlib import Path
+from typing import List
 
-from ._exceptions import AutomizorStorageError
 from ._storage import JSON
 
 
@@ -11,6 +14,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):
+    """
+    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 +99,82 @@ def get_text(name: str) -> str:
     return storage.get_text(name)
 
 
+def set_bytes(name: str, data: bytes, content_type="application/octet-stream"):
+    """
+    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):
+    """
+    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):
+    """
+    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):
+    """
+    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",
 ]