helper-cli 0.1.11__py3-none-any.whl → 0.1.21__py3-none-any.whl

helper/commands/system_info.py

@@ -0,0 +1,326 @@
+import click
+import platform
+import subprocess
+import sys
+from datetime import datetime
+
+
+def run_command(cmd):
+    """Run a shell command and return its output"""
+    try:
+        result = subprocess.check_output(
+            cmd, shell=True, text=True, stderr=subprocess.STDOUT
+        ).strip()
+        return result if result else "N/A"
+    except subprocess.CalledProcessError as e:
+        return f"Error: {e.output}" if e.output else "Command failed"
+
+
+def format_bytes(size_bytes):
+    """Convert bytes to human readable format"""
+    if not isinstance(size_bytes, (int, float)):
+        try:
+            size_bytes = float(size_bytes)
+        except (ValueError, TypeError):
+            return str(size_bytes)
+
+    for unit in ["B", "KB", "MB", "GB", "TB", "PB"]:
+        if size_bytes < 1024.0 or unit == "PB":
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} PB"
+
+
+def parse_vm_stat(output):
+    """Parse macOS vm_stat output and return human readable memory info"""
+    if not output or "Mach Virtual Memory Statistics" not in output:
+        return "Memory information not available"
+
+    # Get physical memory using sysctl
+    try:
+        total_memory = int(run_command("sysctl -n hw.memsize"))
+    except (ValueError, subprocess.CalledProcessError):
+        return "Error: Could not determine total physical memory"
+
+    lines = output.split("\n")
+    mem_info = {}
+
+    for line in lines[1:]:  # Skip header
+        if ":" in line:
+            key, value = line.split(":", 1)
+            key = key.strip().strip(".")
+            try:
+                # Convert pages to bytes (1 page = 4KB on macOS)
+                pages = int(value.strip().strip("."))
+                mem_info[key] = pages * 4096  # 4KB per page
+            except (ValueError, AttributeError):
+                mem_info[key] = value.strip()
+
+    # Calculate memory usage
+    wired_memory = mem_info.get("Pages wired down", 0)
+    active_memory = mem_info.get("Pages active", 0)
+    inactive_memory = mem_info.get("Pages inactive", 0)
+    free_memory = mem_info.get("Pages free", 0)
+
+    # Calculate used memory (wired + active)
+    used_memory = wired_memory + active_memory
+
+    # Calculate app memory (active + inactive)
+    app_memory = active_memory + inactive_memory
+
+    # Calculate cached files (inactive memory can be purged by the OS)
+    cached_files = inactive_memory
+
+    return (
+        f"Total: {format_bytes(total_memory)}\n"
+        f"Used:  {format_bytes(used_memory)} (Apps: {format_bytes(app_memory)}, Wired: {format_bytes(wired_memory)})\n"
+        f"Free:  {format_bytes(free_memory)}\n"
+        f"Cached: {format_bytes(cached_files)}\n"
+        f"Usage: {used_memory/total_memory*100:.1f}%"
+    )
+
+
+def parse_df_output(output):
+    """Parse df output and format sizes"""
+    if not output:
+        return "Disk information not available"
+
+    lines = output.split("\n")
+    if not lines:
+        return output
+
+    # Keep the header
+    result = [lines[0]]
+
+    # Process each line
+    for line in lines[1:]:
+        if not line.strip():
+            continue
+
+        parts = line.split()
+        if len(parts) >= 5:
+            # Format size columns (assuming standard df -h output)
+            parts[1] = format_bytes(
+                parts[1]
+                .upper()
+                .replace("G", "GB")
+                .replace("M", "MB")
+                .replace("K", "KB")
+                .replace("B", "")
+                .replace("I", "")
+                .strip()
+            )
+            parts[2] = format_bytes(
+                parts[2]
+                .upper()
+                .replace("G", "GB")
+                .replace("M", "MB")
+                .replace("K", "KB")
+                .replace("B", "")
+                .replace("I", "")
+                .strip()
+            )
+            parts[3] = format_bytes(
+                parts[3]
+                .upper()
+                .replace("G", "GB")
+                .replace("M", "MB")
+                .replace("K", "KB")
+                .replace("B", "")
+                .replace("I", "")
+                .strip()
+            )
+
+            # Reconstruct the line with formatted sizes
+            result.append(" ".join(parts))
+        else:
+            result.append(line)
+
+    return "\n".join(result)
+
+
+def get_os_specific_info():
+    """Get OS-specific system information"""
+    system = platform.system().lower()
+
+    if system == "darwin":  # macOS
+        return {
+            "cpu": "sysctl -n machdep.cpu.brand_string",
+            "cpu_cores": "sysctl -n hw.ncpu",
+            "memory": "vm_stat",
+            "disks": "df -h",
+            "os_version": "sw_vers",
+            "hostname": "hostname",
+            "uptime": "uptime",
+        }
+    elif system == "linux":
+        return {
+            "cpu": 'cat /proc/cpuinfo | grep "model name" | head -n 1 | cut -d":" -f2',
+            "cpu_cores": "nproc",
+            "memory": "free -h",
+            "disks": "df -h",
+            "os_version": "cat /etc/os-release",
+            "hostname": "hostname",
+            "uptime": "uptime",
+        }
+    elif system == "windows":
+        return {
+            "cpu": "wmic cpu get name",
+            "cpu_cores": "wmic cpu get NumberOfCores",
+            "memory": "wmic OS get TotalVisibleMemorySize,FreePhysicalMemory /Value",
+            "disks": "wmic logicaldisk get size,freespace,caption",
+            "os_version": 'systeminfo | findstr /B /C:"OS Name" /C:"OS Version"',
+            "hostname": "hostname",
+            "uptime": "wmic os get lastbootuptime",
+        }
+    else:
+        return None
+
+
+def format_uptime(uptime_str, system):
+    """Format uptime string based on OS"""
+    if system == "darwin" or system == "linux":
+        # Example: ' 8:53  up 1 day,  3:45, 2 users, load averages: 2.22 2.41 2.35'
+        parts = uptime_str.split(",")
+        if "up" in parts[0]:
+            return "Uptime: " + parts[0].split("up", 1)[1].strip()
+    return uptime_str
+
+
+@click.command()
+def system_info():
+    """Display system information including CPU, RAM, and disk usage"""
+    system = platform.system().lower()
+    commands = get_os_specific_info()
+
+    if not commands:
+        click.echo("Unsupported operating system")
+        return
+
+    # System Information
+    click.echo("=" * 40 + " System Information " + "=" * 40)
+    click.echo(f"System: {platform.system()} {platform.release()}")
+    click.echo(f"Node Name: {run_command(commands['hostname'])}")
+    click.echo(f"Machine: {platform.machine()}")
+    click.echo(
+        f"Processor: {platform.processor() or run_command(commands['cpu']).strip()}"
+    )
+
+    # OS Version
+    click.echo("\n" + "=" * 40 + " OS Version " + "=" * 40)
+    click.echo(run_command(commands["os_version"]))
+
+    # Uptime
+    click.echo("\n" + "=" * 40 + " Uptime " + "=" * 40)
+    uptime = run_command(commands["uptime"])
+    click.echo(format_uptime(uptime, system))
+
+    # CPU Information
+    click.echo("\n" + "=" * 40 + " CPU Info " + "=" * 40)
+    cpu_cores = run_command(commands["cpu_cores"]).strip()
+    click.echo(f"CPU Cores: {cpu_cores}")
+
+    if system == "darwin" or system == "linux":
+        cpu_info = run_command(commands["cpu"]).strip()
+        click.echo(f"CPU: {cpu_info}")
+
+        # CPU Usage (simplified for cross-platform)
+        if system == "darwin":
+            load_avg = run_command("sysctl -n vm.loadavg").strip()
+            click.echo(f"Load Average: {load_avg}")
+        elif system == "linux":
+            load_avg = run_command("cat /proc/loadavg").strip()
+            click.echo(f"Load Average: {load_avg}")
+
+    # Memory Information
+    click.echo("\n" + "=" * 40 + " Memory Information " + "=" * 40)
+    if system == "darwin":
+        mem_info = run_command("vm_stat")
+        click.echo(parse_vm_stat(mem_info))
+    elif system == "linux":
+        mem_info = run_command("free -b")  # Get bytes for consistent formatting
+        lines = mem_info.split("\n")
+        if len(lines) > 1:
+            headers = lines[0].split()
+            values = lines[1].split()
+            if len(values) >= 7:  # For Mem: line
+                total = int(values[1])
+                used = int(values[2])
+                free = int(values[3])
+                click.echo(
+                    f"Total: {format_bytes(total)}\n"
+                    f"Used:  {format_bytes(used)}\n"
+                    f"Free:  {format_bytes(free)}\n"
+                    f"Usage: {used/total*100:.1f}%"
+                )
+    elif system == "windows":
+        mem_info = run_command(
+            "wmic OS get TotalVisibleMemorySize,FreePhysicalMemory /Value"
+        )
+        if "TotalVisibleMemorySize" in mem_info and "FreePhysicalMemory" in mem_info:
+            try:
+                total = (
+                    int(mem_info.split("TotalVisibleMemorySize=")[1].split("\n")[0])
+                    * 1024
+                )  # KB to bytes
+                free = (
+                    int(mem_info.split("FreePhysicalMemory=")[1].split("\n")[0]) * 1024
+                )  # KB to bytes
+                used = total - free
+                click.echo(
+                    f"Total: {format_bytes(total)}\n"
+                    f"Used:  {format_bytes(used)}\n"
+                    f"Free:  {format_bytes(free)}\n"
+                    f"Usage: {used/total*100:.1f}%"
+                )
+            except (IndexError, ValueError):
+                click.echo(mem_info)
+        else:
+            click.echo(mem_info)
+
+    # Disk Information
+    click.echo("\n" + "=" * 40 + " Disk Information " + "=" * 40)
+    if system == "windows":
+        disks = run_command("wmic logicaldisk get size,freespace,caption")
+        if "Caption" in disks:
+            lines = disks.split("\n")
+            result = [
+                "{:<5} {:<15} {:<15} {:<15} {:<10}".format(
+                    "Drive", "Total Space", "Free Space", "Used Space", "% Used"
+                )
+            ]
+            for line in lines[1:]:
+                parts = line.strip().split()
+                if len(parts) >= 3:
+                    drive = parts[0]
+                    try:
+                        size = int(parts[1])
+                        free = int(parts[2])
+                        used = size - free
+                        pct_used = (used / size) * 100 if size > 0 else 0
+                        result.append(
+                            "{:<5} {:<15} {:<15} {:<15} {:.1f}%".format(
+                                drive,
+                                format_bytes(size),
+                                format_bytes(free),
+                                format_bytes(used),
+                                pct_used,
+                            )
+                        )
+                    except (ValueError, IndexError):
+                        continue
+            click.echo("\n".join(result))
+        else:
+            click.echo(disks)
+    else:
+        disks = run_command(
+            "df -h"
+            if system != "windows"
+            else "wmic logicaldisk get size,freespace,caption"
+        )
+        click.echo(parse_df_output(disks))
+
+
+# Add aliases for the command
+sysinfo = system_info
+si = system_info

