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

helper/commands/file.py

@@ -0,0 +1,202 @@
+"""File management commands."""
+import os
+import time
+import click
+from pathlib import Path
+from typing import List, Optional, Tuple, Callable
+from datetime import datetime
+
+
+def get_sorted_files(
+    directory: str, 
+    extension: Optional[str] = None, 
+    sort_key: Callable[[os.DirEntry], float] = None,
+    reverse: bool = False
+) -> List[Tuple[os.DirEntry, float]]:
+    """Get files sorted by specified key.
+    
+    Args:
+        directory: Directory to search in
+        extension: Optional file extension to filter by (without dot)
+        sort_key: Function to extract sort key from DirEntry
+        reverse: If True, sort in descending order
+        
+    Returns:
+        List of (file_entry, sort_key) tuples
+    """
+    if not os.path.isdir(directory):
+        raise click.BadParameter(f"Directory not found: {directory}")
+    
+    files = []
+    with os.scandir(directory) as it:
+        for entry in it:
+            if not entry.is_file():
+                continue
+                
+            if extension and not entry.name.lower().endswith(f".{extension.lower()}"):
+                continue
+                
+            if sort_key:
+                try:
+                    key = sort_key(entry)
+                    files.append((entry, key))
+                except (OSError, ValueError) as e:
+                    continue
+            else:
+                files.append((entry, 0))
+    
+    # Sort by the sort key
+    files.sort(key=lambda x: x[1], reverse=reverse)
+    return files
+
+
+def format_file_info(entry: os.DirEntry, size: bool = True, modified: bool = True) -> str:
+    """Format file information for display."""
+    info = []
+    if size:
+        try:
+            size_bytes = entry.stat().st_size
+            size_str = human_readable_size(size_bytes)
+            info.append(f"{size_str:>10}")
+        except OSError:
+            info.append(" " * 10)
+    
+    if modified:
+        try:
+            mtime = entry.stat().st_mtime
+            mtime_str = datetime.fromtimestamp(mtime).strftime('%Y-%m-%d %H:%M:%S')
+            info.append(mtime_str)
+        except OSError:
+            info.append(" " * 19)
+    
+    info.append(entry.name)
+    return "  ".join(info)
+
+
+def human_readable_size(size_bytes: int) -> str:
+    """Convert size in bytes to human readable format."""
+    if size_bytes == 0:
+        return "0B"
+    
+    units = ['B', 'KB', 'MB', 'GB', 'TB']
+    unit_idx = 0
+    size = float(size_bytes)
+    
+    while size >= 1024 and unit_idx < len(units) - 1:
+        size /= 1024
+        unit_idx += 1
+    
+    return f"{size:.1f}{units[unit_idx]}"
+
+
+@click.group(name="file")
+@click.option(
+    "--directory",
+    "-d",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, resolve_path=True),
+    default=".",
+    help="Directory to search in (default: current directory)",
+)
+@click.option(
+    "--extension",
+    "-e",
+    type=str,
+    help="Filter by file extension (without dot)",
+)
+@click.option(
+    "--size",
+    "-s",
+    is_flag=True,
+    help="Show file sizes",
+)
+@click.option(
+    "--modified",
+    "-m",
+    is_flag=True,
+    help="Show last modified time",
+)
+@click.pass_context
+def file_cmd(ctx: click.Context, directory: str, extension: str, size: bool, modified: bool) -> None:
+    """File management and processing commands."""
+    ctx.ensure_object(dict)
+    ctx.obj["directory"] = directory
+    ctx.obj["extension"] = extension
+    ctx.obj["show_size"] = size
+    ctx.obj["show_modified"] = modified
+
+
+@file_cmd.command(name="newest")
+@click.option(
+    "--count",
+    "-n",
+    type=int,
+    default=1,
+    help="Number of newest files to show (default: 1)",
+)
+@click.pass_context
+def newest_files(ctx: click.Context, count: int) -> None:
+    """Show the newest files in the directory."""
+    directory = ctx.obj["directory"]
+    extension = ctx.obj["extension"]
+    show_size = ctx.obj["show_size"]
+    show_modified = ctx.obj["show_modified"]
+    
+    try:
+        files = get_sorted_files(
+            directory=directory,
+            extension=extension,
+            sort_key=lambda e: e.stat().st_mtime,
+            reverse=True
+        )
+        
+        if not files:
+            click.echo("No files found.")
+            return
+            
+        click.echo(f"Newest files in {directory}:")
+        for i, (entry, _) in enumerate(files[:count], 1):
+            click.echo(f"{i}. {format_file_info(entry, show_size, show_modified)}")
+            
+    except Exception as e:
+        raise click.ClickException(str(e))
+
+
+@file_cmd.command(name="oldest")
+@click.option(
+    "--count",
+    "-n",
+    type=int,
+    default=1,
+    help="Number of oldest files to show (default: 1)",
+)
+@click.pass_context
+def oldest_files(ctx: click.Context, count: int) -> None:
+    """Show the oldest files in the directory."""
+    directory = ctx.obj["directory"]
+    extension = ctx.obj["extension"]
+    show_size = ctx.obj["show_size"]
+    show_modified = ctx.obj["show_modified"]
+    
+    try:
+        files = get_sorted_files(
+            directory=directory,
+            extension=extension,
+            sort_key=lambda e: e.stat().st_mtime,
+            reverse=False
+        )
+        
+        if not files:
+            click.echo("No files found.")
+            return
+            
+        click.echo(f"Oldest files in {directory}:")
+        for i, (entry, _) in enumerate(files[:count], 1):
+            click.echo(f"{i}. {format_file_info(entry, show_size, show_modified)}")
+            
+    except Exception as e:
+        raise click.ClickException(str(e))
+
+
+# Add this to register the command group
+def file():
+    return file_cmd

