Open-AutoTools 0.0.4rc1__py3-none-any.whl → 0.0.5__py3-none-any.whl

autotools/autoip/core.py

@@ -2,16 +2,27 @@ import socket
 import requests
 import json
 import ipaddress
-import netifaces
 import time
 import speedtest
 import psutil
+from ..utils.text import is_ci_environment, mask_ipv4, mask_ipv6, mask_sensitive_info
+
+# NORMALIZES psutil.net_if_addrs() OUTPUT TO A netifaces-LIKE STRUCTURE:
+def _psutil_addrs_to_family_map(addrs):
+    family_map = {}
+    for snic in addrs or []:
+        family = getattr(snic, 'family', None)
+        addr = getattr(snic, 'address', None)
+        if not addr: continue
+        if family not in (socket.AF_INET, socket.AF_INET6): continue
+        family_map.setdefault(family, []).append({'addr': addr})
+    return family_map
 
 # EXTRACTS IPV4 ADDRESSES FROM INTERFACE ADDRESSES
 def _extract_ipv4_addresses(addrs):
     ipv4_list = []
-    if netifaces.AF_INET in addrs:
-        for addr in addrs[netifaces.AF_INET]:
+    if socket.AF_INET in addrs:
+        for addr in addrs[socket.AF_INET]:
             if 'addr' in addr and not addr['addr'].startswith('127.'):
                 ipv4_list.append(addr['addr'])
     return ipv4_list
@@ -19,9 +30,9 @@ def _extract_ipv4_addresses(addrs):
 # EXTRACTS IPV6 ADDRESSES FROM INTERFACE ADDRESSES
 def _extract_ipv6_addresses(addrs):
     ipv6_list = []
-    if netifaces.AF_INET6 in addrs:
-        for addr in addrs[netifaces.AF_INET6]:
-            if 'addr' in addr and not addr['addr'].startswith('fe80:'):
+    if socket.AF_INET6 in addrs:
+        for addr in addrs[socket.AF_INET6]:
+            if 'addr' in addr and not addr['addr'].lower().startswith('fe80:'):
                 clean_addr = addr['addr'].split('%')[0]
                 ipv6_list.append(clean_addr)
     return ipv6_list
@@ -30,10 +41,13 @@ def _extract_ipv6_addresses(addrs):
 def get_local_ips():
     ips = {'ipv4': [], 'ipv6': []}
 
-    for interface in netifaces.interfaces():
-        addrs = netifaces.ifaddresses(interface)
-        ips['ipv4'].extend(_extract_ipv4_addresses(addrs))
-        ips['ipv6'].extend(_extract_ipv6_addresses(addrs))
+    try: if_addrs = psutil.net_if_addrs()
+    except Exception: return ips
+
+    for _, addrs in (if_addrs or {}).items():
+        family_map = _psutil_addrs_to_family_map(addrs)
+        ips['ipv4'].extend(_extract_ipv4_addresses(family_map))
+        ips['ipv6'].extend(_extract_ipv6_addresses(family_map))
 
     return ips
 
@@ -122,20 +136,26 @@ def get_public_ip():
 
 # GETS LOCAL IP ADDRESS OF DEFAULT NETWORK INTERFACE
 def get_local_ip():
+    # TRY psutil FIRST (NO NETWORK NEEDED)
     try:
-        gateways = netifaces.gateways()
-        default_interface = gateways['default'][netifaces.AF_INET][1]
-        addrs = netifaces.ifaddresses(default_interface)
-        return addrs[netifaces.AF_INET][0]['addr']
-    except (KeyError, IndexError, OSError):
-        try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            s.connect(("8.8.8.8", 80))
-            ip = s.getsockname()[0]
-            s.close()
-            return ip
-        except OSError:
-            return None
+        if_addrs = psutil.net_if_addrs()
+        for _, addrs in (if_addrs or {}).items():
+            for snic in addrs or []:
+                if getattr(snic, 'family', None) != socket.AF_INET: continue
+                addr = getattr(snic, 'address', None)
+                if addr and not addr.startswith('127.'): return addr
+    except Exception:
+        pass
+
+    # FALLBACK: UDP SOCKET TRICK
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except OSError:
+        return None
 
 # RETRIEVES DETAILED INFORMATION ABOUT AN IP ADDRESS
 def get_ip_info(ip=None):
