octostar-python-client 0.1.759__py3-none-any.whl

octostar/utils/jobs/apps/execute_app_job.py

@@ -0,0 +1,114 @@
+import os
+import logging
+import yaml
+from typing import Optional, Union
+
+_logger = logging.getLogger(__name__)
+
+from ....api.apps import execute_app_job
+from ....models.execute_app_job_json_body import ExecuteAppJobJsonBody
+from ....models.execute_app_job_json_body_annotation import (
+    ExecuteAppJobJsonBodyAnnotation,
+)
+from ....client import Client
+from ...exceptions import ApiConnectionError
+
+
+def sync(
+    commands: str,
+    zip_archive_link: Optional[str] = os.getenv("OS_SELF_ARCHIVE"),
+    manifest: Optional[Union[dict, str]] = None,
+    annotations: Optional[dict[str, str]] = None,
+    client: Client = None,
+):
+    """
+    # Start a new job
+
+    ## Arguments
+
+    - `commands`: The bash commands to execute in the new job.
+    - `zip_archive_link`: A URL to a zip archive containing a valid app. Note that the app will not execute through `main.sh` but via the provided commands.
+    - `manifest`: A manifest file, either as a dictionary parsable as YAML or as a raw YAML string.
+            Note that `app_name`, `alias` and `app_title` are always inherited from the parent and cannot be overridden by this manifest.
+    - `annotations`: A list of key-value strings to be appended to the kubernetes pod.
+            Keys must start with 'app.octostar.com/'. Example: {'app.octostar.com/author': 'John Doe'}
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+
+    An acknowledgment.
+
+    ## Raises
+
+    - `ApiConnectionError`: If the operation was unsuccessful on the server.
+    """
+    if not annotations:
+        annotations = {}
+    if not manifest:
+        manifest = None
+    if manifest and isinstance(manifest, dict):
+        manifest = yaml.dump(manifest)
+    response = execute_app_job.sync_detailed(
+        json_body=ExecuteAppJobJsonBody(
+            ontology=client.ontology,
+            archive=zip_archive_link,
+            commands=commands,
+            manifest=manifest,
+            annotation=ExecuteAppJobJsonBodyAnnotation(**annotations),
+            ancestor=os.getenv("OS_ANCESTOR") or os.getenv("OS_APP_ID"),
+        ),
+        client=client,
+    )
+    if response.status_code != 200:
+        raise ApiConnectionError("execute_app_job", response, client)
+    return response.parsed
+
+
+async def asyncio(
+    commands: str,
+    zip_archive_link: Optional[str] = os.getenv("OS_SELF_ARCHIVE"),
+    manifest: Optional[Union[dict, str]] = None,
+    annotations: Optional[dict[str, str]] = None,
+    client: Client = None,
+):
+    """
+    # Start a new job asynchronously
+
+    ## Arguments
+
+    - `commands`: The bash commands to execute in the new job.
+    - `zip_archive_link`: A URL to a zip archive containing a valid app. Note that the app will not execute through `main.sh` but via the provided commands.
+    - `manifest`: A manifest file, either as a dictionary parsable as YAML or as a raw YAML string.
+            Note that `app_name`, `alias` and `app_title` are always inherited from the parent and cannot be overridden by this manifest.
+    - `annotations`: A list of key-value strings to be appended to the kubernetes pod.
+            Keys must start with 'app.octostar.com/'. Example: {'app.octostar.com/author': 'John Doe'}
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+
+    An acknowledgment.
+
+    ## Raises
+
+    - `ApiConnectionError`: If the operation was unsuccessful on the server.
+    """
+    if not annotations:
+        annotations = {}
+    if not manifest:
+        manifest = None
+    if manifest and isinstance(manifest, dict):
+        manifest = yaml.dump(manifest)
+    response = await execute_app_job.asyncio_detailed(
+        json_body=ExecuteAppJobJsonBody(
+            ontology=client.ontology,
+            archive=zip_archive_link,
+            commands=commands,
+            manifest=manifest,
+            annotation=ExecuteAppJobJsonBodyAnnotation(**annotations),
+            ancestor=os.getenv("OS_ANCESTOR") or os.getenv("OS_APP_ID"),
+        ),
+        client=client,
+    )
+    if response.status_code != 200:
+        raise ApiConnectionError("execute_app_job", response, client)
+    return response.parsed

octostar/utils/jobs/apps/get_app_logs.py

