clarity-cli 0.1.0__py3-none-any.whl

clarity_cli/commands.py

@@ -0,0 +1,174 @@
+from clarity_cli.outputs import CliOutput, CliTable
+from clarity_cli.input import CliInputs
+from clarity_cli.helpers import (is_logged_in, get_tests, trigger_test_execution, write_new_profile_to_config,
+                                 get_profile_configuration, get_clarity_access_token, get_devices, format_device_state, get_params)
+from clarity_cli.defs import TableColumn, ThemeColors, CONFIG_FILE, ProfileConfig, InputTypes
+from clarity_cli.exceptions import StopCommand
+
+
+class CliCommands():
+    def __init__(self):
+        self.out = CliOutput()
+        self.input = CliInputs()
+
+    def _get_current_profile_and_config(self, profile=None, override_config_path=None):
+        config, profile_name = self.out.run_sync_function("Validate profile...",
+                                                          get_profile_configuration, profile=profile, override_config_path=override_config_path)
+        return config, profile_name
+
+    def execute(self, ctx, test_id=None, profile=None, override_config_path=None, project=None, workspace=None, agent_id=None, parameters_file=None):
+        """Execute a test from the available tests"""
+        self.out.setup_context(ctx)
+        config, profile_name = self._get_current_profile_and_config(profile, override_config_path)
+        web_token = is_logged_in(profile_name)
+
+        project = project or config.project
+        workspace = workspace or config.workspace
+        agent_id = agent_id or config.agent
+
+        if not project:
+            self.out.vprint("project wasn't provided, asking user")
+            project = self.input.ask_for_text_input("Project id")
+        if not workspace:
+            self.out.vprint("workspace id wasn't provided, asking user")
+            workspace = self.input.ask_for_text_input("Workspace id")
+
+        self.out.main_message("Test Execution")
+
+        # Display available tests in a table
+        test_execution_columns = [TableColumn("ID", ThemeColors.CYAN),
+                                  TableColumn("Name", ThemeColors.GREEN),
+                                  TableColumn("Version", ThemeColors.RED),
+                                  TableColumn("Description", ThemeColors.YELLOW)]
+        tests_table = CliTable("Available Tests", test_execution_columns)
+        available_tests, params = self.out.run_sync_function("Getting Tests...", get_tests, token=web_token, workspace_id=workspace, domain=config.domain)
+
+        selected_test = None
+
+        # If test ID is provided directly, use it
+        if test_id:
+            selected_test = next((test for test in available_tests if test["test_id"] == test_id), None)
+            if not selected_test:
+                raise StopCommand(f"Error: Test with ID '{test_id}' not found")
+
+            self.input.ask_for_confirmation(f"Execute test '{selected_test['test_name']}' ({test_id})?")
+
+        # If no test ID provided, use interactive selection
+        else:
+            tests_table.add_data(available_tests,
+                                 headers_mapping={"ID": "test_id", "Name": "test_name", "Version": "test_version", "Description": "description"})
+            tests_table.print_table()
+            # Create choices for the test selection
+            choices = [f"{test['test_id']} - {test['test_name']}, {test['test_version']}" for test in available_tests]
+            selected = self.input.ask_for_input_from_list("Select a test to execute", choices)
+
+            # Get the selected test ID
+            selected_test_id = selected.split(' - ')[0]
+            selected_test = next((test for test in available_tests if test["test_id"] == selected_test_id), None)
+
+            if not selected_test:
+                raise StopCommand("Error: Could not find the selected test")
+
+        if selected_test.get('iot_device_required'):
+            if not agent_id:
+                self.out.vprint("agent id wasn't provided, asking user")
+                devices_column = [TableColumn("Name", ThemeColors.CYAN),
+                                  TableColumn("ID"),
+                                  TableColumn("Version"),
+                                  TableColumn("Status")]
+                available_devices = self.out.run_sync_function("Getting devices...", get_devices, token=web_token, workspace_id=workspace, domain=config.domain)
+                devices_by_name = {}
+                for device in available_devices:
+                    format_device_state(device)
+                    devices_by_name[device['device_name']] = device
+                devices_table = CliTable("Available Devices", devices_column)
+                devices_table.add_data(available_devices,
+                                       headers_mapping={"ID": "device_id", "Name": "device_name", "Version": "iot_client_version", "Status": "state"})
+                devices_table.print_table()
+                agent_name = self.input.ask_for_input_from_list("Please select an agent id", devices_by_name.keys())
+                agent_id = devices_by_name.get(agent_name)
+            if not agent_id:
+                raise StopCommand("Agent was not provided, please ")
+
+        self.out.main_message("Configure flow parameters")
+        self.out.vprint(f"test flow param config:\n{params[selected_test_id].get('properties', {})}")
+        if parameters_file:
+            self.out.vprint(f"Loading parameters file: {parameters_file}")
+            params_from_config = get_params(parameters_file)
+
+        for param_name, param in params[selected_test_id].get('properties', {}).items():
+            if param.get('type') in list(InputTypes.__members__):
+                input_value = self.input.ask_for_text_input(param_name, default=param.get('default'))
+                if params_from_config.get(param_name):
+                    self.out.vprint(f"Got param: {param_name} from file, value: {params_from_config[param_name]}")
+                    param['default'] = params_from_config[param_name]
+                else:
+                    self.out.vprint(f"Got param: {param_name} user: { InputTypes[param['type']].value(input_value)}")
+                    param['default'] = InputTypes[param['type']].value(input_value)
+        if not params[selected_test_id]:
+            self.out.warning("Flow variables weren't found")
+        # Execute the test (in a real app, this would trigger an actual test)
+        web_token = is_logged_in(profile_name)
+        execution_url = self.out.run_sync_function(f"Executing: {selected_test['test_name']}...",
+                                                   function=trigger_test_execution, domain=config.domain, token=web_token, workspace=workspace,
+                                                   project_id=project, agent_id=agent_id, test_id=selected_test_id, params=params[selected_test_id])
+
+        self.out.ok(f"Successfully executed test: {CliOutput.bold(selected_test['test_name'])}")
+        self.out.print(f"[dim]Results will be available in the dashboard: {execution_url}[/dim]")
+
+    def write_profile_to_config(self, ctx, profile_name=None, client_id=None, client_secret=None, token_endpoint=None,
+                                scope=None, project=None, workspace=None, agent_id=None, domain=None, default=None):
+        self.out.setup_context(ctx)
+        self.out.main_message("New Profile")
+        if not profile_name:
+            self.out.vprint("profile name wasn't provided, asking user")
+            profile_name = self.input.ask_for_text_input("Profile name")
+        if not client_id:
+            self.out.vprint("client_id wasn't provided, asking user")
+            client_id = self.input.ask_for_text_input("Client id")
+        if not client_secret:
+            self.out.vprint("client_secret wasn't provided, asking user")
+            client_secret = self.input.ask_for_password_input("Client secret")
+        if not token_endpoint:
+            self.out.vprint("token endpoint wasn't provided, asking user")
+            token_endpoint = self.input.ask_for_password_input("Token endpoint")
+        if not scope:
+            self.out.vprint("scope wasn't provided, asking user")
+            scope = self.input.ask_for_password_input("Scope")
+        if not domain:
+            self.out.vprint("domain wasn't provided, asking user")
+            domain = self.input.ask_for_text_input("Clarity domain")
+        if not project:
+            self.out.vprint("project wasn't provided, asking user")
+            project = self.input.ask_for_text_input("Project id", optional=True)
+        if not workspace:
+            self.out.vprint("workspace provided, asking user")
+            workspace = self.input.ask_for_text_input("Workspace id", optional=True)
+        if not agent_id:
+            self.out.vprint("agent_id wasn't provided, asking user")
+            agent_id = self.input.ask_for_text_input("Agent id", optional=True)
+        if default is None:
+            default = self.input.ask_for_confirmation("Set this profile as default?", default=False)
+        if profile_name and client_id and client_secret and token_endpoint and scope and domain:
+            columns = [TableColumn("Property", ThemeColors.CYAN), TableColumn("Value", ThemeColors.GREEN)]
+            table = CliTable("New Profile", columns)
+            table.add_data([("Profile name", profile_name), ("Client id", client_id), ("Client secret", client_secret), ("Clarity domain", domain),
+                            ("Default Project id", project), ("Default workspace id", workspace), ("Default agent id", agent_id), ("Is default", str(default))])
+            table.print_table()
+            self.input.ask_for_confirmation("Setup the new profile?", default=True, hard_stop=True)
+        else:
+            raise StopCommand("Missing property")
+
+        config = ProfileConfig(client_id=client_id, client_secret=client_secret, domain=domain, token_endpoint=token_endpoint, scope=scope,
+                               project=project, workspace=workspace, agent_id=agent_id)
+        self.out.run_sync_function(f"Configuring new profile {profile_name}...",
+                                   write_new_profile_to_config, profile_name=profile_name, default=default, config=config)
+        self.out.ok(f"New profile {CliOutput.bold(profile_name)} successfully configured")
+        self.out.vprint(f"All profiles can be found at: {CONFIG_FILE}")
+
+    def login_using_config_file(self, ctx, profile=None, override_config_path=None):
+        self.out.setup_context(ctx)
+        config, profile = self._get_current_profile_and_config(profile, override_config_path)
+        self.out.run_sync_function("Logging in", get_clarity_access_token, profile=profile, client_id=config.client_id,
+                                   client_secret=config.client_secret, token_endpoint=config.token_endpoint, scope=config.scope)
+        self.out.ok("Successfully logged in!")