@@ -152,59 +172,93 @@ def get_ip_info(ip=None):
         response = requests.get(url)
         data = response.json()
 
-        if 'error' in data: raise ValueError(f"Error getting IP info: {data['error']}")
+        if 'error' in data:
+            raise ValueError(f"Error getting IP info: {data['error']}")
 
         return data
     except requests.RequestException as e:
         raise ValueError(f"Error connecting to IP info service: {str(e)}")
 
-# DISPLAYS LOCAL AND PUBLIC IP ADDRESSES
-def _display_ip_addresses(output):
-    local_ips = get_local_ips()
-    public_ips = get_public_ips()
-    output.append("\nLocal IPs:")
+# FORMATS IP ADDRESS FOR DISPLAY (MASKS IF IN CI)
+def _format_ip_for_display(ip, mask_func, in_ci):
+    if not ip: return 'Not available'
+    return mask_func(ip) if in_ci else ip
 
+# DISPLAYS LOCAL IP ADDRESSES
+def _display_local_ips(output, local_ips, in_ci):
+    output.append("\nLocal IPs:")
     if local_ips['ipv4']:
-        for ip in local_ips['ipv4']: output.append(f"IPv4: {ip}")
+        for ip in local_ips['ipv4']:
+            display_ip = _format_ip_for_display(ip, mask_ipv4, in_ci)
+            output.append(f"IPv4: {display_ip}")
     else:
         output.append("IPv4: Not available")
-        
     if local_ips['ipv6']:
-        for ip in local_ips['ipv6']: output.append(f"IPv6: {ip}")
+        for ip in local_ips['ipv6']:
+            display_ip = _format_ip_for_display(ip, mask_ipv6, in_ci)
+            output.append(f"IPv6: {display_ip}")
     else:
         output.append("IPv6: Not available")
-    
+
+# DISPLAYS PUBLIC IP ADDRESSES
+def _display_public_ips(output, public_ips, in_ci):
     output.append("\nPublic IPs:")
-    output.append(f"IPv4: {public_ips['ipv4'] or 'Not available'}")
-    output.append(f"IPv6: {public_ips['ipv6'] or 'Not available'}")
+    public_ipv4 = _format_ip_for_display(public_ips['ipv4'], mask_ipv4, in_ci)
+    public_ipv6 = _format_ip_for_display(public_ips['ipv6'], mask_ipv6, in_ci)
+    output.append(f"IPv4: {public_ipv4}")
+    output.append(f"IPv6: {public_ipv6}")
+
+# DISPLAYS LOCAL AND PUBLIC IP ADDRESSES
+def _display_ip_addresses(output):
+    local_ips = get_local_ips()
+    public_ips = get_public_ips()
+    in_ci = is_ci_environment()
+    _display_local_ips(output, local_ips, in_ci)
+    _display_public_ips(output, public_ips, in_ci)
 
 # DISPLAYS CONNECTIVITY TEST RESULTS
 def _display_connectivity_tests(output):
     output.append("\nConnectivity Tests:")
     results = test_connectivity()
     for name, success, latency in results:
-        status = f"✓ {latency}ms" if success else "✗ Failed"
+        status = f"OK {latency}ms" if success else "X Failed"
         output.append(f"{name:<15} {status}")
 
 # DISPLAYS LOCATION INFORMATION
 def _display_location_info(output):
     try:
         loc = get_ip_info()
+        in_ci = is_ci_environment()
         output.append("\nLocation Info:")