helper/commands/venv.py

@@ -0,0 +1,130 @@
+"""
+Virtual environment management commands for the helper CLI.
+
+This module provides commands to manage Python virtual environments,
+including activating and deactivating them from the command line.
+"""
+
+import os
+import sys
+
+import click
+
+
+def find_virtualenv(path=None):
+    """Find virtual environment in the given path or current directory.
+
+    Args:
+        path (str, optional): Path to search for virtual environment.
+            Defaults to current directory.
+
+    Returns:
+        str: Path to the activate script if found, None otherwise.
+    """
+    if path is None:
+        path = os.getcwd()
+
+    # Check common virtual environment directories
+    venv_dirs = ["venv", ".venv"]
+    for venv_dir in venv_dirs:
+        activate_script = os.path.join(path, venv_dir, "bin", "activate")
+        if os.path.exists(activate_script):
+            return activate_script
+
+    # If not found in current directory, try parent directories
+    parent = os.path.dirname(path)
+    if parent != path:  # Prevent infinite recursion
+        return find_virtualenv(parent)
+
+    return None
+
+
+def source_virtualenv(venv_path=None):
+    """Source a virtual environment.
+
+    Args:
+        venv_path (str, optional): Path to the virtual environment.
+            If None, search in current and parent directories.
+    """
+    if venv_path is None:
+        activate_script = find_virtualenv()
+        if not activate_script:
+            click.echo(
+                "Error: No virtual environment found in current or parent directories.",
+                err=True,
+            )
+            click.echo(
+                "Please specify the path to the virtual environment or "
+                "create one with 'python -m venv venv'"
+            )
+            sys.exit(1)
+    else:
+        # If path is provided, check if it's a directory or activate script
+        if os.path.isdir(venv_path):
+            # If it's a directory, look for bin/activate
+            activate_script = os.path.join(venv_path, "bin", "activate")
+            if not os.path.exists(activate_script):
+                click.echo(f"Error: No activate script found in {venv_path}", err=True)
+                sys.exit(1)
+        elif os.path.isfile(venv_path):
+            # If it's a file, use it directly
+            activate_script = venv_path
+        else:
+            click.echo(f"Error: {venv_path} is not a valid file or directory", err=True)
+            sys.exit(1)
+
+    # Get the absolute path to the activate script
+    activate_script = os.path.abspath(activate_script)
+
+    # Print the command to source the virtual environment
+    # The user needs to run this with 'eval $(h venv source [path])' or
+    # 'source <(h venv source [path])'
+    click.echo(f'source "{activate_script}"')
+    venv_dir = os.path.dirname(os.path.dirname(activate_script))
+    click.echo(f"# Virtual environment activated: {venv_dir}", err=True)
+
+
+def deactivate_virtualenv():
+    """Print the command to deactivate the current virtual environment."""
+    click.echo("deactivate")
+    click.echo("# Virtual environment deactivated", err=True)
+
+
+@click.group()
+def venv():
+    """Manage Python virtual environments (v0.1.19)."""
+
+
+@venv.command()
+@click.argument("path", required=False)
+def source(path):
+    """Source a Python virtual environment.
+
+    If no path is provided, searches for a virtual environment in the current or parent directories.
+    Looks for 'venv' first, then '.venv'.
+
+    Usage:
+        h venv source [PATH]  # Source the specified virtual environment or auto-detect
+        eval $(h venv source)  # In bash/zsh to activate the virtual environment
+        source <(h venv source)  # Alternative syntax for bash/zsh
+    """
+    source_virtualenv(path)
+
+
+@venv.command()
+def deactivate():
+    """Deactivate the current virtual environment.
+
+    Usage:
+        h venv deactivate  # Show the deactivate command
+        eval $(h venv deactivate)  # In bash/zsh to deactivate the virtual environment
+    """
+    deactivate_virtualenv()
+
+
+# Add short aliases
+s = source
+d = deactivate
+
+# Add the commands to the module
+__all__ = ["venv", "source", "deactivate", "s", "d"]

