karrio-cli 2025.5rc3__py3-none-any.whl

karrio_cli/commands/codegen.py

@@ -0,0 +1,336 @@
+import re
+import sys
+import typer
+import importlib
+from typing import Optional, List, Set
+import logging
+import os
+
+app = typer.Typer()
+
+@app.command("transform")
+def transform(
+    input_file: Optional[str] = typer.Argument(
+        None, help="Input file path. If not provided, reads from stdin."
+    ),
+    output_file: Optional[str] = typer.Argument(
+        None, help="Output file path. If not provided, writes to stdout."
+    ),
+    append_type_suffix: bool = typer.Option(
+        True, help="Append 'Type' to class names", is_flag=True
+    ),
+):
+    """
+    Transform Python code generated by quicktype (using dataclasses)
+    into code that uses attrs and jstruct decorators.
+    """
+    # Read input from file or stdin
+    if input_file:
+        with open(input_file, "r") as f:
+            content = f.read()
+    else:
+        content = sys.stdin.read()
+
+    # Transform the content
+    transformed = transform_content(content, append_type_suffix)
+
+    # Write output to file or stdout
+    if output_file:
+        with open(output_file, "w") as f:
+            f.write(transformed)
+    else:
+        print(transformed)
+
+def extract_class_names(content: str) -> Set[str]:
+    """Extract all class names from the content."""
+    return set(re.findall(r"class\s+(\w+)", content))
+
+def transform_content(content: str, append_type_suffix: bool = True) -> str:
+    """Transform dataclass-based code to jstruct-based code."""
+    # Check if we already have a typing import
+    has_typing_import = "import typing" in content
+
+    # Replace imports
+    if "from dataclasses import dataclass" in content:
+        content = content.replace(
+            "from dataclasses import dataclass",
+            "import attr\nimport jstruct" + ("" if has_typing_import else "\nimport typing")
+        )
+    else:
+        # If dataclasses import is not found, add the imports anyway
+        imports = "import attr\nimport jstruct"
+        if not has_typing_import:
+            imports += "\nimport typing"
+        content = imports + "\n" + content
+
+    # Remove any "from typing import" lines completely
+    content = re.sub(r"from typing import [^\n]+\n", "", content)
+
+    # Replace @dataclass decorator with @attr.s
+    content = re.sub(r"@dataclass", "@attr.s(auto_attribs=True)", content)
+
+    # Get all class names
+    class_names = extract_class_names(content)
+
+    # Dictionary to keep track of original class names and their new versions with Type suffix
+    class_name_mapping = {}
+
+    # Create a new names dictionary if we're appending Type
+    if append_type_suffix:
+        for class_name in class_names:
+            # If the class name already ends with 'Type', append 'ObjectType' instead
+            if class_name.endswith('Type'):
+                class_name_mapping[class_name] = f"{class_name}ObjectType"
+            else:
+                class_name_mapping[class_name] = f"{class_name}Type"
+
+        # Rename class definitions only, not field names
+        for original_name, new_name in class_name_mapping.items():
+            # Replace class definitions
+            content = re.sub(
+                rf"class\s+{original_name}\s*:",
+                f"class {new_name}:",
+                content
+            )
+
+    # Process all property definitions
+    lines = content.split('\n')
+    for i in range(len(lines)):
+        line = lines[i]
+
+        # Skip if this is not a class property line
+        if not re.search(r'^\s+\w+\s*:', line):
+            continue
+
+        # Replace typing annotations with module references
+        line = re.sub(r':\s*Any\s*=', r': typing.Any =', line)  # Replace standalone Any as a type
+        line = re.sub(r':\s*Union\s*=', r': typing.Union =', line)  # Replace standalone Union as a type
+        line = re.sub(r':\s*Dict\s*=', r': typing.Dict =', line)  # Replace standalone Dict as a type
+        line = re.sub(r'Optional\[', r'typing.Optional[', line)
+        line = re.sub(r'List\[', r'typing.List[', line)
+        line = re.sub(r'Union\[', r'typing.Union[', line)  # Add handling for Union types
+        line = re.sub(r'Dict\[', r'typing.Dict[', line)  # Add handling for Dict types
+        line = re.sub(r'(\[|,\s*)Any(\]|,|\s*\]=)', r'\1typing.Any\2', line)  # Match Any inside brackets or between commas
+        line = re.sub(r'(\[|,\s*)Union(\[)', r'\1typing.Union\2', line)  # Match Union inside brackets or between commas
+        line = re.sub(r'(\[|,\s*)Dict(\[)', r'\1typing.Dict\2', line)  # Match Dict inside brackets or between commas
+
+        # Handle nested Union inside Optional
+        line = re.sub(r'typing\.Optional\[(Union\[)', r'typing.Optional[typing.\1', line)
+
+        # Handle nested Dict inside Optional
+        line = re.sub(r'typing\.Optional\[(Dict\[)', r'typing.Optional[typing.\1', line)
+
+        # Handle properties with null values (e.g., "category: None" -> "category: typing.Any = None")
+        line = re.sub(r'(\w+):\s*None\s*$', r'\1: typing.Any = None', line)
+        lines[i] = line
+
+        # Handle complex type annotations for each class
+        for original_name in class_names:
+            class_name = class_name_mapping.get(original_name, original_name) if append_type_suffix else original_name
+
+            # Update type annotations references only, not field names
+            if append_type_suffix and original_name != class_name:
+                # Replace original_name with class_name only when it's inside type annotation brackets
+                # This prevents changing field names that match class names
+
+                # Handle typing.Optional[OriginalName]
+                pattern = re.compile(rf'(typing\.\w+\[)({original_name})(\])')
+                lines[i] = re.sub(pattern, f'\\1{class_name}\\3', lines[i])
+
+                # Handle Union types that contain the class name
+                union_pattern = re.compile(rf'(typing\.Union\[[^,\]]*,\s*)({original_name})(\s*\]|\s*,)')
+                lines[i] = re.sub(union_pattern, f'\\1{class_name}\\3', lines[i])
+
+                # Also handle Union when the class name is the first element
+                union_first_pattern = re.compile(rf'(typing\.Union\[)({original_name})(\s*,)')
+                lines[i] = re.sub(union_first_pattern, f'\\1{class_name}\\3', lines[i])
+
+                # Handle Dict with class name as key or value type
+                dict_pattern = re.compile(rf'(typing\.Dict\[[^,\]]*,\s*)({original_name})(\s*\])')
+                lines[i] = re.sub(dict_pattern, f'\\1{class_name}\\3', lines[i])
+
+                # Handle Dict with class name as key type
+                dict_key_pattern = re.compile(rf'(typing\.Dict\[)({original_name})(\s*,)')
+                lines[i] = re.sub(dict_key_pattern, f'\\1{class_name}\\3', lines[i])
+
+                # Handle nested types: typing.Optional[typing.List[OriginalName]]
+                nested_pattern = re.compile(rf'(typing\.\w+\[typing\.\w+\[)({original_name})(\]\])')
+                lines[i] = re.sub(nested_pattern, f'\\1{class_name}\\3', lines[i])
+
+                # Handle jstruct.JStruct[OriginalName]
+                jstruct_pattern = re.compile(rf'(jstruct\.JStruct\[)({original_name})(\])')
+                lines[i] = re.sub(jstruct_pattern, f'\\1{class_name}\\3', lines[i])
+
+                # Handle jstruct.JList[OriginalName]
+                jlist_pattern = re.compile(rf'(jstruct\.JList\[)({original_name})(\])')
+                lines[i] = re.sub(jlist_pattern, f'\\1{class_name}\\3', lines[i])
+
+            # Check for Optional[ClassType]
+            if re.search(rf'typing\.Optional\[{class_name}\]\s*=\s*None', lines[i]):
+                lines[i] = re.sub(
+                    rf'typing\.Optional\[{class_name}\]\s*=\s*None',
+                    f'typing.Optional[{class_name}] = jstruct.JStruct[{class_name}]',
+                    lines[i]
+                )
+
+            # Check for List[ClassType]
+            elif re.search(rf'typing\.List\[{class_name}\]\s*=\s*None', lines[i]):
+                lines[i] = re.sub(
+                    rf'typing\.List\[{class_name}\]\s*=\s*None',
+                    f'typing.List[{class_name}] = jstruct.JList[{class_name}]',
+                    lines[i]
+                )
+
+            # Check for Optional[List[ClassType]]
+            elif re.search(rf'typing\.Optional\[typing\.List\[{class_name}\]\]\s*=\s*None', lines[i]):
+                lines[i] = re.sub(
+                    rf'typing\.Optional\[typing\.List\[{class_name}\]\]\s*=\s*None',
+                    f'typing.Optional[typing.List[{class_name}]] = jstruct.JList[{class_name}]',
+                    lines[i]
+                )
+
+            # Check for Optional[Union[...]]
+            elif re.search(rf'typing\.Optional\[typing\.Union\[[^\]]*{class_name}[^\]]*\]\]\s*=\s*None', lines[i]):
+                # For simplicity, we're not replacing the value here since Union types are complex
+                # and we don't want to make assumptions about the appropriate jstruct type
+                pass
+
+            # Check for Optional[Dict[...]]
+            elif re.search(rf'typing\.Optional\[typing\.Dict\[[^\]]*{class_name}[^\]]*\]\]\s*=\s*None', lines[i]):
+                # For simplicity, we're not replacing the value here since Dict types are complex
+                # and we don't want to make assumptions about the appropriate jstruct type
+                pass
+
+    return '\n'.join(lines)
+
+@app.command("generate")
+def generate(
+    input_file: str = typer.Argument(..., help="Input JSON schema file path"),
+    output_file: Optional[str] = typer.Argument(
+        None, help="Output Python file path. If not provided, writes to stdout."
+    ),
+    python_version: str = typer.Option("3.11", help="Python version to target"),
+    just_types: bool = typer.Option(True, help="Generate just the type definitions without serialization code"),
+    append_type_suffix: bool = typer.Option(True, help="Append 'Type' to class names"),
+    nice_property_names: bool = typer.Option(False, help="Use nice property names"),
+):
+    """
+    Generate Python code with jstruct from a JSON schema file using quicktype.
+    """
+    import subprocess
+
+    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+    logger = logging.getLogger(__name__)
+
+    # Build quicktype command
+    cmd = [
+        "npx",
+        "quicktype",
+        "--no-uuids",
+        "--no-enums",
+        "--no-date-times",
+        "--src-lang", "json",
+        "--lang", "python",
+        "--all-properties-optional",
+        "--no-nice-property-names",
+        f"--python-version", python_version,
+        "--src", input_file
+    ]
+
+    if just_types:
+        cmd.append("--just-types")
+
+    if nice_property_names:
+        cmd.remove("--no-nice-property-names")
+
+    # Run quicktype to generate Python code with dataclasses
+    result = subprocess.run(cmd, capture_output=True, text=True)
+
+    if result.returncode != 0:
+        logger.error(f"Error generating code for {os.path.basename(input_file)}: {result.stderr}")
+        print(f"Error running quicktype: {result.stderr}", file=sys.stderr)
+        sys.exit(1)
+
+    # Transform the output to use jstruct
+    transformed = transform_content(result.stdout, append_type_suffix)
+
+    # Write output to file or stdout
+    if output_file:
+        with open(output_file, "w") as f:
+            f.write(transformed)
+        logger.info(f"Generated {os.path.basename(output_file)} from {os.path.basename(input_file)}")
+    else:
+        print(transformed)
+        logger.info(f"Generated code from {os.path.basename(input_file)} to stdout")
+
+def instantiate_tree(cls, indent=0, alias=""):
+    tree = f"{alias}{cls.__name__}(\n"
+    indent += 1
+    items = cls.__annotations__.items() if hasattr(cls, "__annotations__") else []
+
+    for name, typ in items:
+        if typ.__name__ == "Optional" and hasattr(typ, "__args__"):
+            typ = typ.__args__[0]
+        if typ.__name__ == "List" and hasattr(typ, "__args__"):
+            typ = typ.__args__[0]
+            if hasattr(typ, "__annotations__"):
+                tree += (
+                    " " * indent * 4
+                    + f"{name}=[\n"
+                    + " " * (indent + 1) * 4
+                    + f"{instantiate_tree(typ, indent + 1, alias=alias)}\n"
+                    + " " * indent * 4
+                    + "],\n"
+                )
+            else:
+                tree += " " * indent * 4 + f"{name}=[],\n"
+        elif hasattr(typ, "__annotations__"):
+            tree += (
+                " " * indent * 4
+                + f"{name}={instantiate_tree(typ, indent, alias=alias)},\n"
+            )
+        else:
+            tree += " " * indent * 4 + f"{name}=None,\n"
+
+    tree += " " * (indent - 1) * 4 + ")"
+    return tree
+
+
+def instantiate_class_from_module(
+    module_name: str,
+    class_name: str,
+    module_alias: str = "",
+):
+    module = importlib.import_module(module_name)
+    cls = getattr(module, class_name)
+    alias = f"{module_alias}." if module_alias != "" else ""
+
+    return instantiate_tree(cls, alias=alias)
+
+
+@app.command("create-tree")
+def create_tree(
+    module: str = typer.Option(..., prompt=True, help="Module containing the class"),
+    class_name: str = typer.Option(..., prompt=True, help="Class name to generate a tree for"),
+    module_alias: str = typer.Option("", help="Optional alias for the module in the output"),
+):
+    """
+    Generate a Python code tree from a class definition.
+
+    This command imports a class from a specified module and generates
+    a Python code snippet that shows how to construct an instance of that class
+    with all its nested properties.
+    """
+    if not module or not class_name:
+        print("module and class_name are required")
+        raise typer.Abort()
+
+    output = instantiate_class_from_module(
+        module,
+        class_name,
+        module_alias=module_alias,
+    )
+    typer.echo(output)
+
+if __name__ == "__main__":
+    app()