clarity_cli/defs.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+from enum import Enum
+from pydantic import BaseModel
+
+
+# Define the base directory for storing configuration
+CONFIG_DIR = Path.home() / '.clarity'
+CONFIG_FILE = CONFIG_DIR / 'config.json'
+TOKEN_FILE = CONFIG_DIR / 'token.json'
+
+EXECUTION_VIEW_PATH = 'testing/executions/view?executionId={execution_id}&projectId={project_id}'
+DEVICES_LIST = 'inv-api/devices/status'
+TEST_LIST = 'inv-api/testing/catalog'
+
+
+class ThemeColors(Enum):
+    GREEN = "green"
+    YELLOW = "yellow"
+    BLUE = "blue"
+    CYAN = "cyan"
+    WHITE = "white"
+    RED = "red"
+
+
+@dataclass
+class TableColumn:
+    name: str
+    color: Optional[ThemeColors] = ThemeColors.WHITE
+
+
+class ProfileConfig(BaseModel):
+    client_id: str
+    client_secret: str
+    token_endpoint: str
+    scope: str
+    project: Optional[str] = ""
+    workspace: Optional[str] = ""
+    agent: Optional[str] = ""
+    domain: str
+
+
+class InputTypes(Enum):
+    integer = int
+    string = str
+    boolean = bool