helper/main.py

@@ -1,38 +1,51 @@
 import click
 import logging
 import sys
-from .commands import internal_ip, public_ip, arch, nixos, docker
+import subprocess
+from . import __version__
+from .commands import (
+    internal_ip,
+    public_ip,
+    arch,
+    nixos,
+    docker,
+    speed,
+    system_info,
+    venv,
+    file,
+)
+
 
 class VerbosityCommand(click.Command):
     def parse_args(self, ctx, args):
         # Initialize verbosity from context if it exists
         ctx.ensure_object(dict)
-        verbose = ctx.obj.get('verbosity', 0)
-        
+        verbose = ctx.obj.get("verbosity", 0)
+
         # Process args for verbosity flags
         new_args = []
         i = 0
         while i < len(args):
             arg = args[i]
-            if arg == '--verbose':
+            if arg == "--verbose":
                 verbose += 1
-            elif arg.startswith('-v'):
-                verbose += arg.count('v')
+            elif arg.startswith("-v"):
+                verbose += arg.count("v")
             else:
                 new_args.append(arg)
             i += 1
-        
+
         # Update verbosity in context
-        ctx.obj['verbosity'] = verbose
-        
+        ctx.obj["verbosity"] = verbose
+
         # Set up logging
         self._setup_logging(verbose)
