Open-AutoTools 0.0.3rc5__py3-none-any.whl → 0.0.4rc1__py3-none-any.whl

autotools/autopassword/core.py

@@ -6,96 +6,55 @@ from cryptography.fernet import Fernet
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 
-def generate_password(length=12, use_uppercase=True, use_numbers=True, use_special=True, 
-                     min_special=1, min_numbers=1):
-    """Generate a secure random password with specified requirements."""
-
-    # DEFINE CHARACTER SETS
+# GENERATES A SECURE RANDOM PASSWORD WITH SPECIFIED REQUIREMENTS
+def generate_password(length=12, use_uppercase=True, use_numbers=True, use_special=True, min_special=1, min_numbers=1):
     lowercase = string.ascii_lowercase
     uppercase = string.ascii_uppercase if use_uppercase else ''
     numbers = string.digits if use_numbers else ''
     special = "!@#$%^&*()_+-=[]{}|;:,.<>?" if use_special else ''
-    
-    #  COMBINE ALL ALLOWED CHARACTERS
     all_chars = lowercase + uppercase + numbers + special
-    
-    # ENSURE MINIMUM REQUIREMENTS
     password = []
     password.append(secrets.choice(lowercase))
-    if use_uppercase:
-        password.append(secrets.choice(uppercase))
-    if use_numbers:
-        password.extend(secrets.choice(numbers) for _ in range(min_numbers))
-    if use_special:
-        password.extend(secrets.choice(special) for _ in range(min_special))
-    
-    # FILL REST OF PASSWORD
+
+    if use_uppercase: password.append(secrets.choice(uppercase))
+    if use_numbers: password.extend(secrets.choice(numbers) for _ in range(min_numbers))
+    if use_special: password.extend(secrets.choice(special) for _ in range(min_special))
+
     remaining_length = length - len(password)
     password.extend(secrets.choice(all_chars) for _ in range(remaining_length))
-    
-    random.shuffle(password) # SHUFFLE PASSWORD
-    
-    return ''.join(password) ## RETURN PASSWORD
+    random.shuffle(password)
 
+    return ''.join(password)
+
+# GENERATES ENCRYPTION KEY FOR FERNET SYMMETRIC ENCRYPTION
 def generate_encryption_key(password=None, salt=None):
-    """Generate a strong encryption key using Fernet."""
-    if not password:
-        # GENERATE A RANDOM KEY
-        return Fernet.generate_key()
-    
-    if not salt:
-        salt = secrets.token_bytes(16)
-    
-    # DERIVE A KEY FROM PASSWORD AND SALT
-    kdf = PBKDF2HMAC(
-        algorithm=hashes.SHA256(),
-        length=32,
-        salt=salt,
-        iterations=100000,
-    )
-    
-    # ENCODE KEY IN BASE64
+    if not password: return Fernet.generate_key()
+    if not salt: salt = secrets.token_bytes(16)
+    kdf = PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=100000)
     key = base64.urlsafe_b64encode(kdf.derive(password.encode()))
     return key, salt
 
+# ANALYZES PASSWORD STRENGTH AND PROVIDES IMPROVEMENT SUGGESTIONS
 def analyze_password_strength(password):
-    """Analyze password strength and return a score and suggestions."""
     score = 0
     suggestions = []