karrio_cli/commands/login.py

@@ -0,0 +1,139 @@
+import os
+import typer
+import requests
+
+app = typer.Typer()
+
+DEFAULT_HOST = "http://localhost:5002"
+
+
+def get_config():
+    config_file = os.path.expanduser("~/.karrio/config")
+    if os.path.exists(config_file):
+        with open(config_file, "r") as f:
+            return dict(line.strip().split("=") for line in f)
+    return {}
+
+
+def get_host_and_key():
+    config = get_config()
+    host = os.environ.get("KARRIO_HOST") or config.get("KARRIO_HOST") or DEFAULT_HOST
+    api_key = os.environ.get("KARRIO_API_KEY") or config.get("KARRIO_API_KEY")
+    return host, api_key
+
+
+@app.command()
+def login(
+    host: str = typer.Option(
+        DEFAULT_HOST,
+        prompt="Enter the Karrio host URL",
+        help="The URL of the Karrio instance",
+    ),
+    api_key: str = typer.Option(
+        ...,
+        prompt="Enter your Karrio API key",
+        hide_input=True,
+        help="Your Karrio API key",
+    ),
+):
+    """
+    Configure a connection to a Karrio instance.
+
+    Example:
+    ```terminal
+    kcli login --host http://localhost:5002 --api-key your_api_key_here | jq '{message: "Login successful", host: .host}'
+    ```
+    """
+    if not host:
+        host = DEFAULT_HOST
+
+    try:
+        # Validate the connection
+        headers = {"Authorization": f"Token {api_key}"}
+        response = requests.get(f"{host}", headers=headers)
+        response.raise_for_status()
+
+        # Save the configuration
+        config_dir = os.path.expanduser("~/.karrio")
+        os.makedirs(config_dir, exist_ok=True)
+        config_file = os.path.join(config_dir, "config")
+
+        with open(config_file, "w") as f:
+            f.write(f"KARRIO_HOST={host}\n")
+            f.write(f"KARRIO_API_KEY={api_key}\n")
+
+        typer.echo(f"Successfully logged in to Karrio instance at {host}")
+        typer.echo(f"Configuration saved to {config_file}")
+
+    except requests.RequestException as e:
+        typer.echo(f"Error connecting to Karrio instance: {str(e)}", err=True)
+    except IOError as e:
+        typer.echo(f"Error saving configuration: {str(e)}", err=True)
+
+
+@app.command()
+def logout():
+    """
+    Remove the saved Karrio configuration.
+
+    Example:
+    ```terminal
+    kcli logout | jq '{message: "Logout successful"}'
+    ```
+    """
+    config_file = os.path.expanduser("~/.karrio/config")
+    try:
+        os.remove(config_file)
+        typer.echo("Successfully logged out. Karrio configuration removed.")
+    except FileNotFoundError:
+        typer.echo("No saved Karrio configuration found.")
+    except IOError as e:
+        typer.echo(f"Error removing configuration: {str(e)}", err=True)
+
+
+@app.command()
+def status():
+    """
+    Check the current login status and connection to Karrio.
+
+    Example:
+    ```terminal
+    kcli status | jq '{status: "Connected", host: .host, api_key: "********"}'
+    ```
+    """
+    host, api_key = get_host_and_key()
+
+    if api_key:
+        try:
+            headers = {"Authorization": f"Token {api_key}"}
+            response = requests.get(f"{host}", headers=headers)
+            response.raise_for_status()
+
+            # Display connection status
+            typer.echo(f"Connected to Karrio instance at {host}")
+
+            # Display API metadata if available
+            try:
+                metadata = response.json()
+                typer.echo("\nAPI Metadata:")
+                for key, value in metadata.items():
+                    typer.echo(f"  {key}: {value}")
+            except ValueError:
+                typer.echo("\nNo API metadata available")
+
+            # Display API key source
+            if os.environ.get("KARRIO_API_KEY"):
+                typer.echo("\nUsing API key from environment variable")
+            elif os.path.exists(os.path.expanduser("~/.karrio/config")):
+                typer.echo("\nUsing API key from config file")
+
+        except requests.RequestException as e:
+            typer.echo(f"Error connecting to Karrio instance: {str(e)}", err=True)
+    else:
+        typer.echo(
+            "Not logged in. Use 'karrio login' to configure the connection or set KARRIO_API_KEY environment variable."
+        )
+
+
+if __name__ == "__main__":
+    app()