@@ -0,0 +1,113 @@
+import os
+import logging
+import re
+
+_logger = logging.getLogger(__name__)
+
+from ....api.apps import get_app_logs
+from ....client import Client
+from ...exceptions import ApiConnectionError
+
+
+def sync(
+    app_id: str = os.getenv("OS_APP_ID"),
+    since_seconds: int = None,
+    tail_lines: int = None,
+    client: Client = None,
+):
+    """
+    # Get App Logs
+
+    Retrieves the logs of a running app given its ID.
+
+    ## Arguments
+    - `app_id`: The running app ID.
+    - `since_seconds`: The maximum amount of seconds prior to now to get logs for.
+    - `tail_lines`: The maximum amount of log lines to retrieve.
+
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+    An UTF-8 string with the app logs.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    response = get_app_logs.sync_detailed(
+        app_id=app_id,
+        since_seconds=since_seconds,
+        tail_lines=tail_lines,
+        client=client,
+    )
+    if response.status_code != 200:
+        raise ApiConnectionError("get_app_logs", response, client)
+    logs = response.content
+    try:
+        escaped_logs = logs.decode("utf-8", "replace")
+        escaped_logs = re.sub(
+            r"\\.",
+            lambda x: {
+                "\\n": "\n",
+                "\\t": "\t",
+                "\\r": "\r",
+                '\\"': '"',
+                "\\'": "'",
+            }.get(x[0], x[0]),
+            escaped_logs,
+        )
+        return escaped_logs
+    except Exception:
+        _logger.warning("Could not decode logs! Returning raw bytes")
+        return logs
+
+
+async def asyncio(
+    app_id: str = os.getenv("OS_APP_ID"),
+    since_seconds: int = None,
+    tail_lines: int = None,
+    client: Client = None,
+):
+    """
+    # Get App Logs Asynchronously
+
+    Asynchronously retrieves the logs of a running app/job given its ID.
+
+    ## Arguments
+    - `app_id`: The running app ID.
+    - `since_seconds`: The maximum amount of seconds prior to now to get logs for.
+    - `tail_lines`: The maximum amount of log lines to retrieve.
+
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+    An UTF-8 string with the app logs.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    response = await get_app_logs.asyncio_detailed(
+        app_id=app_id,
+        since_seconds=since_seconds,
+        tail_lines=tail_lines,
+        client=client,
+    )
+    if response.status_code != 200:
+        raise ApiConnectionError("get_app_logs", response, client)
+    logs = response.content
+    try:
+        escaped_logs = logs.decode("utf-8", "replace")
+        escaped_logs = re.sub(
+            r"\\.",
+            lambda x: {
+                "\\n": "\n",
+                "\\t": "\t",
+                "\\r": "\r",
+                '\\"': '"',
+                "\\'": "'",
+            }.get(x[0], x[0]),
+            escaped_logs,
+        )
+        return escaped_logs
+    except Exception:
+        _logger.warning("Could not decode logs! Returning raw bytes")
+        return logs

octostar/utils/jobs/apps/get_app_secret.py

@@ -0,0 +1,102 @@
+import os
+from warnings import warn
+from dotenv import get_key, find_dotenv, load_dotenv
+from ....client import Client
+
+
+def sync(key: str, client: Client = None) -> str:
+    """
+    # Reads an application secret value
+
+    Retrieves the value of an application secret based on the provided key.
+
+    ## Arguments
+
+    - `key`: The key for the application secret.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+
+    The corresponding secret value.
+
+    ## Raises
+
+    - `ValueError`: If the key is not valid.
+    - `RuntimeError`: If the secrets file could not be read.
+
+    ## Example
+
+    ```python
+    secret_value = sync("my_secret_key")
+    print(secret_value)
+    ```
+    """
+    if not key or not isinstance(key, str):
+        raise ValueError("key must be a non-empty string")
+    if not key.strip():
+        raise ValueError("key must be non-empty")
+
+    sanitized_key = (
+        key.replace("/", "_").replace(".", "_").replace("-", "_").replace(" ", "_")
+    )
+
+    if f"{os.getenv('OS_DEV_MODE')}".lower() == "true":
+        if not os.getenv(sanitized_key):
+            dotenv_value = get_key(find_dotenv(usecwd=True), sanitized_key)
+            if dotenv_value is not None:
+                os.environ[sanitized_key] = dotenv_value
+                warn(
+                    "Loading secret from .env file. This is fine for development but not for production!",
+                    stacklevel=2,
+                )
+        if os.getenv(sanitized_key) is not None:
+            warn(
+                f"App secret {sanitized_key} has been loaded in plaintext from environment variables. This is fine for development but it should not happen in production!",
+                Warning,
+                stacklevel=2,
+            )
+            return os.environ[sanitized_key]
+
+    path = "/etc/secrets/" + sanitized_key
+
+    if not os.path.isfile(path):
+        raise RuntimeError(f"Secret file not found at {path}")
+
+    try:
+        with open(path, "r") as file:
+            line = file.readline()
+            if not line:
+                raise ValueError(f"Secret file {path} is empty")
+            return line.strip()
+    except Exception as e:
+        raise RuntimeError(f"Error reading secret file {path}: {e}")
+
+
+async def asyncio(key: str, client: Client = None) -> str:
+    """
+    # Reads an application secret value asynchronously
+
+    Retrieves the value of an application secret based on the provided key asynchronously.
+
+    ## Arguments
+
+    - `key`: The key for the application secret.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+
+    The corresponding secret value.
+
+    ## Raises
+
+    - `ValueError`: If the key is not valid.
+    - `RuntimeError`: If the secrets file could not be read.
+
+    ## Example
+
+    ```python
+    secret_value = await asyncio("my_secret_key")
+    print(secret_value)
+    ```
+    """
+    return sync(key, client)