helper/commands/internal_ip.py

@@ -1,8 +1,9 @@
 import platform
 import socket
 import shutil
-from ..utils import run_cmd
 import click
+from helper import __version__
+from helper.utils import run_cmd
 
 def get_internal_ip():
     """Get the internal IP address based on the operating system."""
@@ -23,5 +24,12 @@ def get_internal_ip():
 
 @click.command()
 def internal_ip():
-    """Show local/internal IP"""
+    """Show local/internal IP address.
+    
+    Version: {}
+    
+    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()

helper/commands/nixos.py

@@ -1,65 +1,89 @@
-import click
-import platform
+"""NixOS related commands for the helper CLI.
+
+This module provides commands to manage NixOS packages and system operations.
+"""
+
 import subprocess
+import sys
+
+import click
+
 
 def check_nixos():
     """Check if running on NixOS."""
     try:
-        with open('/etc/os-release') as f:
-            return 'NixOS' in f.read()
+        with open("/etc/os-release") as f:
+            return "NixOS" in f.read()
     except FileNotFoundError:
         return False
-    except Exception as e:
+    except (IOError, PermissionError) as e:
         click.echo(f"Warning: Could not check if running on NixOS: {e}", err=True)
         return False
 
+
 def get_nixos_version():
-    """Get NixOS version information."""
+    """Get NixOS version information.
+
+    Returns:
+        str: NixOS version information or error message
+    """
     if not check_nixos():
         return "Not running NixOS"
-    
+
     try:
-        result = subprocess.run(['nixos-version'], 
-                              capture_output=True, 
-                              text=True)
-        if result.returncode == 0:
-            return result.stdout.strip()
-        return "NixOS version could not be determined"
-    except Exception as e:
-        return f"Error getting NixOS version: {str(e)}"
+        result = subprocess.run(
+            ["nixos-version"], capture_output=True, text=True, check=True
+        )
+        return result.stdout.strip()
+    except subprocess.CalledProcessError as e:
+        return f"Error getting NixOS version: {e.stderr}"
+    except FileNotFoundError:
+        return "nixos-version command not found"
+
 
 @click.group()
 def nixos():
-    """NixOS related commands."""
+    """NixOS related commands (v0.1.19)."""
     if not check_nixos():
-        click.echo("Warning: Not running on NixOS. Some commands may not work as expected.", err=True)
+        click.echo(
+            "Warning: Not running on NixOS. Some commands may not work as expected.",
+            err=True,
+        )
+
 
 @nixos.command()
 def version():
     """Show NixOS version."""
     click.echo(get_nixos_version())
 
+
 @nixos.command()
-@click.argument('package', required=False)
+@click.argument("package", required=False)
 def search(package):
     """Search for Nix packages."""
     if not package:
         click.echo("Please specify a package to search for")
         return
-        
+
     try:
-        result = subprocess.run(['nix-env', '-qa', package],
-                              capture_output=True,
-                              text=True)
+        result = subprocess.run(
+            ["nix-env", "-qa", package], capture_output=True, text=True, check=False
+        )
         if result.returncode == 0:
             click.echo(result.stdout)
         else:
             click.echo(f"Error searching for package: {result.stderr}", err=True)
-    except Exception as e:
+    except subprocess.SubprocessError as e:
         click.echo(f"Error: {str(e)}", err=True)
 
+
 @nixos.command()
-@click.option('-f', '--force', is_flag=True, help='Force garbage collection and remove all old generations')
+@click.option(
+    "-f",
+    "--force",
+    is_flag=True,
+    help="Force garbage collection and remove all old generations",
+)
 def clean(force):
     """Clean Nix store and perform garbage collection."""
     if not check_nixos():
@@ -71,18 +95,20 @@ def clean(force):
         if force:
             click.echo("Forcing garbage collection and removing all old generations...")
             # Remove all old generations of all profiles
-            subprocess.run(['nix-collect-garbage', '-d'], check=True)
+            subprocess.run(["nix-collect-garbage", "-d"], check=True)
             click.echo("✓ Removed all old generations and ran garbage collection")
         else:
             # Regular garbage collection (safe, only removes unreachable paths)
-            subprocess.run(['nix-collect-garbage'], check=True)
+            subprocess.run(["nix-collect-garbage"], check=True)
             click.echo("✓ Garbage collection completed")
-        
+
         # Show disk space usage after cleanup
         click.echo("\nDisk space usage after cleanup:")
-        subprocess.run(['nix-store', '--query', '--disk-usage', '/nix/store'])
-        
+        subprocess.run(
+            ["nix-store", "--query", "--disk-usage", "/nix/store"], check=False
+        )
+
     except subprocess.CalledProcessError as e:
         click.echo(f"Error during cleanup: {e}", err=True)
-    except Exception as e:
-        click.echo(f"Unexpected error: {str(e)}", err=True)
+    except subprocess.SubprocessError as e:
+        click.echo(f"Subprocess error: {str(e)}", err=True)

helper/commands/public_ip.py

@@ -1,8 +1,17 @@
-from ..utils import run_cmd
 import click
+from helper import __version__
+from helper.utils import run_cmd
+
 
 @click.command()
 def public_ip():
-    """Show 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)

helper/commands/speed.py

@@ -0,0 +1,38 @@
+import click
+import subprocess
+from ..utils import run_cmd
+
+
+def check_speedtest_installed():
+    """Check if speedtest-cli is installed."""
+    try:
+        subprocess.run(
+            ["which", "speedtest-cli"],
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+@click.command()
+@click.option("--simple", "-s", is_flag=True, help="Only show basic speed information")
+def speed(simple):
+    """Test internet speed using speedtest-cli"""
+    if not check_speedtest_installed():
+        click.echo("Error: speedtest-cli is not installed. Please install it first.")
+        click.echo("You can install it with: pip install speedtest-cli")
+        return
+
+    cmd = "speedtest-cli"
+    if simple:
+        cmd += " --simple"
+
+    run_cmd(cmd)
+
+
+# Add aliases for the command
+speed_test = speed
+sp = speed