acex-cli 0.1.0__tar.gz

acex_cli-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: acex-cli
+Version: 0.1.0
+Summary: CLI components for acex framework
+Author: Johan Lahti
+Author-email: johan.lahti@acebit.se
+Requires-Python: >=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: acex-core
+Requires-Dist: typer[all]

acex_cli-0.1.0/cli/__init__.py

@@ -0,0 +1,8 @@
+"""
+ACEX CLI module
+"""
+
+from .main import app as cli_app
+from .commands import *
+
+__all__ = ["cli_app"]

acex_cli-0.1.0/cli/commands/__init__.py

@@ -0,0 +1,7 @@
+"""
+CLI Commands package
+"""
+
+from . import assets, nodes, logical_nodes
+
+__all__ = ["assets", "nodes", "logical_nodes"]

acex_cli-0.1.0/cli/commands/assets.py

@@ -0,0 +1,37 @@
+"""
+Asset management commands
+"""
+
+import typer
+from typing import Optional, List
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer()
+console = Console()
+
+@app.command("list")
+def list_assets():
+    """List all assets"""
+    console.print("Listing assets...", style="green")
+    # Implementation would go here
+    
+@app.command("create")
+def create_asset(
+    name: str = typer.Argument(..., help="Asset name"),
+    description: Optional[str] = typer.Option(None, "--description", "-d", help="Asset description")
+):
+    """Create a new asset"""
+    # Import only when needed
+    from ...models import Asset
+    
+    console.print(f"Creating asset: {name}", style="green")
+    if description:
+        console.print(f"Description: {description}")
+    # Implementation would go here
+
+@app.command("show")
+def show_asset(asset_id: int = typer.Argument(..., help="Asset ID")):
+    """Show asset details"""
+    console.print(f"Showing asset {asset_id}", style="green")
+    # Implementation would go here

acex_cli-0.1.0/cli/commands/logical_nodes.py

@@ -0,0 +1,34 @@
+"""
+Logical Node management commands
+"""
+
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer()
+console = Console()
+
+@app.command("list")
+def list_logical_nodes():
+    """List all logical nodes"""
+    console.print("Listing logical nodes...", style="green")
+    # Implementation would go here
+    
+@app.command("create")
+def create_logical_node(
+    name: str = typer.Argument(..., help="Logical node name"),
+    node_id: Optional[int] = typer.Option(None, "--node-id", "-n", help="Parent node ID")
+):
+    """Create a new logical node"""
+    console.print(f"Creating logical node: {name}", style="green")
+    if node_id:
+        console.print(f"Node ID: {node_id}")
+    # Implementation would go here
+
+@app.command("show")
+def show_logical_node(logical_node_id: int = typer.Argument(..., help="Logical node ID")):
+    """Show logical node details"""
+    console.print(f"Showing logical node {logical_node_id}", style="green")
+    # Implementation would go here

acex_cli-0.1.0/cli/commands/nodes.py