clarity_cli/exceptions.py

@@ -0,0 +1,14 @@
+from clarity_cli.outputs import CliOutput
+
+out = CliOutput()
+
+
+class StopCommand(Exception):
+    def __init__(self, *args):
+        out.error(*args)
+        exit(0)
+
+
+class UnAuthenticated(Exception):
+    def __init__(self, *args):
+        raise StopCommand(f"You need to login first. Run {CliOutput.bold('clarity login')}")

clarity_cli/helpers.py

@@ -0,0 +1,217 @@
+import json
+import jwt
+import datetime
+import base64
+import requests
+from clarity_cli.outputs import CliOutput
+from clarity_cli.defs import CONFIG_DIR, TOKEN_FILE, CONFIG_FILE, ProfileConfig, EXECUTION_VIEW_PATH, TEST_LIST, DEVICES_LIST
+from clarity_cli.exceptions import StopCommand, UnAuthenticated
+out = CliOutput()
+
+
+def ensure_config_dir():
+    """Ensure the config directory exists"""
+    if not CONFIG_DIR.exists():
+        CONFIG_DIR.mkdir(parents=True)
+        out.ok("Created configuration directory at ~/.clarity")
+
+
+def is_logged_in(profile):
+    """Check if the user is logged in by verifying the token"""
+    if not TOKEN_FILE.exists():
+        raise UnAuthenticated()
+    out.vprint("Token file found")
+    try:
+        with open(TOKEN_FILE, 'r') as f:
+            token_data = json.load(f)
+
+        # Verify token hasn't expired
+        token = token_data.get(profile)
+        if not token:
+            raise UnAuthenticated()
+        out.vprint("Token was loaded successfully")
+        # Decode the token without verification to check expiration
+        decoded = jwt.decode(token, options={"verify_signature": False})
+        out.vprint("Token was parsed successfully")
+        exp_timestamp = decoded.get('exp', datetime.datetime.now(datetime.timezone.utc))
+
+        # Check if token has expired
+        if datetime.datetime.fromtimestamp(exp_timestamp, tz=datetime.timezone.utc) < datetime.datetime.now(datetime.timezone.utc):
+            out.warning(
+                "Your session has expired. Please login again.")
+            raise UnAuthenticated()
+
+        return token
+
+    except Exception as e:
+        out.error(f"Error checking login status: {str(e)}")
+        raise UnAuthenticated()
+
+
+def format_device_state(device):
+    if device['state'] == 'connected':
+        device['state'] = f"[green]{device['state']}[/green]"
+    if device['state'] == 'disconnected':
+        device['state'] = f"[red]{device['state']}[/red]"
+    else:
+        device['state'] = f"[yellow]{device['state']}[/yellow]"
+
+
+def get_devices(token, workspace_id, domain):
+    headers = {"Authorization": f"Bearer {token}", "workspace": workspace_id}
+    url = f"{domain}/{DEVICES_LIST}"
+    response = requests.get(url, headers=headers)
+    if response.status_code == 200:
+        res = response.json()
+        devices = res['device_list']
+        return devices
+    else:
+        out.vprint("Error getting devices list")
+        out.vprint(response.text)
+        raise StopCommand("Couldn't get devices list")
+
+
+def get_tests(token, workspace_id, domain):
+    headers = {"Authorization": f"Bearer {token}", "workspace": workspace_id}
+    url = f"{domain}/{TEST_LIST}"
+    response = requests.get(url, headers=headers)
+    # Check if the request was successful
+    param_res = {}
+    if response.status_code == 200:
+        res = response.json()
+        for test in res:
+            param_res[test['test_id']] = test['params_schema']
+        return res, param_res
+    else:
+        out.vprint("Error getting tests list")
+        out.vprint(response.text)
+        raise StopCommand("Couldn't get Test list")
+
+
+def trigger_test_execution(domain, token, workspace, project_id, agent_id, test_id, params):
+    headers = {"Authorization": f"Bearer {token}", "workspace": workspace}
+    url = f"{domain}/inv-api/testing/executions/handler"
+    data = {
+        "project_id": project_id,
+        "agent_id": agent_id,
+        "test_plan_config": [{
+            "params_config": {},
+            "test_id": test_id,
+            "test_config": {'variables_config':  params}
+        }
+        ],
+    }
+    response = requests.post(url, headers=headers, json=data)
+    # Check if the request was successful
+    if response.status_code == 202:
+        res = response.json()
+        out.ok("Execution started")
+        out.vprint(f"execution id: {res['execution_id']}, project id: {res['project_id']}")
+        # return URL to track the execution
+        return f"{domain}/{EXECUTION_VIEW_PATH.format(execution_id=res['execution_id'], project_id=res['project_id'])}"
+    else:
+        out.vprint("Status code:", response.status_code)
+        raise StopCommand(f"Failed to start execution, {response.text}")
+
+
+def get_clarity_access_token(profile, client_id, client_secret, token_endpoint, scope):
+    # The client credentials grant requires HTTP Basic Authentication,
+    # where the username is the client ID and the password is the client secret
+    try:
+        client_auth = base64.b64encode(f"{client_id}:{client_secret}".encode("utf-8")).decode("utf-8")
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Authorization": f"Basic {client_auth}",
+        }
+
+        # The grant_type must be client_credentials
+        data = {
+            "grant_type": "client_credentials",
+            "scope": scope,
+        }
+        response = requests.post(token_endpoint, headers=headers, data=data)
+
+        if response.status_code != 200:
+            out.verbose(response.text)
+            raise StopCommand("Failed to get access token")
+
+        response_data = response.json()
+        out.vprint(f"Got token: {response_data['access_token']}")
+        write_token(response_data["access_token"], profile)
+    except Exception as e:
+        out.vprint(f"Login error - {e}")
+        raise StopCommand("Unable to login")
+
+
+def read_config(config_override=None):
+    config_to_use = config_override or CONFIG_FILE
+    try:
+        out.vprint(f"Reading config file: {config_to_use}")
+        with open(config_to_use, "r") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def read_token():
+    try:
+        with open(TOKEN_FILE, "r") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def get_params(params_file):
+    try:
+        with open(params_file, "r") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def write_new_profile_to_config(profile_name: str, default: bool, config: ProfileConfig):
+    try:
+        cur_config = read_config()
+        new_profile = {
+            profile_name: config.model_dump()
+        }
+        full_config = {**cur_config, **new_profile}
+        full_config['default'] = profile_name if default else full_config.get('default', "")
+        with open(CONFIG_FILE, "w") as f:
+            json.dump(full_config, f)
+    except Exception as e:
+        StopCommand(f"An error occurred while writing new profile to config file - {e}")
+
+
+def write_token(token, profile):
+    tokens = read_token()
+    tokens[profile] = token
+    try:
+        out.vprint(f"writing token to {TOKEN_FILE}, for profile: {profile}")
+        with open(TOKEN_FILE, 'w') as f:
+            json.dump(tokens, f)
+    except Exception as e:
+        StopCommand(f"Unable to write tmp token to: {TOKEN_FILE} - {e}")
+
+
+def get_profile_configuration(profile=None, override_config_path=None):
+    current_configuration = read_config(override_config_path)
+    if not profile:
+        out.warning("Profile was not provided, using default profile")
+        profile = current_configuration.get('default')
+        if profile:
+            out.ok(f"Default profile found, using {profile} profile")
+        else:
+            raise StopCommand("Default profile wasn't configured, please specify a profile")
+    try:
+        profile_config = ProfileConfig(**current_configuration.get(profile, {}))
+        if not profile_config:
+            out.error(f"profile {CliOutput.bold(profile)} was not found")
+            out.warning("use "+{CliOutput.bold('\'clarity profile-setup\'')} + "command to set it up")
+    except Exception as e:
+        # is_valid_config = all([True if key in profile_config else False for key in ['client_id', 'client_secret', 'token_endpoint', 'scope']])
+        # if not is_valid_config:
+        out.vprint(f"Error parsing config - {e}")
+        out.warning("use "+{CliOutput.bold('\'clarity profile-setup\'')} + "command to set it up")
+        raise StopCommand("Profile configuration is not valid, please reconfigure or use another profile")
+    return profile_config, profile