octostar/utils/jobs/apps/get_apps_url.py

@@ -0,0 +1,73 @@
+import logging
+from typing import Union
+
+_logger = logging.getLogger(__name__)
+
+from ....api.apps import get_apps_url
+from ....models.get_apps_url_json_body import GetAppsUrlJsonBody
+from ....client import Client
+from ...exceptions import ApiConnectionError
+
+
+def sync(app_id: Union[str, list[str]], client: Client = None):
+    """
+    # Get App URL
+
+    Get the app URL for a app ID.
+
+    ## Arguments
+    - `app_id`: The ID of the app. Can also be a list of such IDs.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+    One or a list of app urls.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    as_list = True
+    if not isinstance(app_id, list):
+        app_id = [app_id]
+        as_list = False
+    response = get_apps_url.sync_detailed(
+        json_body=GetAppsUrlJsonBody(app_id), client=client
+    )
+    if response.status_code != 200:
+        raise ApiConnectionError("get_apps_url", response, client)
+    content = response.parsed
+    content = [app.app_url for app in content]
+    if not as_list:
+        content = content[0]
+    return content
+
+
+async def asyncio(app_id: Union[str, list[str]], client: Client = None):
+    """
+    # Get App URL Asynchronously
+
+    Get asynchronously the app URL for a app ID.
+
+    ## Arguments
+    - `app_id`: The ID of the app. Can also be a list of such IDs.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+    One or a list of app urls.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    as_list = True
+    if not isinstance(app_id, list):
+        app_id = [app_id]
+        as_list = False
+    response = await get_apps_url.asyncio_detailed(
+        json_body=GetAppsUrlJsonBody(app_id), client=client
+    )
+    if response.status_code != 200:
+        raise ApiConnectionError("get_apps_url", response, client)
+    content = response.parsed
+    content = [app.app_url for app in content]
+    if not as_list:
+        content = content[0]
+    return content

octostar/utils/jobs/apps/list_app_jobs.py

@@ -0,0 +1,62 @@
+import os
+import logging
+
+_logger = logging.getLogger(__name__)
+
+from ....api.apps import list_app_jobs
+from ....client import Client
+from ...exceptions import ApiConnectionError
+
+
+def sync(app_id: str = os.getenv("OS_APP_ID"), client: Client = None):
+    """
+    # List App Children
+
+    List the jobs spawned by a app.
+
+    ## Arguments
+    - `app_id`: The running app ID.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+    A list of jobs, each containing their full info. Note the full info does not contain the job URL,
+    use `get_job_url()` to retrieve it.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    response = list_app_jobs.sync_detailed(app_id=app_id, client=client)
+    if response.status_code != 200:
+        raise ApiConnectionError("list_app_jobs", response, client)
+    content = response.parsed
+    content = list(filter(lambda x: x.name != app_id, content))
+    for elem in content:
+        elem.labels = elem.labels.additional_properties
+    return content
+
+
+async def asyncio(app_id: str = os.getenv("OS_APP_ID"), client: Client = None):
+    """
+    # List App Children Asynchronously
+
+    List asynchronously the jobs spawned by a app.
+
+    ## Arguments
+    - `app_id`: The running app ID.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+    A list of jobs, each containing their full info. Note the full info does not contain the job URL,
+    use `get_job_url()` to retrieve it.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    response = await list_app_jobs.asyncio_detailed(app_id=app_id, client=client)
+    if response.status_code != 200:
+        raise ApiConnectionError("list_app_jobs", response, client)
+    content = response.parsed
+    content = list(filter(lambda x: x.name != app_id, content))
+    for elem in content:
+        elem.labels = elem.labels.additional_properties
+    return content

octostar/utils/jobs/apps/list_apps.py

