intuned-runtime 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

intuned_cli/__init__.py

@@ -0,0 +1,40 @@
+import sys
+
+import arguably
+from dotenv import find_dotenv
+from dotenv import load_dotenv
+
+from intuned_cli.utils.console import console
+from intuned_cli.utils.error import CLIError
+from intuned_cli.utils.error import log_automation_error
+from runtime.context.context import IntunedContext
+from runtime.errors.run_api_errors import AutomationError
+
+from . import commands
+
+
+def run():
+    dotenv = find_dotenv(usecwd=True)
+    if dotenv:
+        load_dotenv(dotenv, override=True)
+    try:
+        with IntunedContext():
+            arguably.run(name="intuned")
+            sys.exit(0)
+    except CLIError as e:
+        if e.auto_color:
+            console.print(f"[bold red]{e.message}[/bold red]")
+        else:
+            console.print(e.message)
+    except AutomationError as e:
+        log_automation_error(e)
+    except KeyboardInterrupt:
+        console.print("[bold red]Aborted[/bold red]")
+    except Exception as e:
+        console.print(
+            f"[red][bold]An error occurred: [/bold]{e}\n[bold]Please report this issue to the Intuned team.[/bold]"
+        )
+    sys.exit(1)
+
+
+__all__ = ["commands", "run"]

intuned_cli/commands/__init__.py

@@ -0,0 +1,18 @@
+from .attempt_api_command import attempt__api as attempt__api  # type: ignore
+from .attempt_authsession_check_command import (
+    attempt__authsession__check as attempt__authsession__check,  # type: ignore
+)
+from .attempt_authsession_command import attempt__authsession as attempt__authsession  # type: ignore
+from .attempt_authsession_create_command import (
+    attempt__authsession__create as attempt__authsession__create,  # type: ignore
+)
+from .attempt_command import attempt as attempt  # type: ignore
+from .command import __root__ as __root__  # type: ignore
+from .deploy_command import deploy as deploy  # type: ignore
+from .init_command import init as init  # type: ignore
+from .run_api_command import run__api as run__api  # type: ignore
+from .run_authsession_command import run__authsession as run__authsession  # type: ignore
+from .run_authsession_create_command import run__authsession__create as run__authsession__create  # type: ignore
+from .run_authsession_update_command import run__authsession__update as run__authsession__update  # type: ignore
+from .run_authsession_validate_command import run__authsession__validate as run__authsession__validate  # type: ignore
+from .run_command import run as run  # type: ignore

intuned_cli/commands/attempt_api_command.py

@@ -0,0 +1,51 @@
+import arguably
+import pytimeparse  # type: ignore
+
+from intuned_cli.controller.api import execute_attempt_api_cli
+from intuned_cli.utils.auth_session_helpers import assert_auth_consistent
+from intuned_cli.utils.auth_session_helpers import load_parameters
+
+
+@arguably.command  # type: ignore
+async def attempt__api(
+    api_name: str,
+    parameters: str,
+    /,
+    *,
+    auth_session: str | None = None,
+    proxy: str | None = None,
+    timeout: str = "10 min",
+    headless: bool = False,
+    output_file: str | None = None,
+):
+    """Executes an Intuned API attempt with parameters
+
+    Args:
+        api_name (str): Name of the API.
+        parameters (str): Path to JSON file containing API parameters or the parameters as a JSON string.
+        auth_session (str | None, optional): [-a/--auth-session]. ID of the auth session to use for the API. This is expected to be in ./auth-session-instances/<id>
+        proxy (str | None, optional): [--proxy]. Proxy URL to use. Defaults to None.
+        timeout (str, optional): [--timeout]. Timeout - milliseconds or pytimeparse-formatted string. Defaults to "10 min".
+        headless (bool, optional): [--headless]. Run the API in headless mode (default: False). This will not open a browser window.
+        output_file (str | None, optional): [-o/--output-file]. Output file path. Defaults to None.
+    """
+
+    await assert_auth_consistent(auth_session)
+
+    input_data = await load_parameters(parameters)
+
+    timeout_value = pytimeparse.parse(timeout)  # type: ignore
+    if timeout_value is None:
+        raise ValueError(
+            f"Invalid timeout format: {timeout}. Please use a valid time format like '10 min' or '600 seconds'."
+        )
+
+    await execute_attempt_api_cli(
+        api_name=api_name,
+        input_data=input_data,
+        proxy=proxy,
+        auth_session_id=auth_session,
+        timeout=timeout_value,
+        headless=headless,
+        output_file=output_file,
+    )