clarity_cli/input.py

@@ -0,0 +1,47 @@
+import inquirer
+from inquirer import themes
+from clarity_cli.exceptions import StopCommand
+from clarity_cli.outputs import CliOutput
+
+out = CliOutput()
+
+
+class CliInputs():
+
+    def ask_for_confirmation(self, confirmation_message, default=True, hard_stop=False):
+        questions = [
+            inquirer.Confirm('confirm', message=f"{confirmation_message}", default=default)]
+
+        answers = inquirer.prompt(questions, theme=themes.GreenPassion())
+        if not answers:
+            out.vprint("Command was canceled")
+            raise StopCommand()
+        if hard_stop and not answers['confirm']:
+            out.vprint("Command was not confirmed")
+            raise StopCommand()
+        return answers['confirm']
+
+    def ask_for_input_from_list(self, message, options: list):
+        questions = [inquirer.List('list_input', message=message, choices=options)]
+        answers = inquirer.prompt(questions, theme=themes.GreenPassion())
+        if not answers or not answers['list_input']:
+            out.warning("Command was canceled")
+            raise StopCommand()
+        return answers.get('list_input')
+
+    def ask_for_text_input(self, message, default="", optional=False):
+        final_message = f"{message} [Optional]" if optional else message
+        questions = [inquirer.Text('text_input', message=final_message, default=default)]
+        answers = inquirer.prompt(questions, theme=themes.Default())
+        if not answers or (optional and not answers['text_input']):
+            out.warning("Command was canceled")
+            raise StopCommand()
+        return answers.get('text_input')
+
+    def ask_for_password_input(self, message):
+        questions = [inquirer.Password('pass_input', message=message)]
+        answers = inquirer.prompt(questions, theme=themes.Default())
+        if not answers or not answers['pass_input']:
+            out.warning("Command was canceled")
+            raise StopCommand()
+        return answers.get('pass_input')