-        output.append(f"City: {loc.get('city', 'Unknown')}")
-        output.append(f"Region: {loc.get('region', 'Unknown')}")
-        output.append(f"Country: {loc.get('country', 'Unknown')}")
-        output.append(f"ISP: {loc.get('org', 'Unknown')}")
+
+        if in_ci:
+            output.append("City: [REDACTED]")
+            output.append("Region: [REDACTED]")
+            output.append("Country: [REDACTED]")
+            output.append("ISP: [REDACTED]")
+        else:
+            output.append(f"City: {loc.get('city', 'Unknown')}")
+            output.append(f"Region: {loc.get('region', 'Unknown')}")
+            output.append(f"Country: {loc.get('country', 'Unknown')}")
+            output.append(f"ISP: {loc.get('org', 'Unknown')}")
+
     except Exception as e:
-        output.append(f"\nLocation lookup failed: {str(e)}")
+        error_msg = str(e)
+        if is_ci_environment(): error_msg = mask_sensitive_info(error_msg)
+        output.append(f"\nLocation lookup failed: {error_msg}")
 
 # DISPLAYS DNS SERVER INFORMATION
 def _display_dns_servers(output):
     output.append("\nDNS Servers:")
+    in_ci = is_ci_environment()
     try:
         with open('/etc/resolv.conf', 'r') as f:
             for line in f:
-                if 'nameserver' in line: output.append(f"DNS: {line.split()[1]}")
+                if 'nameserver' in line:
+                    dns_ip = line.split()[1]
+                    display_dns = mask_ipv4(dns_ip) if in_ci else dns_ip
+                    output.append(f"DNS: {display_dns}")
+
     except OSError:
         output.append("Could not read DNS configuration")
 
@@ -246,6 +300,7 @@ def _monitor_network_traffic(output, interval):
 # MAIN FUNCTION TO RUN NETWORK DIAGNOSTICS AND DISPLAY RESULTS
 def run(test=False, speed=False, monitor=False, interval=1, ports=False, dns=False, location=False, no_ip=False):
     output = []
+    in_ci = is_ci_environment()
 
     if not no_ip: _display_ip_addresses(output)
     if test: _display_connectivity_tests(output)
