helper-cli 0.1.23__tar.gz → 0.1.25__tar.gz

{helper_cli-0.1.23 → helper_cli-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helper-cli
-Version: 0.1.23
+Version: 0.1.25
 Summary: Simple system info CLI
 Author-email: Huy Nguyen <huy.ntq02@gmail.com>
 License-Expression: GPL-3.0-or-later

helper_cli-0.1.25/helper/commands/__init__.py

@@ -0,0 +1,4 @@
+# Initialize commands package
+from .env import env as env_cmd
+
+__all__ = ['env_cmd']

helper_cli-0.1.25/helper/commands/all_info.py

@@ -0,0 +1,36 @@
+"""Command to display all system information."""
+import click
+from .. import commands
+
+
+def register_all_command(cli):
+    """Register the 'all' command with the CLI.
+    
+    Args:
+        cli: The main CLI group
+    """
+    @cli.command()
+    @click.pass_context
+    def all(ctx):
+        """Show all info"""
+        # Get the parent command (the main CLI group)
+        parent = ctx.parent.command
+        
+        click.echo("=== Internal IP ===")
+        ctx.invoke(parent.get_command(ctx, "ip"))
+        
+        click.echo("\n=== Public IP ===")
+        ctx.invoke(parent.get_command(ctx, "pubip"))
+        
+        click.echo("\n=== Architecture ===")
+        ctx.invoke(parent.get_command(ctx, "arch"))
+        
+        # NixOS command doesn't accept arguments, so we'll just run it directly
+        click.echo("\n=== NixOS (Skipped) ==="
+                 "\nNote: NixOS version check skipped as it requires direct execution"
+                 "\nTo check NixOS version, run: h nix")
+        
+        click.echo("\n=== System Info ===")
+        ctx.invoke(parent.get_command(ctx, "si"))
+
+    return all

helper_cli-0.1.25/helper/commands/arch.py

@@ -0,0 +1,20 @@
+import click
+from helper import __version__
+from helper.utils import run_cmd
+
+
+@click.command()
+def arch():
+    """Display system architecture information.
+    
+    Shows the machine hardware name, which is useful for determining
+    if you're running on x86_64, arm64, or other architectures.
+    
+    Equivalent to running 'uname -m' in the terminal.
+    
+    Example:
+        $ h arch
+        arm64
+    """
+    cmd = "uname -m"
+    run_cmd(cmd)

{helper_cli-0.1.23 → helper_cli-0.1.25}/helper/commands/docker.py

@@ -195,17 +195,22 @@ def get_verbosity(ctx: click.Context) -> Verbosity:
 )
 @click.pass_context
 def docker(ctx, verbose):
-    """Docker management commands (v{}).
+    """Docker container and image management.
     
-    This command provides various Docker management subcommands including:
-    - ps: List containers
-    - run: Run a command in a new container
-    - rm: Remove one or more containers
-    - rmi: Remove one or more images
-    - url: Show containers with their HTTP/HTTPS URLs
+    Manage Docker containers and images with subcommands for common operations.
     
-    Use --help with any subcommand for more information.
-    """.format(__version__)
+    Subcommands:
+      ps    List containers
+      run   Run a command in a new container
+      rm    Remove one or more containers
+      rmi   Remove one or more images
+      url   Show containers with their HTTP/HTTPS URLs
+    
+    Examples:
+      h d ps            # List running containers
+      h d run nginx     # Run an nginx container
+      h d rm container  # Remove a container
+    """
     ctx.ensure_object(dict)
 
     # Get verbosity from parent context if it exists, otherwise use the flag value

helper_cli-0.1.25/helper/commands/env.py