karrio_cli/commands/plugins.py

@@ -0,0 +1,168 @@
+import typer
+import karrio.references as references
+import typing
+
+app = typer.Typer()
+
+@app.command("list")
+def list_plugins(
+    pretty: bool = typer.Option(False, "--pretty", "-p", help="Pretty print the output"),
+    line_numbers: bool = typer.Option(False, "--line-numbers", "-n", help="Show line numbers in pretty print"),
+):
+    """
+    List all plugins with short description and active status.
+
+    Examples:
+    ```terminal
+    # Get all plugins and display as a table (default)
+    kcli plugins list
+    ```
+
+    ```terminal
+    # Get plugins in JSON format
+    kcli plugins list --pretty | jq ".[] | {id, label, status, enabled}"
+    ```
+
+    Example Output:
+    ```json
+    [
+      {
+        "id": "plugin_id",
+        "label": "Plugin Name",
+        "status": "active",
+        "enabled": true,
+        "description": "A brief description of the plugin functionality"
+      }
+    ]
+    ```
+    """
+    plugins = references.collect_plugins_data()
+    registry = references.Registry()
+    results = []
+    for plugin_id, plugin in plugins.items():
+        enabled = registry.get(f"{plugin_id.upper()}_ENABLED", True)
+        results.append({
+            "id": plugin_id,
+            "label": plugin.get("label", ""),
+            "status": plugin.get("status", ""),
+            "enabled": enabled,
+            "description": plugin.get("description", ""),
+        })
+    if pretty:
+        import json
+        typer.echo(json.dumps(results, indent=2))
+    else:
+        try:
+            from tabulate import tabulate
+            table = [
+                [i, plugin['id'], plugin['label'], plugin['status'], 'ENABLED' if plugin['enabled'] else 'DISABLED']
+                for i, plugin in enumerate(results, 1)
+            ]
+            headers = ['#', 'ID', 'Label', 'Status', 'Enabled']
+            typer.echo(tabulate(table, headers=headers, tablefmt='github'))
+        except ImportError:
+            for i, plugin in enumerate(results, 1):
+                line = f"{i}. {plugin['id']} - {plugin['label']} ({'ENABLED' if plugin['enabled'] else 'DISABLED'}) - {plugin['status']}"
+                if line_numbers:
+                    typer.echo(f"{i}: {line}")
+                else:
+                    typer.echo(line)
+
+@app.command("show")
+def show_plugin(
+    plugin_id: str,
+    pretty: bool = typer.Option(False, "--pretty", "-p", help="Pretty print the output"),
+    line_numbers: bool = typer.Option(False, "--line-numbers", "-n", help="Show line numbers in pretty print"),
+):
+    """
+    Show full details for a plugin by ID.
+
+    Example:
+    ```terminal
+    kcli plugins show plugin_id --pretty | jq "{id, label, description, status, enabled}"
+    ```
+
+    Example Output:
+    ```json
+    {
+      "id": "plugin_id",
+      "label": "Plugin Name",
+      "description": "A detailed description of the plugin functionality",
+      "status": "active",
+      "enabled": true,
+      "version": "1.0.0",
+      "author": "Plugin Author",
+      "website": "https://plugin-website.com",
+      "dependencies": {
+        "python": ">=3.8",
+        "karrio": ">=2024.12"
+      }
+    }
+    ```
+    """
+    details = references.get_plugin_details(plugin_id)
+    if not details:
+        typer.echo(f"Plugin '{plugin_id}' not found.", err=True)
+        raise typer.Exit(code=1)
+    import json
+    if pretty:
+        typer.echo(json.dumps(details, indent=2))
+    else:
+        for i, (k, v) in enumerate(details.items(), 1):
+            line = f"{k}: {v}"
+            if line_numbers:
+                typer.echo(f"{i}: {line}")
+            else:
+                typer.echo(line)
+
+@app.command("enable")
+def enable_plugin(
+    plugin_id: str,
+):
+    """
+    Enable a plugin by updating the Django Constance env var associated.
+
+    Example:
+    ```terminal
+    kcli plugins enable plugin_id
+    ```
+
+    Example Output:
+    ```text
+    Plugin 'plugin_id' enabled.
+    ```
+    """
+    registry = references.Registry()
+    key = f"{plugin_id.upper()}_ENABLED"
+    try:
+        registry[key] = True
+        typer.echo(f"Plugin '{plugin_id}' enabled.")
+    except Exception as e:
+        typer.echo(f"Failed to enable plugin '{plugin_id}': {e}", err=True)
+        raise typer.Exit(code=1)
+
+@app.command("disable")
+def disable_plugin(
+    plugin_id: str,
+):
+    """
+    Disable a plugin by updating the Django Constance env var associated.
+
+    Example:
+    ```terminal
+    kcli plugins disable plugin_id
+    ```
+
+    Example Output:
+    ```text
+    Plugin 'plugin_id' disabled.
+    ```
+    """
+    registry = references.Registry()
+    key = f"{plugin_id.upper()}_ENABLED"
+    try:
+        registry[key] = False
+        typer.echo(f"Plugin '{plugin_id}' disabled.")
+    except Exception as e:
+        typer.echo(f"Failed to disable plugin '{plugin_id}': {e}", err=True)
+        raise typer.Exit(code=1)