@@ -259,4 +314,6 @@ def run(test=False, speed=False, monitor=False, interval=1, ports=False, dns=Fal
         if run_speedtest(): output.append("Speed test completed successfully")
         else: output.append("Speed test failed")
 
-    return "\n".join(output) 
+    result = "\n".join(output)
+    if in_ci: result = mask_sensitive_info(result, mask_ips=True)
+    return result 

autotools/autolower/commands.py

@@ -3,10 +3,31 @@ from .core import autolower_transform
 from ..utils.loading import LoadingAnimation
 from ..utils.updates import check_for_updates
 
+# TOOL CATEGORY (USED BY 'autotools smoke')
+TOOL_CATEGORY = 'Text'
+
+# SMOKE TEST CASES (USED BY 'autotools smoke')
+SMOKE_TESTS = [
+    {'name': 'basic', 'args': ['TEST', 'WITH', 'MULTIPLE', 'WORDS']},
+    {'name': 'special', 'args': ['SPECIAL', 'CHARS:', '!@#$%^&*()']},
+    {'name': 'mixed', 'args': ['123', 'MIXED', 'with', 'UPPERCASE', '456']},
+    {'name': 'unicode', 'args': ['ÁCCÊNTS', 'ÀND', 'ÉMOJIS', '🚀', '⭐']},
+]
+
 # CLI COMMAND TO TRANSFORM TEXT TO LOWERCASE
 @click.command()
 @click.argument('text', nargs=-1)
 def autolower(text):
+    """
+        TRANSFORMS TEXT TO LOWERCASE.
+
+        \b
+        EXAMPLES:
+            autolower HELLO WORLD
+            autolower "THIS IS A TEST"
+            echo "TEXT" | autolower
+    """
+
     with LoadingAnimation(): result = autolower_transform(" ".join(text))
     click.echo(result)
     update_msg = check_for_updates()

autotools/autonote/commands.py

@@ -0,0 +1,70 @@
+import click
+from .core import autonote_add, autonote_list, DEFAULT_NOTES_FILE
+from ..utils.loading import LoadingAnimation
+from ..utils.updates import check_for_updates
+
+# TOOL CATEGORY (USED BY 'autotools smoke')
+TOOL_CATEGORY = 'Text'
+
+# SMOKE TEST CASES (USED BY 'autotools smoke')
+SMOKE_TESTS = [
+    {'name': 'add-note', 'args': ['--add', 'Test note']},
+    {'name': 'list-notes', 'args': ['--list']},
+]
+
+# CLI COMMAND TO MANAGE NOTES
+@click.command()
+@click.option('--file', '-f', 'notes_path', default=DEFAULT_NOTES_FILE, help='PATH TO NOTES FILE (DEFAULT: NOTES.md)')
+@click.option('--add', 'add_note', metavar='NOTE', help='ADD A NOTE')
+@click.option('--no-timestamp', 'no_timestamp', is_flag=True, help='ADD NOTE WITHOUT TIMESTAMP')
+@click.option('--list', 'list_notes', is_flag=True, help='LIST ALL NOTES')
+@click.option('--limit', type=int, metavar='N', help='LIMIT NUMBER OF NOTES WHEN LISTING (SHOWS LAST N NOTES)')
+def autonote(notes_path, add_note, no_timestamp, list_notes, limit):
+    """
+        TAKES QUICK NOTES AND SAVES THEM TO A MARKDOWN FILE.
+
+        \b
+        OPERATIONS:
+            - ADD NOTE: --add "your note here" [--no-timestamp]
+            - LIST NOTES: --list [--limit N]
+
+        \b
+        EXAMPLES:
+            autonote --add "Meeting with team at 3pm"
+            autonote --add "Remember to update docs" --no-timestamp
+            autonote --list
+            autonote --list --limit 5
+    """
+
+    operations = sum([bool(add_note), bool(list_notes)])
+
+    if operations == 0:
+        click.echo(click.style("ERROR: NO OPERATION SPECIFIED", fg='red'), err=True)
+        click.echo(click.get_current_context().get_help())
+        raise click.Abort()
+
+    if operations > 1:
+        click.echo(click.style("ERROR: ONLY ONE OPERATION CAN BE PERFORMED AT A TIME", fg='red'), err=True)
+        raise click.Abort()
+
+    try:
+        with LoadingAnimation():
+            if add_note:
+                result = autonote_add(notes_path, add_note, timestamp=not no_timestamp)
+                click.echo(click.style(f"SUCCESS: ADDED NOTE TO {result}", fg='green'))
+            elif list_notes:  # pragma: no branch
+                notes = autonote_list(notes_path, limit, format_for_terminal=True)
+                if not notes:
+                    click.echo(click.style("NO NOTES FOUND", fg='yellow'))
+                else:
+                    click.echo(click.style(f"\nNOTES ({len(notes)}):", fg='blue', bold=True))
+                    for note in notes:
+                        click.echo(f"  {note}")
+        
+        update_msg = check_for_updates()
+        if update_msg:
+            click.echo(update_msg)
+    
+    except Exception as e:
+        click.echo(click.style(f"UNEXPECTED ERROR: {str(e)}", fg='red'), err=True)
+        raise click.Abort()

autotools/autonote/core.py

@@ -0,0 +1,106 @@
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+
+DEFAULT_NOTES_FILE = "NOTES.md"
+
+NOTES_TEMPLATE = """# NOTES
+
+"""
+
+# READS NOTES FILE CONTENT
+def _read_notes_file(notes_path: Path) -> str:
+    if not notes_path.exists():
+        return NOTES_TEMPLATE
+    return notes_path.read_text(encoding='utf-8')
+
+# WRITES NOTES FILE CONTENT
+def _write_notes_file(notes_path: Path, content: str):
+    notes_path.parent.mkdir(parents=True, exist_ok=True)
+    notes_path.write_text(content, encoding='utf-8')
+
+# ADDS A NOTE TO THE NOTES FILE
+def autonote_add(notes_path: str, note: str, timestamp: Optional[bool] = True):
+    notes_file = Path(notes_path)
+    content = _read_notes_file(notes_file)
+    
+    lines = content.split('\n')
+    
+    # REMOVE TRAILING EMPTY LINES
+    while lines and lines[-1].strip() == '':
+        lines.pop()
+    
+    # ENSURE FILE HAS HEADER IF EMPTY OR MISSING
+    if not lines or (len(lines) == 1 and lines[0].strip() == ''):
+        lines = ['# NOTES', '']
+    elif not any(line.strip().startswith('#') for line in lines):
+        lines.insert(0, '# NOTES')
+        lines.insert(1, '')
+    
+    # ADD NEW NOTE WITH TIMESTAMP
+    if timestamp:
+        timestamp_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        new_note = f"- **[{timestamp_str}]** {note}"
+    else:
+        new_note = f"- {note}"
+    
+    lines.append(new_note)
+    lines.append('')  # ADD EMPTY LINE AFTER NOTE
+    
+    content = '\n'.join(lines)
+    _write_notes_file(notes_file, content)
+    return str(notes_file)
+
+# FORMATS NOTE FOR TERMINAL DISPLAY (REMOVES MARKDOWN)
+def _format_note_for_terminal(note_line: str) -> str:
+    # REMOVE LEADING DASH AND SPACES
+    note = note_line.lstrip('-').strip()
+    
+    # EXTRACT TIMESTAMP IF PRESENT (SUPPORTS MULTIPLE FORMATS FOR COMPATIBILITY)
+    import re
+    # NEW FORMAT: **[YYYY-MM-DD HH:MM:SS]** note
+    timestamp_match = re.match(r'\*\*\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\]\*\*\s*(.+)', note)
+    if timestamp_match:
+        timestamp = timestamp_match.group(1)
+        note_text = timestamp_match.group(2)
+        return f"[{timestamp}] {note_text}"
+    
+    # FORMAT: [YYYY-MM-DD HH:MM:SS] note (WITHOUT BOLD)
+    timestamp_match = re.match(r'\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\]\s*(.+)', note)
+    if timestamp_match:
+        timestamp = timestamp_match.group(1)
+        note_text = timestamp_match.group(2)
+        return f"[{timestamp}] {note_text}"
+    
+    # OLD FORMAT: **YYYY-MM-DD HH:MM:SS**: note (FOR BACKWARD COMPATIBILITY)
+    timestamp_match = re.match(r'\*\*(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\*\*:\s*(.+)', note)
+    if timestamp_match:
+        timestamp = timestamp_match.group(1)
+        note_text = timestamp_match.group(2)
+        return f"[{timestamp}] {note_text}"
+    
+    # NO TIMESTAMP, RETURN AS IS
+    return note
+
+# LISTS NOTES FROM THE FILE
+def autonote_list(notes_path: str, limit: Optional[int] = None, format_for_terminal: bool = False):
+    notes_file = Path(notes_path)
+    if not notes_file.exists():
+        return []
+    
+    content = _read_notes_file(notes_file)
+    lines = content.split('\n')
+    
+    notes = []
+    for line in lines:
+        stripped = line.strip()
+        if stripped and stripped.startswith('-'):
+            if format_for_terminal:
+                notes.append(_format_note_for_terminal(stripped))
+            else:
+                notes.append(stripped)
+    
+    if limit and limit > 0:
+        notes = notes[-limit:]  # GET LAST N NOTES
+    
+    return notes

autotools/autopassword/commands.py

@@ -4,6 +4,22 @@ from ..utils.loading import LoadingAnimation
 from ..utils.updates import check_for_updates
 from .core import generate_password, generate_encryption_key, analyze_password_strength
 
+# TOOL CATEGORY (USED BY 'autotools smoke')
+TOOL_CATEGORY = 'Security'
+
+# SMOKE TEST CASES (USED BY 'autotools smoke')
+SMOKE_TESTS = [
+    {'name': 'basic', 'args': []},
+    {'name': 'length', 'args': ['--length', '32']},
+    {'name': 'no-special', 'args': ['--no-special']},
+    {'name': 'no-numbers', 'args': ['--no-numbers']},
+    {'name': 'no-uppercase', 'args': ['--no-uppercase']},
+    {'name': 'min-special', 'args': ['--min-special', '3']},
+    {'name': 'min-numbers', 'args': ['--min-numbers', '3']},
+    {'name': 'analysis', 'args': ['--analyze']},
+    {'name': 'encryption', 'args': ['--gen-key']},
+]
+
 # CLI COMMAND TO GENERATE PASSWORDS OR ENCRYPTION KEYS
 @click.command()
 @click.option('--length', '-l', default=12, help='Password length (default: 12)')
@@ -15,7 +31,29 @@ from .core import generate_password, generate_encryption_key, analyze_password_s
 @click.option('--analyze', '-a', is_flag=True, help='Analyze password strength')
 @click.option('--gen-key', '-g', is_flag=True, help='Generate encryption key')
 @click.option('--password-key', '-p', help='Generate key from password')
-def autopassword(length, no_uppercase, no_numbers, no_special, min_special, min_numbers, analyze, gen_key, password_key):    
+def autopassword(length, no_uppercase, no_numbers, no_special, min_special, min_numbers, analyze, gen_key, password_key):
+    """
+        GENERATES SECURE PASSWORDS OR ENCRYPTION KEYS.
+
+        \b
+        FEATURES:
+            - Generate random passwords with customizable length
+            - Control character sets (uppercase, numbers, special)
+            - Set minimum requirements for special characters and numbers
+            - Analyze password strength
+            - Generate encryption keys
+            - Derive keys from passwords
+
+        \b
+        EXAMPLES:
+            autopassword
+            autopassword --length 16
+            autopassword --length 20 --analyze
+            autopassword --no-special --min-numbers 3
+            autopassword --gen-key
+            autopassword --password-key "mypassword" --analyze
+    """
+
     # DISPLAYS PASSWORD STRENGTH ANALYSIS RESULTS
     def show_analysis(text, prefix=""):
         if not analyze: return

autotools/autotest/commands.py

@@ -4,6 +4,16 @@ import sys
 import os
 import re
 from ..utils.updates import check_for_updates
+from ..utils.text import safe_text
+
+# TOOL CATEGORY (USED BY 'autotools smoke')
+TOOL_CATEGORY = 'Testing'
+
+# SMOKE TEST CASES (USED BY 'autotools smoke')
+# NOTE: THIS TOOL IS SKIPPED BY DEFAULT IN SMOKE RUNS (SEE docs/docker.md)
+SMOKE_TESTS = [
+    {'name': 'help', 'args': ['--help']},
+]
 
 # CLI COMMAND TO RUN TEST SUITE WITH PYTEST
 @click.command()
@@ -13,6 +23,29 @@ from ..utils.updates import check_for_updates
 @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):