-        
+
         # Continue with normal argument parsing
         return super().parse_args(ctx, new_args)
-    
+
     def _setup_logging(self, verbose):
-        logger = logging.getLogger('docker-helper')
+        logger = logging.getLogger("docker-helper")
         if verbose >= 3:
             logger.setLevel(logging.DEBUG)
         elif verbose == 2:
@@ -42,29 +55,30 @@ class VerbosityCommand(click.Command):
         else:
             logger.setLevel(logging.ERROR)
 
+
 class VerbosityGroup(click.Group):
     def make_context(self, info_name, args, parent=None, **extra):
         # Pre-process args to find verbosity flags
         verbose = 0
         processed_args = []
-        
+
         for arg in args:
-            if arg == '--verbose':
+            if arg == "--verbose":
                 verbose += 1
-            elif arg.startswith('-v'):
-                verbose += arg.count('v')
+            elif arg.startswith("-v"):
+                verbose += arg.count("v")
             else:
                 processed_args.append(arg)
-        
+
         # Create context with processed args
         ctx = super().make_context(info_name, processed_args, parent=parent, **extra)
-        
+
         # Set verbosity in context
         ctx.ensure_object(dict)
-        ctx.obj['verbosity'] = verbose
-        
+        ctx.obj["verbosity"] = verbose
+
         # Set up logging