intuned_cli/commands/attempt_authsession_check_command.py

@@ -0,0 +1,38 @@
+import arguably
+import pytimeparse  # type: ignore
+
+from intuned_cli.controller.authsession import execute_attempt_check_auth_session_cli
+from intuned_cli.utils.auth_session_helpers import assert_auth_enabled
+
+
+@arguably.command  # type: ignore
+async def attempt__authsession__check(
+    id: str,
+    /,
+    *,
+    proxy: str | None = None,
+    timeout: str = "10 min",
+    headless: bool = False,
+):
+    """Check an existing auth session
+
+    Args:
+        id (str): ID of the auth session to check
+        proxy (str | None, optional): [--proxy]. Proxy URL to use for the auth session command. Defaults to None.
+        timeout (str, optional): [--timeout]. Timeout for the auth session command - milliseconds or pytimeparse-formatted string. Defaults to "10 min".
+        headless (bool, optional): [--headless]. Run the API in headless mode (default: False). This will not open a browser window.
+    """
+    await assert_auth_enabled()
+
+    timeout_value = pytimeparse.parse(timeout)  # type: ignore
+    if timeout_value is None:
+        raise ValueError(
+            f"Invalid timeout format: {timeout}. Please use a valid time format like '10 min' or '600 seconds'."
+        )
+
+    await execute_attempt_check_auth_session_cli(
+        id=id,
+        headless=headless,
+        timeout=timeout_value,
+        proxy=proxy,
+    )

intuned_cli/commands/attempt_authsession_command.py

@@ -0,0 +1,12 @@
+import arguably
+
+from intuned_cli.utils.console import console
+
+
+@arguably.command  # type: ignore
+async def attempt__authsession():
+    """Execute san Intuned authsession attempt"""
+
+    if arguably.is_target():
+        console.print(" (-h/--help) for usage")
+        exit(1)

intuned_cli/commands/attempt_authsession_create_command.py

@@ -0,0 +1,44 @@
+import arguably
+import pytimeparse  # type: ignore
+
+from intuned_cli.controller.authsession import execute_attempt_create_auth_session_cli
+from intuned_cli.utils.auth_session_helpers import assert_auth_enabled
+from intuned_cli.utils.auth_session_helpers import load_parameters
+
+
+@arguably.command  # type: ignore
+async def attempt__authsession__create(
+    parameters: str,
+    /,
+    *,
+    id: str | None = None,
+    proxy: str | None = None,
+    timeout: str = "10 min",
+    headless: bool = False,
+):
+    """Create a new auth session
+
+    Args:
+        parameters (str): Parameters for the auth session command
+        id (str | None, optional): [--id]. ID of the auth session to use for the command. Defaults to ./auth-session-instances/[current timestamp].json.
+        proxy (str | None, optional): [--proxy]. Proxy URL to use for the auth session command. Defaults to None.
+        timeout (str, optional): [--timeout]. Timeout for the auth session command - milliseconds or pytimeparse-formatted string. Defaults to "10 min".
+        headless (bool, optional): [--headless]. Run the API in headless mode (default: False). This will not open a browser window.
+    """
+    await assert_auth_enabled()
+
+    auth_session_input = await load_parameters(parameters) or {}
+
+    timeout_value = pytimeparse.parse(timeout)  # type: ignore
+    if timeout_value is None:
+        raise ValueError(
+            f"Invalid timeout format: {timeout}. Please use a valid time format like '10 min' or '600 seconds'."
+        )
+
+    await execute_attempt_create_auth_session_cli(
+        id=id,
+        input_data=auth_session_input,
+        headless=headless,
+        timeout=timeout_value,
+        proxy=proxy,
+    )

intuned_cli/commands/attempt_command.py

@@ -0,0 +1,12 @@
+import arguably
+
+from intuned_cli.utils.console import console
+
+
+@arguably.command  # type: ignore
+async def attempt():
+    """Executes an Intuned attempt."""
+
+    if arguably.is_target():
+        console.print(" (-h/--help) for usage")
+        exit(1)

intuned_cli/commands/command.py

