argocli 0.1.0__py3-none-any.whl

argocli/__init__.py

@@ -0,0 +1,67 @@
+# pylint: disable=broad-except, line-too-long
+
+"""
+module docstring
+"""
+
+# import os
+import sys
+from importlib import metadata
+import cac_core as cac
+
+# import yaml
+# import keyring
+import argocli.core.client as client
+
+if sys.version_info < (3, 9):
+    print("This project requires Python 3.9 or higher.", file=sys.stderr)
+    sys.exit(1)
+
+cac.updatechecker.check_package_for_updates(__name__)
+
+try:
+    __version__ = metadata.version(__package__)
+except Exception:
+    __version__ = "#N/A"
+
+log = cac.logger.new(__name__)
+log.debug("Initializing %s version %s", __name__, __version__)
+
+CONFIG = cac.config.Config(__name__)
+
+log.debug("user config path: %s", CONFIG.config_file)
+
+# TODO: prompt user for server and username if not set
+argo_server = CONFIG.get("server", "INVALID_DEFAULT") #.replace("https://", "")
+if argo_server == "INVALID_DEFAULT":
+    log.error("Invalid server in %s: %s", CONFIG.config_file, argo_server)
+    sys.exit(1)
+
+argo_namespace = CONFIG.get("namespace", "INVALID_DEFAULT")
+if argo_namespace == "INVALID_DEFAULT":
+    log.error("Invalid namespace in %s: %s", CONFIG.config_file, argo_namespace)
+    sys.exit(1)
+
+argo_username = CONFIG.get("username", "INVALID_DEFAULT")
+if argo_username == "INVALID_DEFAULT":
+    log.error("Invalid username in %s: %s", CONFIG.config_file, argo_username)
+    sys.exit(1)
+
+credentialmanager = cac.credentialmanager.CredentialManager(__name__)
+argo_api_token = credentialmanager.get_credential(
+    argo_username,
+    "Argo API key",
+)
+
+if not argo_api_token:
+    # TODO: update the docs
+    log.error(
+        "API token not found for %s; see https://github.com/rpunt/%s/blob/main/README.md#authentication",
+        argo_username,
+        __name__.replace("_", "-"),
+    )
+    sys.exit(1)
+
+ARGO_CLIENT = client.ArgoClient(argo_server, argo_namespace, argo_api_token)
+
+__all__ = ["ARGO_CLIENT", "CONFIG", "log"]