-        logger = logging.getLogger('docker-helper')
+        logger = logging.getLogger("docker-helper")
         if verbose >= 3:
             logger.setLevel(logging.DEBUG)
         elif verbose == 2:
@@ -73,24 +87,48 @@ class VerbosityGroup(click.Group):
             logger.setLevel(logging.WARNING)
         else:
             logger.setLevel(logging.ERROR)
-        
+
         return ctx
 
-@click.group(cls=VerbosityGroup)
+
+@click.group(
+    cls=VerbosityGroup,
+    context_settings={
+        "help_option_names": ["-h", "--help"],
+        "token_normalize_func": lambda x: "helper" if x == "h" else x,
+    },
+)
+@click.version_option(__version__, "-V", "--version", message="%(prog)s version %(version)s")
 def cli():
-    """Helper CLI - quick system info"""
+    """Helper CLI - quick system info (v{})
+    
+    You can use 'h' as a shortcut for 'helper' command.
+    Example: h docker ps
+    
+    For detailed help on a specific command, use: helper <command> --help
+    """.format(__version__)
     # Set up basic logging
     logging.basicConfig(
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        level=logging.ERROR
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        level=logging.ERROR,
     )
 
+
 # Register all commands
 cli.add_command(internal_ip.internal_ip)
 cli.add_command(public_ip.public_ip)
 cli.add_command(arch.arch)
 cli.add_command(nixos.nixos, name="nixos")
 cli.add_command(docker.docker, name="docker")
+cli.add_command(speed.speed, name="speed")
+cli.add_command(speed.speed, name="sp")
+cli.add_command(system_info.system_info, name="system-info")
+cli.add_command(system_info.system_info, name="sysinfo")
+cli.add_command(system_info.system_info, name="si")
+cli.add_command(venv.venv, name="v")
+cli.add_command(file.file(), name="file")
+cli.add_command(file.file(), name="f")
+
 
 @cli.command()
 @click.pass_context
@@ -103,7 +141,10 @@ def all(ctx):
     click.echo("\n=== Architecture ===")
     ctx.invoke(arch.arch)
     click.echo("\n=== NixOS ===")
-    ctx.invoke(nixos.nixos, 'version')
+    ctx.invoke(nixos.nixos, "version")
+    click.echo("\n=== System Info ===")
+    ctx.invoke(system_info.system_info)
+
 
 if __name__ == "__main__":
     cli()

helper/table.py

@@ -0,0 +1,29 @@
+import click
+import json
+import yaml
+from tabulate import tabulate
+
+data = [{"name": "Huy", "age": 23}, {"name": "An", "age": 25}]
+
+
+@click.command()
+@click.option(
+    "--format",
+    "-f",
+    type=click.Choice(["json", "yaml", "table", "text"]),
+    default="table",
+)
+def show(format):
+    if format == "json":
+        click.echo(json.dumps(data, indent=2))
+    elif format == "yaml":
+        click.echo(yaml.dump(data))
+    elif format == "table":
+        click.echo(tabulate(data, headers="keys"))
+    else:
+        for item in data:
+            click.echo(f"{item['name']} - {item['age']}")
+
+
+if __name__ == "__main__":
+    show()