@@ -0,0 +1,26 @@
+import arguably
+
+from intuned_cli.utils.console import console
+
+
+@arguably.command  # type: ignore
+async def __root__(
+    *,
+    version: bool = False,
+):
+    """Intuned CLI to initialize, develop and deploy Intuned projects.
+
+    This command is the entry point for the Intuned CLI. It provides various subcommands
+    for managing Intuned projects, including initialization, development, and deployment.
+
+    Args:
+        version (bool, optional): [-v/--version] Show version information. Defaults to False.
+    """
+
+    if version:
+        console.print("1.0.0")  # todo: better version handling
+        exit(0)
+
+    if arguably.is_target() and not version:
+        console.print(" (-h/--help) for usage")
+        exit(1)

intuned_cli/commands/deploy_command.py

@@ -0,0 +1,47 @@
+import arguably
+
+from intuned_cli.controller.deploy import deploy_project
+from intuned_cli.controller.deploy import get_intuned_api_auth_credentials
+from intuned_cli.controller.deploy import validate_intuned_project
+from intuned_cli.controller.deploy import validate_project_name
+from intuned_cli.utils.error import CLIError
+
+
+@arguably.command  # type: ignore
+async def deploy(
+    project_name: str | None = None,
+    /,
+    *,
+    workspace_id: str | None = None,
+    api_key: str | None = None,
+):
+    """Deploys the application.
+
+    Args:
+        project_name (str | None, optional): The name of the project to deploy.
+        workspace_id (str | None, optional): The ID of the workspace to deploy to.
+        api_key (str | None, optional): The API key to use for authentication.
+    """
+    try:
+        intuned_json = await validate_intuned_project()
+    except CLIError as e:
+        raise CLIError(
+            f"[bold red]Project to be deployed is not a valid Intuned project:[/bold red][bright_red] {e}[/bright_red]\n",
+            auto_color=False,
+        ) from e
+
+    project_name = project_name or intuned_json.project_name
+    if not project_name:
+        raise CLIError("Project name is required")
+
+    validate_project_name(project_name)
+
+    workspace_id, api_key = await get_intuned_api_auth_credentials(
+        intuned_json=intuned_json, workspace_id=workspace_id, api_key=api_key
+    )
+
+    await deploy_project(
+        project_name=project_name,
+        workspace_id=workspace_id,
+        api_key=api_key,
+    )

intuned_cli/commands/init_command.py

@@ -0,0 +1,21 @@
+import arguably
+
+from intuned_cli.controller.init import check_empty_directory
+from intuned_cli.controller.init import python_template_name
+from intuned_cli.controller.init import write_project_from_file_tree
+
+
+@arguably.command  # type: ignore
+async def init():
+    """
+    Initializes current app, creating pyproject.toml and Intuned.json files. Will ask for confirmation before overwriting existing files.
+
+    Args:
+        template_name (str | None): Name of the template to use.
+
+    Returns:
+        None
+    """
+    is_target_directory_empty = await check_empty_directory()
+
+    await write_project_from_file_tree(python_template_name, is_target_directory_empty)

intuned_cli/commands/run_api_command.py

@@ -0,0 +1,69 @@
+import arguably
+import pytimeparse  # type: ignore
+
+from intuned_cli.controller.api import AuthSessionInput
+from intuned_cli.controller.api import execute_run_api_cli
+from intuned_cli.utils.auth_session_helpers import assert_auth_consistent
+from intuned_cli.utils.auth_session_helpers import load_parameters
+
+
+@arguably.command  # type: ignore
+async def run__api(
+    api_name: str,
+    parameters: str,
+    /,
+    *,
+    auth_session: str | None = None,
+    retries: int = 1,
+    proxy: str | None = None,
+    no_auth_session_auto_recreate: bool = False,
+    auth_session_check_attempts: int = 1,
+    auth_session_create_attempts: int = 1,
+    timeout: str = "10 min",
+    headless: bool = False,
+    output_file: str | None = None,
+):
+    """Execute san Intuned API run with parameters
+
+    Args:
+        api_name (str): Name of the API to run.
+        parameters (str): Path to the JSON file containing API parameters OR the parameters as a JSON string.
+        auth_session (str | None, optional): [-a/--auth-session]. ID of the auth session to use for the API. This is expected to be in ./auth-session-instances/<id>.
+        retries (int, optional): [--retries]. Number of retries for the API call. Defaults to 1.
+        proxy (str | None, optional): [--proxy]. Proxy URL to use. Defaults to None.
+        no_auth_session_auto_recreate (bool, optional): [--no-auth-session-auto-recreate]. Disable auto recreate for auth session. Defaults to False.
+        auth_session_check_attempts (int, optional): [--auth-session-check-attempts]. Auth session check attempts. Defaults to 1.
+        auth_session_create_attempts (int, optional): [--auth-session-create-attempts]. Auth session create attempts. Defaults to 1.
+        timeout (str, optional): [--timeout]. Timeout - milliseconds or pytimeparse-formatted string. Defaults to "10 min".
+        headless (bool, optional): [--headless]. Run the API in headless mode (default: False). This will not open a browser window.
+        output_file (str | None, optional): [-o/--output-file]. Output file path. Defaults to None.
+    """
+    auth_session_auto_recreate = not no_auth_session_auto_recreate
+
+    await assert_auth_consistent(auth_session)
+
+    input_data = await load_parameters(parameters)
+
+    timeout_value = pytimeparse.parse(timeout)  # type: ignore
+    if timeout_value is None:
+        raise ValueError(
+            f"Invalid timeout format: {timeout}. Please use a valid time format like '10 min' or '600 seconds'."
+        )
+
+    await execute_run_api_cli(
+        api_name=api_name,
+        input_data=input_data,
+        retries=retries,
+        proxy=proxy,
+        auth_session=AuthSessionInput(
+            id=auth_session,
+            auto_recreate=auth_session_auto_recreate,
+            check_retries=auth_session_check_attempts,
+            create_retries=auth_session_create_attempts,
+        )
+        if auth_session
+        else None,
+        timeout=timeout_value,
+        headless=headless,
+        output_file=output_file,
+    )