+    """
+        RUNS THE TEST SUITE WITH PYTEST.
+
+        \b
+        FEATURES:
+            - Run unit tests only
+            - Run integration tests only
+            - Generate coverage reports
+            - Generate HTML coverage reports
+            - Test specific modules
+            - Auto-install test dependencies
+
+        \b
+        EXAMPLES:
+            autotest
+            autotest --unit
+            autotest --integration
+            autotest --module autocaps
+            autotest --html
+            autotest --no-cov
+            autotest --unit --module autopassword
+    """
+
     _install_test_dependencies()
     
     cmd = _build_test_command(unit, integration, no_cov, html, module)
@@ -32,12 +65,12 @@ def _install_test_dependencies():
         import pytest
         import pytest_cov
     except ImportError:
-        click.echo(click.style("\n❌ pytest and/or pytest-cov not found. Installing...", fg='yellow', bold=True))
+        click.echo(safe_text(click.style("\n[X] 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))
+            subprocess.run([sys.executable, '-m', 'pip', 'install', 'pytest', 'pytest-cov'], check=True)
+            click.echo(safe_text(click.style("[OK] 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))
+            click.echo(safe_text(click.style(f"\n[X] 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
@@ -149,10 +182,10 @@ def _run_test_process(cmd):
         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))
+        click.echo(safe_text(click.style(f"\n[X] 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))
+        click.echo(safe_text(click.style(f"\n[X] ERROR RUNNING TESTS: {str(e)}", fg='red', bold=True)))
         sys.exit(1)
 
 # PREPARES ENVIRONMENT FOR TEST PROCESS
@@ -197,9 +230,7 @@ def _process_test_output(process):
 
 # 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) 
+    if process.returncode == 0: click.echo(safe_text(click.style("\n[OK] ALL TESTS PASSED !", fg='green', bold=True)))
+    else: click.echo(safe_text(click.style("\n[X] SOME TESTS FAILED!", fg='red', bold=True)))
+    _display_coverage_metrics(coverage_data)
+    if process.returncode != 0: sys.exit(1)

autotools/autotodo/__init__.py

@@ -0,0 +1,87 @@
+from autotools.autotodo.core import (
+    DEFAULT_TODO_FILE,
+    PRIORITY_BADGES,
+    TODO_TEMPLATE,
+    _read_todo_file,
+    _write_todo_file,
+    _clean_empty_lines_after_insert,
+    _extract_task_prefix_and_text,
+    _prefix_to_ing,
+    _extract_text_from_tasks_line,
+    _extract_text_from_in_progress_line,
+    _extract_task_text_from_line,
+    _insert_task_into_section,
+    _find_section_boundaries,
+    _calculate_insert_idx,
+    _ensure_tasks_section,
+    _move_in_progress_section,
+    _remove_empty_placeholders,
+    _find_in_progress_position,
+    _handle_in_progress_section,
+    _check_done_sections,
+    _remove_empty_simple_done,
+    _handle_done_section,
+    _ensure_sections,
+    _find_done_section,
+    _find_section_start,
+    _find_section,
+    _create_task_line,
+    _find_last_task_in_section,
+    _insert_task_into_empty_section,
+    _add_task_to_section,
+    _get_task_line_by_index,
+    _move_to_in_progress,
+    _move_to_done,
+    _find_task_lines_in_section,
+    _remove_task,
+    _extract_task_lines_from_section,
+    autotodo_add_task,
+    autotodo_start,
+    autotodo_done,
+    autotodo_remove,
+    autotodo_list
+)
+
+__all__ = [
+    'DEFAULT_TODO_FILE',
+    'PRIORITY_BADGES',
+    'TODO_TEMPLATE',
+    '_read_todo_file',
+    '_write_todo_file',
+    '_clean_empty_lines_after_insert',
+    '_extract_task_prefix_and_text',
+    '_prefix_to_ing',
+    '_extract_text_from_tasks_line',
+    '_extract_text_from_in_progress_line',
+    '_extract_task_text_from_line',
+    '_insert_task_into_section',
+    '_find_section_boundaries',
+    '_calculate_insert_idx',
+    '_ensure_tasks_section',
+    '_move_in_progress_section',
+    '_remove_empty_placeholders',
+    '_find_in_progress_position',
+    '_handle_in_progress_section',
+    '_check_done_sections',
+    '_remove_empty_simple_done',
+    '_handle_done_section',
+    '_ensure_sections',
+    '_find_done_section',
+    '_find_section_start',
+    '_find_section',
+    '_create_task_line',
+    '_find_last_task_in_section',
+    '_insert_task_into_empty_section',
+    '_add_task_to_section',
+    '_get_task_line_by_index',
+    '_move_to_in_progress',
+    '_move_to_done',
+    '_find_task_lines_in_section',
+    '_remove_task',
+    '_extract_task_lines_from_section',
+    'autotodo_add_task',
+    'autotodo_start',
+    'autotodo_done',
+    'autotodo_remove',
+    'autotodo_list'
+]