@@ -0,0 +1,126 @@
+import logging
+from typing import Optional
+import httpx
+from httpx import QueryParams
+
+_logger = logging.getLogger(__name__)
+
+from ....client import Client
+from ...exceptions import ApiConnectionError
+from ...commons import network_retry_strategy
+
+
+def sync(
+    workspaces: Optional[list[str]] = None,
+    include_all: bool = False,
+    main_namespace_only: bool = False,
+    client: Client = None,
+):
+    """
+    # List Apps
+
+    List all of the apps running in Octostar.
+
+    ## Arguments
+    - `workspaces`: The list of workspace IDs by which to filter apps. If None, all workspaces are searched.
+    - `include_all`: If False, only running apps are returned. If True, undeployed apps are also returned.
+    - `main_namespace_only`: If True, running apps will only be searched in the main kubernetes namespace.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+    A list of apps, each containing their full info.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    endpoint_url = f"{client.get_base_url_v1()}/api/v1/apps/"
+    headers = {
+        "Authorization": f"Bearer {client.token}",
+        "x-ontology": client.ontology,
+    }
+    if not workspaces:
+        workspaces = []
+    query_params = QueryParams(
+        [
+            *[("workspaces", ws) for ws in workspaces],
+            ("include_all", include_all),
+            ("main_namespace_only", main_namespace_only),
+        ]
+    )
+    response = None
+    try:
+        for attempt in network_retry_strategy():
+            with attempt:
+                with httpx.Client() as httpx_client:
+                    response = httpx_client.get(
+                        endpoint_url, headers=headers, params=query_params, timeout=30
+                    )
+                    response.raise_for_status()
+                    try:
+                        parsed = response.json()
+                    except ValueError:
+                        raise ConnectionError(
+                            "Could not fetch data from API (failed to parse response), responded with\n"
+                            + str(response.content)
+                        )
+    except Exception:
+        raise ApiConnectionError("list_apps", response, client)
+    return parsed["apps"]
+
+
+async def asyncio(
+    workspaces: Optional[list[str]] = None,
+    include_all: bool = False,
+    main_namespace_only: bool = False,
+    client: Client = None,
+):
+    """
+    # List Apps
+
+    List asynchronously all of the apps running in Octostar.
+
+    ## Arguments
+    - `workspaces`: The list of workspace IDs by which to filter apps. If None, all workspaces are searched.
+    - `include_all`: If False, only running apps are returned. If True, undeployed apps are also returned.
+    - `main_namespace_only`: If True, running apps will only be searched in the main kubernetes namespace.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Returns
+    A list of apps, each containing their full info.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    endpoint_url = f"{client.get_base_url_v1()}/api/v1/apps/"
+    headers = {
+        "Authorization": f"Bearer {client.token}",
+        "x-ontology": client.ontology,
+    }
+    if not workspaces:
+        workspaces = []
+    query_params = QueryParams(
+        [
+            *[("workspaces", ws) for ws in workspaces],
+            ("include_all", include_all),
+            ("main_namespace_only", main_namespace_only),
+        ]
+    )
+    response = None
+    try:
+        for attempt in network_retry_strategy():
+            with attempt:
+                async with httpx.AsyncClient() as httpx_client:
+                    response = await httpx_client.get(
+                        endpoint_url, headers=headers, params=query_params, timeout=30
+                    )
+                    response.raise_for_status()
+                    try:
+                        parsed = response.json()
+                    except ValueError:
+                        raise ConnectionError(
+                            "Could not fetch data from API (failed to parse response), responded with\n"
+                            + str(response.content)
+                        )
+    except Exception:
+        raise ApiConnectionError("list_apps", response, client)
+    return parsed["apps"]

octostar/utils/jobs/apps/undeploy_app.py

@@ -0,0 +1,48 @@
+import os
+import logging
+
+_logger = logging.getLogger(__name__)
+
+from ....api.apps import undeploy_app
+from ....client import Client
+from ...exceptions import ApiConnectionError
+
+
+def sync(
+    app_id: str = os.getenv("OS_APP_ID"),
+    client: Client = None,
+):
+    """
+    # Undeploys an App.
+
+    ## Arguments
+    - `app_id`: The ID of the app to undeploy.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    response = undeploy_app.sync_detailed(app_id=app_id, client=client)
+    if response.status_code != 200:
+        raise ApiConnectionError("undeploy_app", response, client)
+    return response.parsed
+
+
+async def asyncio(
+    app_id: str = os.getenv("OS_APP_ID"),
+    client: Client = None,
+):
+    """
+    # Undeploys an App.
+
+    ## Arguments
+    - `app_id`: The ID of the app to undeploy.
+    - `client`: The Client with which to connect to Octostar. If None, the default one is used.
+
+    ## Raises
+    - `ApiConnectionError`: If the request was unsuccessful on the server.
+    """
+    response = await undeploy_app.asyncio_detailed(app_id=app_id, client=client)
+    if response.status_code != 200:
+        raise ApiConnectionError("undeploy_app", response, client)
+    return response.parsed