@@ -0,0 +1,106 @@
+"""
+Node management commands
+"""
+
+import typer
+from typing import Optional, List
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer()
+console = Console()
+
+def build_node_filters(name=None, hostname=None, node_type=None, active=None, tag=None):
+    """
+    Convert CLI arguments to filter expressions compatible with the project's filter system.
+    Returns a dict that can be passed to database plugins or converted to FilterExpressions.
+    """
+    filters = {}
+    
+    # Basic string filters (support regex patterns /pattern/)
+    if name is not None:
+        filters['name'] = name
+    if hostname is not None:
+        filters['hostname'] = hostname
+    if node_type is not None:
+        filters['type'] = node_type
+        
+    # Boolean filters
+    if active is not None:
+        filters['active'] = active
+        
+    # List filters (for tags, can be expanded to other list fields)
+    if tag is not None and len(tag) > 0:
+        # For multiple tags, we might want AND or OR logic
+        # This structure allows the database plugin to handle it appropriately
+        filters['tags'] = {'in': tag}  # SQL-style "IN" operation
+        
+    return filters
+
+@app.command("list")
+def list_nodes(
+    # Basic filters
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Filter by node name (supports regex /pattern/)"),
+    hostname: Optional[str] = typer.Option(None, "--hostname", "-h", help="Filter by hostname (supports regex /pattern/)"),
+    node_type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by node type"),
+    
+    # Status filters
+    active: Optional[bool] = typer.Option(None, "--active", help="Filter by active status"),
+    
+    # Advanced filters
+    tag: Optional[List[str]] = typer.Option(None, "--tag", help="Filter by tags (can be used multiple times)"),
+    
+    # Query modifiers
+    limit: Optional[int] = typer.Option(None, "--limit", "-l", help="Limit number of results"),
+    sort_by: Optional[str] = typer.Option("name", "--sort", "-s", help="Sort by field (name, hostname, type)"),
+    output_format: Optional[str] = typer.Option("table", "--format", "-f", help="Output format (table, json)")
+):
+    """List nodes with flexible filtering options
+    
+    Examples:
+      acex nodes list --name "router.*" --active
+      acex nodes list --type switch --limit 10
+      acex nodes list --tag production --tag core --format json
+    """
+    console.print("Listing nodes...", style="green")
+    
+    # Build filters using helper function
+    filters = build_node_filters(
+        name=name,
+        hostname=hostname, 
+        node_type=node_type,
+        active=active,
+        tag=tag
+    )
+    
+    # Apply query modifiers
+    query_options = {
+        'limit': limit,
+        'sort_by': sort_by,
+        'output_format': output_format
+    }
+    
+    if filters:
+        console.print(f"Active filters: {filters}", style="dim")
+    if any(v is not None for v in query_options.values()):
+        console.print(f"Query options: {query_options}", style="dim")
+
+    
+    console.print("Found X nodes matching criteria", style="green")
+    
+@app.command("create")
+def create_node(
+    name: str = typer.Argument(..., help="Node name"),
+    hostname: Optional[str] = typer.Option(None, "--hostname", "-h", help="Node hostname")
+):
+    """Create a new node"""
+    console.print(f"Creating node: {name}", style="green")
+    if hostname:
+        console.print(f"Hostname: {hostname}")
+    # Implementation would go here
+
+@app.command("show")
+def show_node(node_id: int = typer.Argument(..., help="Node ID")):
+    """Show node details"""
+    console.print(f"Showing node {node_id}", style="green")
+    # Implementation would go here

acex_cli-0.1.0/cli/main.py

@@ -0,0 +1,36 @@
+"""
+Main CLI application
+"""
+
+import typer
+from .commands import assets, nodes, logical_nodes
+
+app = typer.Typer(
+    name="acex",
+    help="ACEX - Extendable Automation & Control Ecosystem CLI",
+    add_completion=False
+)
+state = {"verbose": False}
+        
+app.add_typer(assets.app, name="assets", help="Manage assets")
+app.add_typer(nodes.app, name="nodes", help="Manage nodes") 
+app.add_typer(logical_nodes.app, name="logical-nodes", help="Manage logical nodes")
+
+
+@app.command()
+def hello():
+    """Test command"""
+    typer.echo(f"ACEX!")
+
+# Override the main callback to load commands when needed
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context, verbose: bool = False):
+    state["verbose"] = verbose
+    """Main callback - loads commands only when subcommands are used"""
+    if ctx.invoked_subcommand is None:
+        # No subcommand specified, show help
+        print(ctx.get_help())
+
+
+if __name__ == "__main__":
+    app()

acex_cli-0.1.0/cli/utils.py

@@ -0,0 +1,43 @@
+"""
+CLI utilities and helpers
+"""
+
+from typing import Optional, Any, Dict
+from rich.console import Console
+from rich.table import Table
+from rich import print as rprint
+
+console = Console()
+
+def print_success(message: str):
+    """Print success message"""
+    console.print(f"✅ {message}", style="green")
+
+def print_error(message: str):
+    """Print error message"""
+    console.print(f"❌ {message}", style="red")
+
+def print_warning(message: str):
+    """Print warning message"""
+    console.print(f"⚠️  {message}", style="yellow")
+
+def print_info(message: str):
+    """Print info message"""
+    console.print(f"ℹ️  {message}", style="blue")
+
+def create_table(title: str, columns: list) -> Table:
+    """Create a Rich table with standard formatting"""
+    table = Table(title=title, show_header=True, header_style="bold magenta")
+    for column in columns:
+        table.add_column(column)
+    return table
+
+def display_model_data(data: Any, title: str = "Data"):
+    """Display model data in a formatted way"""
+    if hasattr(data, 'dict'):
+        # SQLModel/Pydantic model
+        rprint({title: data.dict()})
+    elif isinstance(data, dict):
+        rprint({title: data})
+    else:
+        rprint({title: str(data)})

acex_cli-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "acex-cli"
+version = "0.1.0"
+description = "CLI components for acex framework"
+authors = [
+    {name = "Johan Lahti", email = "johan.lahti@acebit.se"}
+]
+requires-python = ">=3.13"
+dependencies = [
+    "acex-core",
+    "typer[all]"
+]
+
+[project.scripts]
+acex = "acex.cli.cli.main:app"
+
+[tool.poetry]
+packages = [
+    { include = "cli", to = "acex/cli" },
+]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"