intuned_cli/commands/run_authsession_command.py

@@ -0,0 +1,12 @@
+import arguably
+
+from intuned_cli.utils.console import console
+
+
+@arguably.command  # type: ignore
+async def run__authsession():
+    """Executes an Intuned authsession run"""
+
+    if arguably.is_target():
+        console.print(" (-h/--help) for usage")
+        exit(1)

intuned_cli/commands/run_authsession_create_command.py

@@ -0,0 +1,50 @@
+import arguably
+import pytimeparse  # type: ignore
+
+from intuned_cli.controller.authsession import execute_run_create_auth_session_cli
+from intuned_cli.utils.auth_session_helpers import assert_auth_enabled
+from intuned_cli.utils.auth_session_helpers import load_parameters
+
+
+@arguably.command  # type: ignore
+async def run__authsession__create(
+    parameters: str,
+    /,
+    *,
+    id: str | None = None,
+    check_attempts: int = 1,
+    create_attempts: int = 1,
+    proxy: str | None = None,
+    timeout: str = "10 min",
+    headless: bool = False,
+):
+    """Create a new auth session
+
+    Args:
+        parameters (str): Parameters for the auth session command
+        id (str | None, optional): [--id]. ID of the auth session to use for the command. Defaults to auth-session-[current timestamp].
+        check_attempts (int, optional): [--check-attempts]. Number of attempts to check the auth session validity. Defaults to 1.
+        create_attempts (int, optional): [--create-attempts]. Number of attempts to create a new auth session if it is invalid. Defaults to 1.
+        proxy (str | None, optional): [--proxy]. Proxy URL to use for the auth session command. Defaults to None.
+        timeout (str, optional): [--timeout]. Timeout for the auth session command - milliseconds or pytimeparse-formatted string. Defaults to "10 min".
+        headless (bool, optional): [--headless]. Run the API in headless mode (default: False). This will not open a browser window.
+    """
+    await assert_auth_enabled()
+
+    auth_session_input = await load_parameters(parameters) or {}
+
+    timeout_value = pytimeparse.parse(timeout)  # type: ignore
+    if timeout_value is None:
+        raise ValueError(
+            f"Invalid timeout format: {timeout}. Please use a valid time format like '10 min' or '600 seconds'."
+        )
+
+    await execute_run_create_auth_session_cli(
+        id=id,
+        input_data=auth_session_input,
+        check_retries=check_attempts,
+        create_retries=create_attempts,
+        headless=headless,
+        proxy=proxy,
+        timeout=timeout_value,
+    )

intuned_cli/commands/run_authsession_update_command.py