@@ -0,0 +1,85 @@
+"""Environment variable management commands."""
+import os
+import click
+from pathlib import Path
+from ..env_manager import get_env, set_env, load_env, CONFIG_DIR, ENV_FILE
+
+
+@click.group(name="env", help="Manage environment variables.")
+def env():
+    """Environment variable management commands."""
+    pass
+
+
+@env.command(name="list")
+def list_env_cmd():
+    """List all environment variables in a formatted table."""
+    env_vars = load_env()
+    if not env_vars:
+        click.echo("No environment variables set.")
+        return
+    
+    # Find the maximum key length for alignment
+    max_key_len = max(len(str(k)) for k in env_vars.keys())
+    
+    # Print header
+    click.echo("Environment Variables:")
+    click.echo("-" * (max_key_len + 40))  # 40 is a rough estimate for value + padding
+    
+    # Print each variable
+    for key, value in sorted(env_vars.items()):
+        click.echo(f"{key.ljust(max_key_len)} : {value}")
+    
+    click.echo()  # Add a newline at the end
+
+
+@env.command(name="get")
+@click.argument("key", required=False)
+def get_env_cmd(key):
+    """Get environment variable(s).
+    
+    If no key is provided, all environment variables will be shown as a table.
+    """
+    if not key:
+        return list_env_cmd()
+        
+    env_vars = load_env()
+    value = env_vars.get(key, "")
+    click.echo(f"{key}={value}")
+
+
+@env.command(name="set")
+@click.argument("key")
+@click.argument("value")
+def set_env_cmd(key, value):
+    """Set an environment variable."""
+    set_env(key, value)
+    click.echo(f"Set {key}={value}")
+
+
+@env.command(name="unset")
+@click.argument("key")
+def unset_env_cmd(key):
+    """Unset an environment variable."""
+    env_vars = load_env()
+    if key in env_vars:
+        del env_vars[key]
+        save_env(env_vars)
+        if key in os.environ:
+            del os.environ[key]
+        click.echo(f"Unset {key}")
+    else:
+        click.echo(f"Variable {key} not found", err=True)
+
+
+def save_env(env_vars):
+    """Save environment variables to .env file.
+    
+    Args:
+        env_vars: Dictionary of environment variables to save.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    
+    with open(ENV_FILE, 'w', encoding='utf-8') as f:
+        for key, value in env_vars.items():
+            f.write(f'{key}="{value}"\n')

{helper_cli-0.1.23 → helper_cli-0.1.25}/helper/commands/internal_ip.py

@@ -24,12 +24,17 @@ def get_internal_ip():
 
 @click.command()
 def internal_ip():
-    """Show local/internal IP address.
+    """Display the local/internal IP address.
     
-    Version: {}
+    This command shows the internal (LAN) IP address of your machine.
+    It automatically detects the correct network interface based on your OS.
     
-    Displays the internal IP address of the current machine.
-    The command automatically detects the operating system and uses the
-    appropriate method to retrieve the IP address.
-    """.format(__version__)
-    get_internal_ip()
+    Examples:
+        $ h ip
+        192.168.1.100
+        
+    Note: On multi-homed systems, this shows the primary network interface's IP.
+    """
+    ip = get_internal_ip()
+    if ip:
+        click.echo(ip)

{helper_cli-0.1.23 → helper_cli-0.1.25}/helper/commands/nixos.py

@@ -43,7 +43,7 @@ def get_nixos_version():
 
 @click.group()
 def nixos():
-    """NixOS related commands (v0.1.19)."""
+    """NixOS related commands."""
     if not check_nixos():
         click.echo(
             "Warning: Not running on NixOS. Some commands may not work as expected.",

helper_cli-0.1.25/helper/commands/public_ip.py

@@ -0,0 +1,20 @@
+import click
+from helper import __version__
+from helper.utils import run_cmd
+
+
+@click.command()
+def public_ip():
+    """Display the public (external) IP address.
+    
+    This command retrieves and displays your public IP address as seen from the internet.
+    It's useful for checking your current external network identity.
+    
+    Examples:
+        $ h pubip
+        203.0.113.45
+        
+    Note: Requires an active internet connection. Uses ifconfig.me service by default.
+    """
+    cmd = "curl -s ifconfig.me"
+    run_cmd(cmd)

{helper_cli-0.1.23 → helper_cli-0.1.25}/helper/commands/venv.py

@@ -92,7 +92,7 @@ def deactivate_virtualenv():
 
 @click.group()
 def venv():
-    """Manage Python virtual environments (v0.1.19)."""
+    """Manage Python virtual environments."""
 
 
 @venv.command()

helper_cli-0.1.23/helper/main.py → helper_cli-0.1.25/helper/commands/verbosity.py

@@ -1,22 +1,11 @@
-import click
+"""Verbosity handling for CLI commands."""
 import logging
-import sys
-import subprocess
-from . import __version__
-from .commands import (
-    internal_ip,
-    public_ip,
-    arch,
-    nixos,
-    docker,
-    speed,
-    system_info,
-    venv,
-    file,
-)
+import click
 
 
 class VerbosityCommand(click.Command):
+    """Custom click.Command that handles verbosity flags."""
+
     def parse_args(self, ctx, args):
         # Initialize verbosity from context if it exists
         ctx.ensure_object(dict)
@@ -29,7 +18,7 @@ class VerbosityCommand(click.Command):
             arg = args[i]
             if arg == "--verbose":
                 verbose += 1
-            elif arg.startswith("-v"):
+            elif arg.startswith("-"):
                 verbose += arg.count("v")
             else:
                 new_args.append(arg)
@@ -45,6 +34,11 @@ class VerbosityCommand(click.Command):
         return super().parse_args(ctx, new_args)
 
     def _setup_logging(self, verbose):
+        """Configure logging based on verbosity level.
+        
+        Args:
+            verbose (int): Verbosity level (0-3)
+        """
         logger = logging.getLogger("docker-helper")
         if verbose >= 3:
             logger.setLevel(logging.DEBUG)
@@ -57,6 +51,8 @@ class VerbosityCommand(click.Command):
 
 
 class VerbosityGroup(click.Group):
+    """Custom click.Group that handles verbosity flags for command groups."""
+
     def make_context(self, info_name, args, parent=None, **extra):
         # Pre-process args to find verbosity flags
         verbose = 0
@@ -65,7 +61,7 @@ class VerbosityGroup(click.Group):
         for arg in args:
             if arg == "--verbose":
                 verbose += 1
-            elif arg.startswith("-v"):
+            elif arg.startswith("-"):
                 verbose += arg.count("v")
             else:
                 processed_args.append(arg)
@@ -89,62 +85,3 @@ class VerbosityGroup(click.Group):
             logger.setLevel(logging.ERROR)
 
         return ctx
-
-
-@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 (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,
-    )
-
-
-# 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
-def all(ctx):
-    """Show all info"""
-    click.echo("=== Internal IP ===")
-    ctx.invoke(internal_ip.internal_ip)
-    click.echo("\n=== Public IP ===")
-    ctx.invoke(public_ip.public_ip)
-    click.echo("\n=== Architecture ===")
-    ctx.invoke(arch.arch)
-    click.echo("\n=== NixOS ===")
-    ctx.invoke(nixos.nixos, "version")
-    click.echo("\n=== System Info ===")
-    ctx.invoke(system_info.system_info)
-
-
-if __name__ == "__main__":
-    cli()

helper_cli-0.1.25/helper/env_manager.py

@@ -0,0 +1,92 @@
+"""Environment variable management for helper tool."""
+import os
+from pathlib import Path
+from typing import Dict, Optional
+
+# Default environment variables
+DEFAULT_ENV = {
+    "AUTHOR": "nguyenhuy158",
+    "REPO": "github",
+    "ODOO_CONTAINER": "fnp-odoo-1",
+}
+
+# Environment file path
+CONFIG_DIR = Path.home() / ".config" / "helper"
+ENV_FILE = CONFIG_DIR / ".env"
+
+
+def ensure_config_dir() -> None:
+    """Ensure the config directory exists."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_env() -> Dict[str, str]:
+    """Load environment variables from .env file or create with defaults.
+    
+    Returns:
+        Dict containing the environment variables.
+    """
+    # Ensure config directory exists
+    ensure_config_dir()
+    
+    env_vars = DEFAULT_ENV.copy()
+    
+    # Load existing .env file if it exists
+    if ENV_FILE.exists():
+        with open(ENV_FILE, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    try:
+                        key, value = line.split('=', 1)
+                        env_vars[key.strip()] = value.strip().strip('"\'')
+                    except ValueError:
+                        continue
+    else:
+        # Create .env file with default values
+        save_env(env_vars)
+    
+    # Update os.environ with loaded values
+    os.environ.update(env_vars)
+    
+    return env_vars
+
+
+def save_env(env_vars: Dict[str, str]) -> None:
+    """Save environment variables to .env file.
+    
+    Args:
+        env_vars: Dictionary of environment variables to save.
+    """
+    ensure_config_dir()
+    
+    with open(ENV_FILE, 'w', encoding='utf-8') as f:
+        for key, value in env_vars.items():
+            f.write(f'{key}="{value}"\n')
+
+
+def get_env(key: str, default: Optional[str] = None) -> Optional[str]:
+    """Get an environment variable value.
+    
+    Args:
+        key: The environment variable name.
+        default: Default value if key doesn't exist.
+        
+    Returns:
+        The value of the environment variable or default if not found.
+    """
+    env_vars = load_env()
+    return env_vars.get(key, default)
+
+
+def set_env(key: str, value: str) -> None:
+    """Set an environment variable and save to .env file.
+    
+    Args:
+        key: The environment variable name.
+        value: The value to set.
+    """
+    env_vars = load_env()
+    env_vars[key] = value
+    save_env(env_vars)
+    os.environ[key] = value

helper_cli-0.1.25/helper/main.py

@@ -0,0 +1,74 @@
+import click
+import logging
+import sys
+import subprocess
+from pathlib import Path
+from . import __version__
+from .env_manager import load_env
+from .commands import (
+    internal_ip,
+    public_ip,
+    arch,
+    nixos,
+    docker,
+    speed,
+    system_info,
+    venv,
+    file,
+    verbosity,
+    all_info,
+    env_cmd,
+)
+
+
+# Import verbosity classes from the verbosity module
+VerbosityCommand = verbosity.VerbosityCommand
+VerbosityGroup = verbosity.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 (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__)
+    # Initialize environment variables
+    load_env()
+    
+    # Set up basic logging
+    logging.basicConfig(
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        level=logging.ERROR,
+    )
+
+
+# Register all commands
+# Keep only short versions of commands where duplicates exist
+cli.add_command(internal_ip.internal_ip, name="ip")
+cli.add_command(public_ip.public_ip, name="pubip")
+cli.add_command(arch.arch, name="arch")
+cli.add_command(nixos.nixos, name="nix")
+cli.add_command(docker.docker, name="d")
+cli.add_command(speed.speed, name="sp")
+cli.add_command(system_info.system_info, name="si")
+cli.add_command(venv.venv, name="v")
+cli.add_command(file.file(), name="f")
+cli.add_command(env_cmd, name="env")
+
+
+# Register the all command
+all_info.register_all_command(cli)
+
+
+if __name__ == "__main__":
+    cli()

{helper_cli-0.1.23 → helper_cli-0.1.25}/helper_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helper-cli
-Version: 0.1.23
+Version: 0.1.25
 Summary: Simple system info CLI
 Author-email: Huy Nguyen <huy.ntq02@gmail.com>
 License-Expression: GPL-3.0-or-later

{helper_cli-0.1.23 → helper_cli-0.1.25}/helper_cli.egg-info/SOURCES.txt

@@ -1,13 +1,16 @@
 README.md
 pyproject.toml
 helper/__init__.py
+helper/env_manager.py
 helper/main.py
 helper/my_speedtest.py
 helper/table.py
 helper/utils.py
 helper/commands/__init__.py
+helper/commands/all_info.py
 helper/commands/arch.py
 helper/commands/docker.py
+helper/commands/env.py
 helper/commands/file.py
 helper/commands/internal_ip.py
 helper/commands/nixos.py
@@ -15,6 +18,7 @@ helper/commands/public_ip.py
 helper/commands/speed.py
 helper/commands/system_info.py
 helper/commands/venv.py
+helper/commands/verbosity.py
 helper_cli.egg-info/PKG-INFO
 helper_cli.egg-info/SOURCES.txt
 helper_cli.egg-info/dependency_links.txt

{helper_cli-0.1.23 → helper_cli-0.1.25}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "helper-cli"
-version = "0.1.23"
+version = "0.1.25"
 description = "Simple system info CLI"
 readme = "README.md"
 requires-python = ">=3.8"

helper_cli-0.1.23/helper/commands/__init__.py

@@ -1 +0,0 @@
-# Initialize commands package

helper_cli-0.1.23/helper/commands/arch.py

@@ -1,14 +0,0 @@
-import click
-from helper import __version__
-from helper.utils import run_cmd
-
-
-@click.command()
-def arch():
-    """Show CPU architecture information.
-    
-    Version: {}
-    Displays the machine hardware name (equivalent to 'uname -m').
-    """.format(__version__)
-    cmd = "uname -m"
-    run_cmd(cmd)

helper_cli-0.1.23/helper/commands/public_ip.py

@@ -1,17 +0,0 @@
-import click
-from helper import __version__
-from helper.utils import run_cmd
-
-
-@click.command()
-def public_ip():
-    """Show public IP address.
-    
-    Version: {}
-    
-    Retrieves and displays the public IP address of the current machine.
-    Uses https://ifconfig.me as the primary service and falls back to curl
-    if the primary method fails.
-    """.format(__version__)
-    cmd = "curl -s ifconfig.me"
-    run_cmd(cmd)