-    
-    # CHECK LENGTH
-    if len(password) >= 12:
-        score += 2
-    elif len(password) >= 8:
-        score += 1
-    else:
-        suggestions.append("Password should be at least 8 characters long")
-    
-    # CHECK FOR CHARACTER TYPES
-    if any(c.isupper() for c in password):
-        score += 1
-    else:
-        suggestions.append("Add uppercase letters")
-    
-    # CHECK FOR CHARACTER TYPES
-    if any(c.islower() for c in password):
-        score += 1
-    else:
-        suggestions.append("Add lowercase letters")
-    
-    # CHECK FOR CHARACTER TYPES
-    if any(c.isdigit() for c in password):
-        score += 1
-    else:
-        suggestions.append("Add numbers")
-    
-    # CHECK FOR CHARACTER TYPES
-    if any(c in "!@#$%^&*()_+-=[]{}|;:,.<>?" for c in password):
-        score += 1
-    else:
-        suggestions.append("Add special characters")
-    
-    # RETURN SCORE AND SUGGESTIONS
+
+    if len(password) >= 12: score += 2
+    elif len(password) >= 8: score += 1
+    else: suggestions.append("Password should be at least 8 characters long")
+
+    if any(c.isupper() for c in password): score += 1
+    else: suggestions.append("Add uppercase letters")
+
+    if any(c.islower() for c in password): score += 1
+    else: suggestions.append("Add lowercase letters")
+
+    if any(c.isdigit() for c in password): score += 1
+    else: suggestions.append("Add numbers")
+
+    if any(c in "!@#$%^&*()_+-=[]{}|;:,.<>?" for c in password): score += 1
+    else: suggestions.append("Add special characters")
+
     return {
         'score': score,
         'strength': ['Very Weak', 'Weak', 'Medium', 'Strong', 'Very Strong'][min(score, 4)],

autotools/autotest/__init__.py

@@ -0,0 +1,2 @@
+from .commands import autotest
+__all__ = ['autotest'] 

autotools/autotest/commands.py

@@ -0,0 +1,205 @@
+import click
+import subprocess
+import sys
+import os
+import re
+from ..utils.updates import check_for_updates
+
+# CLI COMMAND TO RUN TEST SUITE WITH PYTEST
+@click.command()
+@click.option('--unit', '-u', is_flag=True, help='Run only unit tests')
+@click.option('--integration', '-i', is_flag=True, help='Run only integration tests')
+@click.option('--no-cov', is_flag=True, help='Disable coverage report')
+@click.option('--html', is_flag=True, help='Generate HTML coverage report')
+@click.option('--module', '-m', help='Test specific module (e.g., autocaps, autolower)')
+def autotest(unit, integration, no_cov, html, module):
+    _install_test_dependencies()
+    
+    cmd = _build_test_command(unit, integration, no_cov, html, module)
+    
+    click.echo(click.style("\nRunning tests with command:", fg='blue', bold=True))
+    click.echo(" ".join(cmd))
+    click.echo()
+    
+    _run_test_process(cmd)
+
+    update_msg = check_for_updates()
+    if update_msg: click.echo(update_msg)
+
+# INSTALLS TEST DEPENDENCIES IF MISSING BY RUNNING PIP INSTALL COMMAND
+def _install_test_dependencies():
+    try:
+        import pytest
+        import pytest_cov
+    except ImportError:
+        click.echo(click.style("\n❌ pytest and/or pytest-cov not found. Installing...", fg='yellow', bold=True))
+        try:
+            subprocess.run(['pip', 'install', 'pytest', 'pytest-cov'], check=True)
+            click.echo(click.style("✅ Successfully installed pytest and pytest-cov", fg='green', bold=True))
+        except subprocess.CalledProcessError as e:
+            click.echo(click.style(f"\n❌ Failed to install dependencies: {str(e)}", fg='red', bold=True))
+            sys.exit(1)
+
+# BUILDS THE TEST COMMAND ARGUMENTS BY ADDING THE CORRECT TEST PATH AND OPTIONS
+def _build_test_command(unit, integration, no_cov, html, module):
+    cmd = [sys.executable, '-m', 'pytest', '-vv', '--capture=no', '--showlocals', '--log-cli-level=DEBUG', '-s']
+    
+    if not no_cov:
+        if html: cmd.extend(['--cov-report=html', '--cov=autotools'])
+        else: cmd.extend(['--cov-report=term-missing', '--cov=autotools'])
+    
+    if module:
+        test_path = f'tests/autotools/{module}'
+        if unit and not integration: test_path = f'{test_path}/unit'
+        elif integration and not unit: test_path = f'{test_path}/integration'
+        cmd.append(test_path)
+    else:
+        cmd.append('tests')
+    
+    return cmd
+
+# PROCESSES TEST OUTPUT LINE BY REMOVING UNNECESSARY CHARACTERS AND FORMATTING
+def _process_test_output_line(line):
+    if not line: return None
+    line = line.strip()
+    if not line: return None
+    
+    if '::' in line and 'autotools/' in line:
+        line = line.split('autotools/')[-1].replace('/tests/', '/')
+        parts = line.split('/')
+        if len(parts) > 1: line = parts[-1]
+    
+    line = re.sub(r'\s+', ' ', line)
+    line = re.sub(r'\.+', '.', line)
+    
+    if line.strip('. '): return line
+
+    return None
+
+# EXTRACTS COVERAGE DATA FROM TOTAL LINE
+def _parse_coverage_line(line):
+    parts = line.split()
+    try:
+        if len(parts) >= 4:
+            stmts = int(parts[1])
+            missed = int(parts[2])
+            
+            # CHECK IF BRANCHES ARE PRESENT
+            if len(parts) >= 6 and parts[3].isdigit() and parts[4].isdigit():
+                branches = int(parts[3])
+                branch_partial = int(parts[4])
+                coverage_pct = float(parts[5].rstrip('%'))
+                return {
+                    'statements': stmts,
+                    'missed': missed,
+                    'branches': branches,
+                    'branch_partial': branch_partial,
+                    'coverage': coverage_pct
+                }
+
+            coverage_pct = float(parts[3].rstrip('%'))
+            return {'statements': stmts, 'missed': missed, 'coverage': coverage_pct}
+    except (ValueError, IndexError):
+        match = re.search(r'(\d+\.\d+)%', line)
+        if match: return {'coverage': float(match.group(1))}
+    return {}
+
+# DETERMINES COLOR BASED ON COVERAGE PERCENTAGE
+def _get_coverage_color(percentage):
+    if percentage >= 80: return 'green'
+    if percentage >= 60: return 'yellow'
+    return 'red'
+
+# DISPLAYS COVERAGE METRICS
+def _display_coverage_metrics(coverage_data):
+    if not coverage_data: return
+
+    click.echo()
+    click.echo(click.style("COVERAGE METRICS", fg='blue', bold=True))
+
+    # STATEMENTS COVERAGE
+    if 'statements' in coverage_data and 'missed' in coverage_data:
+        stmts = coverage_data['statements']
+        missed = coverage_data['missed']
+        covered = stmts - missed
+        stmts_pct = (covered / stmts * 100) if stmts > 0 else 0
+        color = _get_coverage_color(stmts_pct)
+        click.echo(click.style(f"Statements: {covered}/{stmts} ({stmts_pct:.2f}%)", fg=color, bold=True))
+
+    # BRANCHES COVERAGE
+    if 'branches' in coverage_data and coverage_data['branches'] > 0:
+        branches = coverage_data['branches']
+        branch_partial = coverage_data.get('branch_partial', 0)
+        branch_covered = branches - branch_partial
+        branch_pct = (branch_covered / branches * 100) if branches > 0 else 0
+        color = _get_coverage_color(branch_pct)
+        click.echo(click.style(f"Branches: {branch_covered}/{branches} ({branch_pct:.2f}%)", fg=color, bold=True))
+
+    # OVERALL COVERAGE
+    if 'coverage' in coverage_data:
+        overall = coverage_data['coverage']
+        color = _get_coverage_color(overall)
+        click.echo(click.style(f"Overall: {overall:.2f}%", fg=color, bold=True))
+
+# RUNS THE TEST PROCESS AND CAPTURES OUTPUT
+def _run_test_process(cmd):
+    try:
+        env = _prepare_test_environment()
+        process = _start_test_process(cmd, env)
+        coverage_data = _process_test_output(process)
+        _handle_test_result(process, coverage_data)
+    except subprocess.CalledProcessError as e:
+        click.echo(click.style(f"\n❌ TESTS FAILED WITH RETURN CODE {e.returncode}", fg='red', bold=True))
+        sys.exit(1)
+    except Exception as e:
+        click.echo(click.style(f"\n❌ ERROR RUNNING TESTS: {str(e)}", fg='red', bold=True))
+        sys.exit(1)
+
+# PREPARES ENVIRONMENT FOR TEST PROCESS
+def _prepare_test_environment():
+    env = dict(os.environ)
+    env['PYTHONPATH'] = os.getcwd()
+    env['FORCE_COLOR'] = '1'
+    return env
+
+# STARTS THE TEST PROCESS
+def _start_test_process(cmd, env):
+    return subprocess.Popen(
+        cmd,
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        universal_newlines=True,
+        bufsize=1
+    )
+
+# PROCESSES TEST OUTPUT AND EXTRACTS COVERAGE DATA
+def _process_test_output(process):
+    coverage_data = {}
+    
+    while True:
+        line = process.stdout.readline()
+        if not line and process.poll() is not None: break
+        
+        if 'TOTAL' in line and '%' in line:
+            coverage_data = _parse_coverage_line(line)
+            sys.stdout.write(line)
+            sys.stdout.flush()
+            continue
+        
+        processed_line = _process_test_output_line(line)
+        if processed_line:
+            sys.stdout.write(processed_line + '\n')
+            sys.stdout.flush()
+    
+    process.wait()
+    return coverage_data
+
+# HANDLES TEST RESULT AND DISPLAYS COVERAGE
+def _handle_test_result(process, coverage_data):
+    if process.returncode == 0:
+        click.echo(click.style("\n✅ ALL TESTS PASSED !", fg='green', bold=True))
+        _display_coverage_metrics(coverage_data)
+    else:
+        click.echo(click.style("\n❌ SOME TESTS FAILED!", fg='red', bold=True))
+        sys.exit(1) 

autotools/cli.py

@@ -1,95 +1,156 @@
 import click
-from importlib.metadata import version as get_version, PackageNotFoundError
-import pkg_resources
 import requests
-from packaging.version import parse as parse_version
-from dotenv import load_dotenv
-from datetime import datetime
 import base64
-import json as json_module
-from translate import Translator
-import yt_dlp
 import argparse
+import json as json_module
+import sys
+
+from dotenv import load_dotenv
+from datetime import datetime
 from urllib.parse import urlparse
+from packaging.version import parse as parse_version
+from importlib.metadata import version as get_version, PackageNotFoundError
 
-# IMPORT COMMANDS FROM EACH MODULE
-from .autocaps.commands import autocaps
-from .autolower.commands import autolower
-from .autodownload.commands import autodownload
-from .autopassword.commands import autopassword
-from .autotranslate.commands import autotranslate
-from .autoip.commands import autoip
-from .autospell.commands import autospell
-from .test.commands import test
-from .utils.updates import check_for_updates
 from .utils.version import print_version
+from .utils.updates import check_for_updates
+from .utils.commands import autocaps, autolower, autopassword, autoip, autotest
+from .utils.performance import init_metrics, finalize_metrics, get_metrics, should_enable_metrics, track_step
 
-# LOAD ENVIRONMENT VARIABLES FROM .ENV FILE
 load_dotenv()
 
-# CLI FUNCTION DEFINITION
-@click.group()
-@click.option('--version', '--v', is_flag=True, callback=print_version,
+# MAIN CLI ENTRY POINT - REGISTERS ALL COMMANDS AND HANDLES GLOBAL OPTIONS
+@click.group(invoke_without_command=True)
+@click.option('--version', '--v', is_flag=True, callback=lambda ctx, param, value: print_version(ctx, value),
               expose_value=False, is_eager=True, help='Show version and check for updates')
 @click.option('--help', '-h', is_flag=True, callback=lambda ctx, param, value: 
               None if not value else (click.echo(ctx.get_help() + '\n' + 
               (check_for_updates() or '')) or ctx.exit()),
               is_eager=True, expose_value=False, help='Show this message and exit.')
-def cli():
-    """A suite of automated tools for various tasks.
+@click.option('--perf', is_flag=True, help='Display performance metrics')
+@click.pass_context
+def cli(ctx, perf):
+    """
+        A suite of automated tools for various tasks:\n
+        - autocaps: Convert text to uppercase\n
+        - autolower: Convert text to lowercase\n
+        - autopassword: Generate secure passwords and encryption keys\n
+        - autoip: Display network information and run diagnostics\n
+        - test: Run the test suite\n
+        \n
+        Run 'autotools COMMAND --help' for more information on each command.\n
+    """
+
+    # INITIALIZE METRICS IF NEEDED
+    if should_enable_metrics(ctx):
+        init_metrics()
+        get_metrics().step_start('startup')
+        get_metrics().step_end()
+        get_metrics().end_startup()
     
-    Run 'autotools COMMAND --help' for more information on each command."""
-    pass
+    # IF NO COMMAND INVOKED, SHOW HELP
+    if ctx.invoked_subcommand is None:
+        autotools()
+        if should_enable_metrics(ctx):
+            get_metrics().end_process()
+            finalize_metrics(ctx)
 
-# REGISTER COMMANDS
-cli.add_command(autocaps)
-cli.add_command(autolower)
-cli.add_command(autodownload)
-cli.add_command(autopassword)
-cli.add_command(autotranslate)
-cli.add_command(autoip)
-cli.add_command(autospell)
-cli.add_command(test)
+# EXECUTES COMMAND WITH PERFORMANCE TRACKING
+def _execute_with_metrics(ctx, original_callback, *args, **kwargs):
+    metrics = get_metrics()
+    # REMOVE 'perf' FROM kwargs IF PRESENT (IT'S NOT PART OF THE ORIGINAL CALLBACK SIGNATURE)
+    kwargs.pop('perf', None)
+    
+    if not should_enable_metrics(ctx): return original_callback(*args, **kwargs)
+    
+    if metrics.process_start is None:
+        init_metrics()
+        get_metrics().end_startup()
+    
+    metrics.start_command()
+    cmd_name = ctx.invoked_subcommand or ctx.command.name or 'unknown'
+    try:
+        with track_step(f'command_{cmd_name}'): result = original_callback(*args, **kwargs)
+        metrics.end_command()
+        return result
+    finally:
+        if metrics.process_end is None:
+            metrics.end_process()
+            finalize_metrics(ctx)
 
-# MAIN COMMAND DEFINITION
-@cli.command()
-def autotools():
-    """Display available commands and tool information."""
-    # SHOW COMMANDS LIST WITH BETTER FORMATTING
-    ctx = click.get_current_context()
-    commands = cli.list_commands(ctx)
+# WRAPS COMMANDS WITH PERFORMANCE TRACKING
+def _wrap_command_with_metrics(cmd):
+    import inspect
+    original_callback = cmd.callback
     
+    # ADD --perf OPTION TO THE COMMAND SO IT CAN BE USED DIRECTLY ON SUBCOMMANDS
+    has_perf_option = any(param.opts == ['--perf'] for param in cmd.params if isinstance(param, click.Option))
+    if not has_perf_option:
+        perf_option = click.Option(['--perf'], is_flag=True, help='Display performance metrics')
+        cmd.params.append(perf_option)
+    
+    sig = inspect.signature(original_callback)
+    expects_ctx = 'ctx' in sig.parameters
+    
+    if expects_ctx:
+        @click.pass_context
+        def wrapped_callback(ctx, *args, **kwargs):
+            return _execute_with_metrics(ctx, original_callback, ctx, *args, **kwargs)
+    else:
+        def wrapped_callback(*args, **kwargs):
+            ctx = click.get_current_context()
+            return _execute_with_metrics(ctx, original_callback, *args, **kwargs)
+    
+    cmd.callback = wrapped_callback
+    return cmd
+
+cli.add_command(_wrap_command_with_metrics(autocaps))
+cli.add_command(_wrap_command_with_metrics(autolower))
+cli.add_command(_wrap_command_with_metrics(autopassword))
+cli.add_command(_wrap_command_with_metrics(autoip))
+cli.add_command(_wrap_command_with_metrics(autotest), name='test')
+
+# DISPLAYS COMMAND OPTIONS
+def _display_command_options(cmd_obj):
+    if not hasattr(cmd_obj, 'params'): return
+    click.echo(click.style("\n  Options:", fg='yellow'))
+    for param in cmd_obj.params:
+        if isinstance(param, click.Option):
+            opts = '/'.join(param.opts)
+            help_text = param.help or ''
+            click.echo(f"    {click.style(opts, fg='yellow')}")
+            click.echo(f"      {help_text}")
+
+# DISPLAYS ALL AVAILABLE COMMANDS
+def _display_commands(ctx, commands):
     click.echo(click.style("\nOpen-AutoTools Commands:", fg='blue', bold=True))
     for cmd in sorted(commands):
-        if cmd != 'autotools':
-            cmd_obj = cli.get_command(ctx, cmd)
-            help_text = cmd_obj.help or cmd_obj.short_help or ''
-            click.echo(f"\n{click.style(cmd, fg='green', bold=True)}")
-            click.echo(f"  {help_text}")
-            
-            # GET OPTIONS FOR EACH COMMAND
-            if hasattr(cmd_obj, 'params'):
-                click.echo(click.style("\n  Options:", fg='yellow'))
-                for param in cmd_obj.params:
-                    if isinstance(param, click.Option):
-                        opts = '/'.join(param.opts)
-                        help_text = param.help or ''
-                        click.echo(f"    {click.style(opts, fg='yellow')}")
-                        click.echo(f"      {help_text}")
+        if cmd == 'autotools': continue
+        cmd_obj = cli.get_command(ctx, cmd)
+        help_text = cmd_obj.help or cmd_obj.short_help or ''
+        click.echo(f"\n{click.style(cmd, fg='green', bold=True)}")
+        click.echo(f"  {help_text}")
+        _display_command_options(cmd_obj)
 
-    # SHOW USAGE EXAMPLES
+# DISPLAYS USAGE EXAMPLES
+def _display_usage_examples():
     click.echo(click.style("\nUsage Examples:", fg='blue', bold=True))
     click.echo("  autotools --help         Show this help message")
     click.echo("  autotools --version      Show version information")
     click.echo("  autotools COMMAND        Run a specific command")
     click.echo("  autotools COMMAND --help Show help for a specific command")
 
-    # CHECK FOR UPDATES
+# DISPLAYS ALL AVAILABLE COMMANDS WITH THEIR OPTIONS AND USAGE EXAMPLES
+@cli.command()
+def autotools():
+    ctx = click.get_current_context()
+    commands = cli.list_commands(ctx)
+
+    _display_commands(ctx, commands)
+    _display_usage_examples()
+
     update_msg = check_for_updates()
     if update_msg:
         click.echo(click.style("\nUpdate Available:", fg='red', bold=True))
         click.echo(update_msg)
 
-# ENTRY POINT
-if __name__ == '__main__':
-    cli()
+if __name__ == '__main__': cli()

autotools/utils/commands.py

@@ -0,0 +1,13 @@
+from ..autocaps.commands import autocaps
+from ..autolower.commands import autolower
+from ..autopassword.commands import autopassword
+from ..autoip.commands import autoip
+from ..autotest.commands import autotest
+
+__all__ = [
+    'autocaps',
+    'autolower',
+    'autopassword',
+    'autoip',
+    'autotest'
+]

autotools/utils/loading.py

@@ -1,16 +1,24 @@
+import threading
 from halo import Halo
 
+# PATCHES THREAD SET DAEMON METHOD TO PREVENT WARNINGS
+def _patched_set_daemon(self, daemon):
+    self.daemon = daemon
+
+_original_set_daemon = threading.Thread.setDaemon
+threading.Thread.setDaemon = _patched_set_daemon
+
+# CONTEXT MANAGER FOR DISPLAYING LOADING ANIMATION
 class LoadingAnimation:
-    """A CONTEXT MANAGER FOR DISPLAYING A LOADING ANIMATION"""
+    # INITIALIZES SPINNER WITH CUSTOM ANIMATION FRAMES
     def __init__(self):
-        self._spinner = Halo(spinner={
-            'interval': 200,
-            'frames': ['   ', '.  ', '.. ', '...'],
-        })
+        self._spinner = Halo(spinner={'interval': 200, 'frames': ['   ', '.  ', '.. ', '...']})
         
+    # STARTS THE LOADING ANIMATION
     def __enter__(self):
         self._spinner.start()
         return self
         
+    # STOPS THE LOADING ANIMATION
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self._spinner.stop() 
+        self._spinner.stop()