@@ -0,0 +1,52 @@
+import arguably
+import pytimeparse  # type: ignore
+
+from intuned_cli.controller.authsession import execute_run_update_auth_session_cli
+from intuned_cli.utils.auth_session_helpers import assert_auth_enabled
+from intuned_cli.utils.auth_session_helpers import load_parameters
+
+
+@arguably.command  # type: ignore
+async def run__authsession__update(
+    id: str,
+    /,
+    *,
+    parameters: str | None = None,
+    check_attempts: int = 1,
+    create_attempts: int = 1,
+    proxy: str | None = None,
+    timeout: str = "10 min",
+    headless: bool = False,
+):
+    """Update an existing auth session
+
+    Args:
+        id (str): ID of the auth session to update
+        parameters (str | None, optional): [--parameters]. Parameters for the auth session command. If not provided, it will use the existing parameters.
+        check_attempts (int, optional): [--check-attempts]. Number of attempts to check the auth session validity. Defaults to 1.
+        create_attempts (int, optional): [--create-attempts]. Number of attempts to create a new auth session if it is invalid. Defaults to 1.
+        proxy (str | None, optional): [--proxy]. Proxy URL to use for the auth session command. Defaults to None.
+        timeout (str, optional): [--timeout]. Timeout for the auth session command - milliseconds or pytimeparse-formatted string. Defaults to "10 min".
+        headless (bool, optional): [--headless]. Run the API in headless mode (default: False). This will not open a browser window.
+    """
+    await assert_auth_enabled()
+
+    auth_session_input = None
+    if parameters:
+        auth_session_input = await load_parameters(parameters)
+
+    timeout_value = pytimeparse.parse(timeout)  # type: ignore
+    if timeout_value is None:
+        raise ValueError(
+            f"Invalid timeout format: {timeout}. Please use a valid time format like '10 min' or '600 seconds'."
+        )
+
+    await execute_run_update_auth_session_cli(
+        id=id,
+        input_data=auth_session_input,
+        check_retries=check_attempts,
+        create_retries=create_attempts,
+        headless=headless,
+        proxy=proxy,
+        timeout=timeout_value,
+    )

intuned_cli/commands/run_authsession_validate_command.py

@@ -0,0 +1,49 @@
+import arguably
+import pytimeparse  # type: ignore
+
+from intuned_cli.controller.authsession import execute_run_validate_auth_session_cli
+from intuned_cli.utils.auth_session_helpers import assert_auth_enabled
+
+
+@arguably.command  # type: ignore
+async def run__authsession__validate(
+    id: str,
+    /,
+    *,
+    check_attempts: int = 1,
+    create_attempts: int = 1,
+    proxy: str | None = None,
+    timeout: str = "10 min",
+    no_auto_recreate: bool = False,
+    headless: bool = False,
+):
+    """Validate an existing auth session
+
+    Args:
+        id (str): ID of the auth session to validate
+        check_attempts (int, optional): [--check-attempts]. Number of attempts to check the auth session validity. Defaults to 1.
+        create_attempts (int, optional): [--create-attempts]. Number of attempts to create a new auth session if it is invalid. Defaults to 1.
+        proxy (str | None, optional): [--proxy]. Proxy URL to use for the auth session command. Defaults to None.
+        timeout (str, optional): [--timeout]. Timeout for the auth session command - milliseconds or pytimeparse-formatted string. Defaults to "10 min".
+        no_auto_recreate (bool, optional): [--no-auto-recreate]. Disable auto recreation of the auth session if it is invalid. Defaults to False.
+        headless (bool, optional): [--headless]. Run the API in headless mode (default: False). This will not open a browser window.
+    """
+    await assert_auth_enabled()
+
+    auto_recreate = not no_auto_recreate
+
+    timeout_value = pytimeparse.parse(timeout)  # type: ignore
+    if timeout_value is None:
+        raise ValueError(
+            f"Invalid timeout format: {timeout}. Please use a valid time format like '10 min' or '600 seconds'."
+        )
+
+    await execute_run_validate_auth_session_cli(
+        id=id,
+        auto_recreate=auto_recreate,
+        check_retries=check_attempts,
+        create_retries=create_attempts,
+        headless=headless,
+        proxy=proxy,
+        timeout=timeout_value,
+    )

intuned_cli/commands/run_command.py

@@ -0,0 +1,12 @@
+import arguably
+
+from intuned_cli.utils.console import console
+
+
+@arguably.command  # type: ignore
+async def run():
+    """Executes an Intuned run."""
+
+    if arguably.is_target():
+        console.print(" (-h/--help) for usage")
+        exit(1)

intuned_cli/constants/__init__.py

@@ -0,0 +1 @@
+from .readme import readme as readme