argocli/cli/main.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python
+# pylint: disable=line-too-long
+
+import argparse
+import importlib
+import sys
+import logging
+import os
+
+# import pkgutil
+import cac_core as cac
+
+
+def discover_commands():
+    """
+    Discover available commands by scanning the commands directory.
+
+    Returns:
+        list: A list of command names.
+    """
+    commands = []
+    commands_dir = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "..", "commands")
+    )
+
+    # Check if the commands directory exists
+    if not os.path.exists(commands_dir) or not os.path.isdir(commands_dir):
+        return commands
+
+    # Get all subdirectories (which are packages) in the commands directory
+    for item in os.listdir(commands_dir):
+        item_path = os.path.join(commands_dir, item)
+        # Only consider directories that have an __init__.py file (Python packages)
+        if (
+            os.path.isdir(item_path)
+            and os.path.exists(os.path.join(item_path, "__init__.py"))
+            and item != "__pycache__"
+        ):
+            commands.append(item)
+
+    return sorted(commands)
+
+
+def discover_actions(command):
+    """
+    Discover available actions for a given command by scanning its directory.
+
+    Args:
+        command (str): The command name.
+
+    Returns:
+        list: A list of action names.
+    """
+    actions = []
+    command_dir = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "..", "commands", command)
+    )
+
+    # Check if the command directory exists
+    if not os.path.exists(command_dir) or not os.path.isdir(command_dir):
+        return actions
+
+    # Get all Python modules in the command directory
+    for item in os.listdir(command_dir):
+        # Skip __init__.py, __pycache__, and non-Python files
+        if item == "__init__.py" or item == "__pycache__" or not item.endswith(".py"):
+            continue
+
+        # Extract action name (filename without .py extension)
+        action = item[:-3]
+        actions.append(action)
+
+    return sorted(actions)
+
+
+def show_command_help(command):
+    """
+    Show help for a specific command, listing all available actions.
+
+    Args:
+        command (str): The command to show help for
+    """
+    actions = discover_actions(command)
+    print(f"\nAvailable actions for '{command}':")
+    for action in sorted(actions):
+        try:
+            module_path = f"{__name__}.commands.{command}.{action}"
+            module = importlib.import_module(module_path)
+            doc = module.__doc__ or "No description available"
+            doc = doc.strip().split("\n")[0]  # Get first line of docstring
+            print(f"  {action.ljust(15)} - {doc}")
+        except Exception:  # pylint: disable=broad-except
+            print(f"  {action.ljust(15)} - No description available")
+
+
+# def register_autocomplete(parser):
+#     """Set up command autocompletion if supported environment"""
+#     try:
+#         import argcomplete
+#         argcomplete.autocomplete(parser)
+#     except ImportError:
+#         # argcomplete is not installed, skip autocomplete setup
+#         pass
+
+
+def setup_logging(verbose: bool) -> logging.Logger:
+    """Configure logging based on command line arguments"""
+    log = cac.logger.new(__name__)
+    if verbose:
+        log.setLevel(logging.DEBUG)
+    # if getattr(args, 'show_log_format', False):
+    #     print(f"Log format: {cac.logger.get_formatter_string()}")
+    #     sys.exit(0)
+    return log
+
+
+def main():
+    """
+    Entry point for the Argo CLI tool.
+
+    This function sets up the argument parser with nested commands, and dynamically
+    loads and executes the appropriate module and action based on user input.
+    """
+    log = cac.logger.new(__name__)
+
+    # Create parent parser for global arguments
+    parent_parser = argparse.ArgumentParser(add_help=False)
+
+    # Main parser that inherits from parent
+    parser = argparse.ArgumentParser(
+        prog="argocli", description="Argo CLI tool", parents=[parent_parser]
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # Discover available commands by scanning the commands directory
+    commands = discover_commands()
+    log.debug("Discovered commands: %s", commands)
+
+    # Dictionary to map command names to their subparsers
+    command_subparsers = {}
+
+    # Set up command structure based on discovered commands
+    for command in commands:
+        command_parser = subparsers.add_parser(
+            command,
+            help=f"{command.capitalize()}-related commands",
+            parents=[parent_parser],
+        )
+        command_subparsers[command] = command_parser.add_subparsers(
+            dest="action", required=True
+        )
+
+    # Add all available action parsers up front by scanning directories
+    for command, subparser in command_subparsers.items():
+        actions = discover_actions(command)
+        log.debug("Discovered actions for %s: %s", command, actions)
+
+        for action in actions:
+            try:
+                # Load the module and class for this action
+                module_path = f"argocli.commands.{command}.{action}"
+                module = importlib.import_module(module_path)
+
+                class_name = f"{command.capitalize()}{action.capitalize()}"
+                action_class = getattr(module, class_name, None)
+
+                if action_class is None:
+                    log.warning(
+                        "Class '%s' not found in module '%s'", class_name, module_path
+                    )
+                    continue
+
+                # Instantiate the action class
+                action_instance = action_class()
+
+                # Create parser for this action and let the action define its arguments
+                action_parser = subparser.add_parser(
+                    action, help=f"{action} {command}", parents=[parent_parser]
+                )
+                action_instance.define_arguments(action_parser)
+
+                # Store the class for later execution
+                action_parser.set_defaults(action_class=action_class)
+
+            except ModuleNotFoundError:
+                log.warning("Command module '%s' not found", module_path)
+            except Exception as e:  # pylint: disable=broad-except
+                log.warning("Error setting up %s %s: %s", command, action, e)
+
+    # # Add autocomplete setup
+    # register_autocomplete(parser)
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    log = setup_logging(args.verbose)
+    # log = setup_logging(False)
+    log.debug("Parsed arguments: %s", args)
+
+    # Add to main function, after argument parsing but before execution
+    if args.command is None:
+        parser.print_help()
+        print("\nAvailable commands:")
+        for cmd in sorted(commands):
+            print(f"  {cmd}")
+        sys.exit(1)
+
+    # Execute the appropriate action
+    try:
+        # Get the action class from the parser defaults
+        action_class = getattr(args, "action_class", None)
+
+        if action_class is None:
+            log.error("No handler found for %s %s", args.command, args.action)
+            sys.exit(1)
+
+        # Instantiate and execute
+        if callable(action_class):
+            action_instance = action_class()
+        else:
+            log.error("Invalid action class for %s %s", args.command, args.action)
+            sys.exit(1)
+
+        log.debug("Executing action: %s %s", args.command, args.action)
+        action_instance.execute(args)
+
+    except Exception as e:  # pylint: disable=broad-except
+        log.error("Error executing command: %s", e)
+
+
+if __name__ == "__main__":
+    main()

argocli/commands/command.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+
+"""
+Base class for all Argo CLI commands.
+
+This module provides a base class that all command actions should inherit from,
+allowing for common functionality and arguments to be shared across different
+command actions.
+"""
+
+import abc
+from cac_core.command import Command
+from argocli import CONFIG, ARGO_CLIENT, log
+
+
+class ArgoCommand(Command):
+    """
+    Base class for all Argo CLI commands.
+
+    This class defines common methods and properties that should be shared
+    across all command actions, such as common arguments, authentication,
+    and utility functions.
+    """
+
+    def __init__(self):
+        """
+        Initialize the command with a logger and Argo client.
+        """
+        super().__init__()
+        self.log = log
+        self.argo_client = ARGO_CLIENT
+        self.config = CONFIG
+
+    @abc.abstractmethod
+    def define_arguments(self, parser):
+        """
+        Define command-specific arguments.
+
+        This method must be implemented by subclasses to add
+        command-specific arguments to the parser.
+
+        Args:
+            parser: The argument parser to add arguments to
+
+        Returns:
+            The updated argument parser
+        """
+        super().define_arguments(parser)
+        return parser
+
+    @abc.abstractmethod
+    def execute(self, args):
+        """
+        Execute the command with the provided arguments.
+
+        This method must be implemented by subclasses.
+
+        Args:
+            args: The parsed arguments
+        """
+        raise NotImplementedError("Command subclasses must implement execute()")

argocli/commands/workflow/__init__.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+
+"""
+Base module for all issue-related commands.
+
+This module defines the base ArgoCommand class that all issue-related
+action classes should inherit from.
+"""
+
+import abc
+from argocli.commands.command import ArgoCommand
+
+
+class ArgoWorkflowCommand(ArgoCommand):
+    """
+    Base class for all workflow-related actions.
+
+    This class defines common methods and properties that should be shared
+    across all workflow actions, such as workflow-specific arguments and utilities.
+    """
+
+    @abc.abstractmethod
+    def define_arguments(self, parser):
+        """
+        Define arguments specific to this command.
+
+        Args:
+            parser: The argument parser to add arguments to
+
+        Returns:
+            The parser with arguments added
+        """
+        super().define_arguments(parser)
+        # Add workflow-specific common arguments
+        has_name = any(action.dest == "name" for action in parser._actions)
+        if not has_name:
+            parser.add_argument(
+                "-n",
+                "--name",
+                help="Workflow name",
+                required=True,
+            )
+        return parser
+
+    @abc.abstractmethod
+    def execute(self, args):
+        """
+        Execute the command with the given arguments.
+
+        Args:
+            args: The parsed arguments
+
+        Returns:
+            The result of the command execution
+        """
+        raise NotImplementedError("Subclasses must implement execute()")

argocli/commands/workflow/status.py

@@ -0,0 +1,28 @@
+# pylint: disable=no-member
+
+from argocli.commands.workflow import ArgoWorkflowCommand
+
+class WorkflowStatus(ArgoWorkflowCommand):
+    """
+    Command to check the status of a workflow.
+    """
+
+    def define_arguments(self, parser):
+        """
+        Define command-specific arguments for checking workflow status.
+        """
+        super().define_arguments(parser)
+        return parser
+
+    def execute(self, args):
+        """
+        Execute the command to check the workflow status.
+        """
+        # print(f"Checking status for workflow: {args.name}")
+        client = self.argo_client
+        workflow_status = client.get_workflow(args.name)
+        print(
+            workflow_status["status"]["phase"]
+            if workflow_status
+            else "Workflow not found or error occurred."
+        )

argocli/core/client.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+# pylint: disable=no-member
+
+"""
+Argo client module.
+"""
+
+import cac_core as cac
+import requests
+
+log = cac.logger.new(__name__)
+
+
+class ArgoClient:
+    """
+    Argo client class.
+    """
+
+    def __init__(self, server, namespace, api_token=None):
+        """
+        Initialize the Argo client.
+
+        Args:
+            server: The Argo server
+            username: The Argo username
+            api_token: The Argo API token
+        """
+        self.server = server
+        self.namespace = namespace
+        self.api_token = api_token
+
+    def get_workflow(self, name):
+        """
+        Get a workflow by name.
+
+        Args:
+            name: The name of the workflow
+
+        Returns:
+            The workflow object
+        """
+        log.debug(f"Getting workflow {name} from server {self.server}")
+        response = requests.get(
+            f"{self.server}/api/v1/workflows/{self.namespace}/{name}",
+            headers={"Authorization": f"Bearer {self.api_token}"},
+            timeout=10
+        )
+        if response.status_code == 200:
+            return response.json()
+        else:
+            log.error(f"Failed to get workflow {name}: {response.status_code} {response.text}")
+            return None

argocli-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: argocli
+Version: 0.1.0
+Summary: A command-line interface for Argo Workflows
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cac-core>=0.4.1
+Requires-Dist: packaging>=25.0
+Requires-Dist: requests>=2.32.4
+Dynamic: license-file

argocli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+argocli/__init__.py,sha256=weB2OKhqXNYNMZ9i23mwC99shvbIM1eochbN91Okakw,1874
+argocli/cli/main.py,sha256=SGDmWCuR2XQS71g1p3p-BYQT1ivxmgrIpfO0G4ZEzJ0,7589
+argocli/commands/command.py,sha256=K9ehMVba9_Rg_TsEPnFec4GP24BpXvHWdfp2A7wvmTc,1599
+argocli/commands/workflow/__init__.py,sha256=6f-gZGuBNw_YM4iK8-gviJ20uDSfmhEtC7Lx8TpWMP8,1489
+argocli/commands/workflow/status.py,sha256=YxNFmieCiBaqOBt6D-uyCDTVr6SC4cLxhgtqxJyxcLE,819
+argocli/core/client.py,sha256=00NMaRbEFmgHGHea2OJPdg7bMAn9wa0gLuJT_kdJ_fU,1246
+argocli-0.1.0.dist-info/licenses/LICENSE,sha256=9zKZw6P2NbYxuA1UuxzvAvTc3VhTW07CAgN3bLxCkqo,1066
+argocli-0.1.0.dist-info/METADATA,sha256=5dwg-OC9EsVNFARFla9mZ02aWmZJ5E3iKWV-0kMeiF4,306
+argocli-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+argocli-0.1.0.dist-info/entry_points.txt,sha256=cAplzeUUaQ8IXiVEBR_9p5_7iRHyAGZQgxl0hITGqrg,50
+argocli-0.1.0.dist-info/top_level.txt,sha256=k62Rfx-hxDMUXTnXBBpjRw16LlSfB6I7rTai_DPoJuw,8
+argocli-0.1.0.dist-info/RECORD,,

argocli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

argocli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+argocli = argocli.cli.main:main

argocli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ryan Punt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

argocli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+argocli