clarity_cli/main.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""
+Clarity CLI - Interactive CLI for test management and execution
+
+This CLI tool provides functionality for:
+- Login (generates and stores JWT tokens)
+- Executing tests (displays and allows selection from available tests)
+"""
+
+# import json
+# import datetime
+# import uuid
+import click
+# import inquirer
+# from inquirer import themes
+# from rich.panel import Panel
+# from rich.table import Table
+# import jwt
+from clarity_cli.helpers import ensure_config_dir
+from clarity_cli.commands import CliCommands
+
+
+commands = CliCommands()
+
+
+@click.group()
+@click.option('--verbose', '-v', is_flag=True, help='Verbose mode')
+@click.pass_context
+def cli(ctx, verbose=False):
+    """Clarity CLI - Interactive test management and execution tool"""
+    ctx.ensure_object(dict)
+    ctx.obj['VERBOSE'] = verbose
+    ensure_config_dir()
+
+
+@cli.command()
+@click.option('--test-id', '-t', help='Specify a test ID to execute directly')
+@click.option('--profile', '-p', help='Specify a name for the new profile')
+@click.option('--override-config-path', '-c', help='Path to config.json, default config stored in ~/.config.json')
+@click.option('--project', '-proj', help='Specify the default project id for clarity operations')
+@click.option('--workspace', '-w', help='Specify the default workspace id for clarity operations')
+@click.option('--agent-id', '-a', help='Specify the default agent id for executions')
+@click.option('--parameters-file', help="Path to a json file that includes all the flow variables values for execution, if flow var doesn't exist using the default value")
+@click.pass_context
+def execute(ctx, test_id=None, profile=None, override_config_path=None, project=None, workspace=None, agent_id=None, parameters_file=None):
+    commands.execute(ctx, test_id, profile, override_config_path, project, workspace, agent_id, parameters_file)
+
+
+@cli.command()
+@click.option('--profile', '-p', help='Specify a name for the new profile')
+@click.option('--client-id', '-id', help='Specify the client ID you got from cyclarity portal')
+@click.option('--client-secret', '-cs', help='Specify the client secret you got from cyclarity portal')
+@click.option('--token-endpoint', '-e', help='Specify the token endpoint you got from cyclarity portal')
+@click.option('--scope', '-s', help='Specify the scope you got from cyclarity portal')
+@click.option('--project', '-proj', help='Specify the default project id for clarity operations')
+@click.option('--workspace', '-w', help='Specify the default workspace id for clarity operations')
+@click.option('--agent_id', '-a', help='Specify the default agent id for executions')
+@click.option('--default', '-d', help='Use this profile as default profile')
+@click.pass_context
+def profile_setup(ctx, profile=None, client_id=None, client_secret=None, token_endpoint=None, scope=None, project=None, workspace=None, agent_id=None, default=None):
+    commands.write_profile_to_config(ctx, profile, client_id, client_secret, token_endpoint, scope, project, workspace, agent_id, default)
+
+
+@cli.command()
+@click.option('--profile', '-p', help='Profile for login, if not provided use default profile')
+@click.option('--override-config-path', '-c', help='Path to config.json, default config stored in ~/.config.json')
+@click.pass_context
+def login(ctx, profile=None, override_config_path=None):
+    commands.login_using_config_file(ctx, profile, override_config_path)
+
+
+if __name__ == '__main__':
+    cli()

clarity_cli/outputs.py

@@ -0,0 +1,67 @@
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from clarity_cli.defs import TableColumn
+
+verbose = True  # or False, depending on your use case
+
+
+class CliTable():
+    def __init__(self, table_name, columns: list[TableColumn]):
+        self.out = CliOutput()
+        self.table = Table(title=table_name)
+        self.columns = columns
+        for column in columns:
+            self.table.add_column(column.name, style=column.color.value)
+
+    def add_data(self, data: list[dict[str, str]], headers_mapping: dict[str, str]):
+        for row in data:
+            self.table.add_row(*[row.get(headers_mapping[col.header], "") for col in self.table.columns])
+
+    def print_table(self):
+        self.out.print(self.table)
+
+
+class CliOutput():
+    _instance = None
+    console: Console = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(CliOutput, cls).__new__(cls)
+            cls._instance.verbose = False  # Default value
+            cls._instance.console = Console()
+        return cls._instance
+
+    def setup_context(self, ctx):
+        self.verbose = ctx.obj.get('VERBOSE')
+
+    def ok(self, message=None):
+        if message:
+            self.print(f"[green]{message}[/green]")
+
+    def error(self, message=None):
+        if message:
+            self.print(f"[red][bold]{message}[bold][/red]")
+
+    def warning(self, message=None):
+        if message:
+            self.print(f"[yellow]{message}[/yellow]")
+
+    def main_message(self, message):
+        self.print(Panel.fit(message, style="blue"))
+
+    def print(self, message):
+        self.console.print(message)
+
+    def vprint(self, message):
+        if self.verbose:
+            self.print(f"[dim]{message}[/dim]")
+
+    @staticmethod
+    def bold(message):
+        return f"[bold]{message}[/bold]"
+
+    def run_sync_function(self, message, function, **args):
+        with self.console.status(f"[bold green]{message}\n"):
+            return function(**args)

clarity_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.3
+Name: clarity-cli
+Version: 0.1.0
+Summary: Interactive CLI for test management and execution
+License: MIT
+Author: Clarity Team
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click (>=8.1.3,<9.0.0)
+Requires-Dist: inquirer (>=3.1.3,<4.0.0)
+Requires-Dist: pydantic (>=2.11.4,<3.0.0)
+Requires-Dist: pyjwt (>=2.6.0,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: rich (>=13.3.5,<14.0.0)
+Description-Content-Type: text/markdown
+
+

clarity_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+clarity_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+clarity_cli/commands.py,sha256=SF_S2LqL_NO4kTlpzgbR7PmPGSlVDN78Su9zLJk0xkk,10824
+clarity_cli/defs.py,sha256=qtZqH5ZaY1uLBw9Ok3JHPVgTH--rwicpGGfzdOeU7Xg,1038
+clarity_cli/exceptions.py,sha256=WCZDMf3WsvC0bpyEQJ--ag1nQbB7HeqR0RY90oKN_jM,325
+clarity_cli/helpers.py,sha256=L_B_4ckXnyrGEE7bXd3atkD9jWXcZ8yJbXZtzbLAEEI,8101
+clarity_cli/input.py,sha256=k_gknkG9YjiF20oV86Nt6_7Pw1_82rrLXLZIvdSbHQk,1974
+clarity_cli/main.py,sha256=x_hsp3Y__kNY-MsjH4diD-4IItEJeRS5Rr4S4zdSr6c,3448
+clarity_cli/outputs.py,sha256=le52pwNQI1bW3e9X7M6iN8GleKEMdRlGj7EqMNsUKs0,2023
+clarity_cli-0.1.0.dist-info/METADATA,sha256=6ue_CAF6R3SRGjD_uUdyl5o692ARdGsxmAXIzl6NgpY,762
+clarity_cli-0.1.0.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+clarity_cli-0.1.0.dist-info/entry_points.txt,sha256=aDG82xIqh9xMP0O9nRcQan9ifvufwFZFNbNVJA7PlVU,48
+clarity_cli-0.1.0.dist-info/RECORD,,

clarity_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.2
+Root-Is-Purelib: true
+Tag: py3-none-any

clarity_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+clarity=clarity_cli.main:cli
+