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

autotools/utils/performance.py

@@ -3,11 +3,17 @@ import gc
 import sys
 import time
 import click
-import resource
 import tracemalloc
 from contextlib import contextmanager
 from typing import Dict, List, Tuple, Optional
 
+try:
+    import resource
+    RESOURCE_AVAILABLE = True
+except ImportError:
+    resource = None
+    RESOURCE_AVAILABLE = False
+
 try:
     import psutil
     PSUTIL_AVAILABLE = True
@@ -19,9 +25,10 @@ ENABLE_PERFORMANCE_METRICS = False
 if os.getenv('AUTOTOOLS_DISABLE_PERF', '').lower() in ('1', 'true', 'yes'): ENABLE_PERFORMANCE_METRICS = False
 
 # FLAG TO ENABLE/DISABLE TRACEMALLOC (CAN BE SLOW IN PRODUCTION)
-# ENABLE BY DEFAULT IN TEST ENVIRONMENTS (DETECTED BY PRESENCE OF PYTEST OR TEST IN SYS.ARGV)
+# ONLY ENABLE IF EXPLICITLY REQUESTED VIA ENV VAR OR IF PYTEST IS ACTUALLY RUNNING
+# DO NOT ENABLE BASED ON ARGUMENT VALUES TO AVOID FALSE POSITIVES (EXAMPLE: "test" AS COMMAND ARGUMENT)
 _ENV_TRACEMALLOC = os.getenv('AUTOTOOLS_ENABLE_TRACEMALLOC', '').lower() in ('1', 'true', 'yes')
-_IS_TEST_ENV = 'pytest' in sys.modules or any('test' in arg.lower() or 'pytest' in arg.lower() for arg in sys.argv)
+_IS_TEST_ENV = 'pytest' in sys.modules or any(arg.endswith('pytest') or arg.endswith('py.test') for arg in sys.argv)
 ENABLE_TRACEMALLOC = _ENV_TRACEMALLOC or _IS_TEST_ENV
 
 # PERFORMANCE METRICS COLLECTOR
@@ -133,47 +140,72 @@ class PerformanceMetrics:
 
     # RECORDS CPU USAGE AT START
     def _record_cpu_start(self):
-        usage = resource.getrusage(resource.RUSAGE_SELF)
-        self.cpu_user_start = usage.ru_utime
-        self.cpu_sys_start = usage.ru_stime
+        if PSUTIL_AVAILABLE:
+            process = psutil.Process()
+            cpu_times = process.cpu_times()
+            self.cpu_user_start = cpu_times.user
+            self.cpu_sys_start = cpu_times.system
+        elif RESOURCE_AVAILABLE:
+            usage = resource.getrusage(resource.RUSAGE_SELF)
+            self.cpu_user_start = usage.ru_utime
+            self.cpu_sys_start = usage.ru_stime
+        else:
+            self.cpu_user_start = time.process_time()
+            self.cpu_sys_start = 0.0
         
     # RECORDS CPU USAGE AT END
     def _record_cpu_end(self):
-        usage = resource.getrusage(resource.RUSAGE_SELF)
-        self.cpu_user_end = usage.ru_utime
-        self.cpu_sys_end = usage.ru_stime
+        if PSUTIL_AVAILABLE:
+            process = psutil.Process()
+            cpu_times = process.cpu_times()
+            self.cpu_user_end = cpu_times.user
+            self.cpu_sys_end = cpu_times.system
+        elif RESOURCE_AVAILABLE:
+            usage = resource.getrusage(resource.RUSAGE_SELF)
+            self.cpu_user_end = usage.ru_utime
+            self.cpu_sys_end = usage.ru_stime
+        else:
+            self.cpu_user_end = time.process_time()
+            self.cpu_sys_end = 0.0
         
     # RECORDS MEMORY USAGE AT START
     def _record_rss_start(self):
         if PSUTIL_AVAILABLE:
             process = psutil.Process()
             self.rss_start = process.memory_info().rss / (1024 * 1024)  # MB
-        else:
+        elif RESOURCE_AVAILABLE:
             usage = resource.getrusage(resource.RUSAGE_SELF)
             self.rss_start = usage.ru_maxrss / 1024  # MB (LINUX) OR KB (MACOS)
             if sys.platform == 'darwin': 
                 self.rss_start = self.rss_start / 1024  # CONVERT KB TO MB ON MACOS
+        else:
+            self.rss_start = 0.0
                 
     # RECORDS MEMORY USAGE AT END
     def _record_rss_end(self):
-        if PSUTIL_AVAILABLE:
-            process = psutil.Process()
-            mem_info = process.memory_info()
-            self.rss_peak = mem_info.rss / (1024 * 1024)  # MB
+        if PSUTIL_AVAILABLE: self._record_rss_end_psutil()
+        elif RESOURCE_AVAILABLE: self._record_rss_end_resource()
+        else: self.rss_peak = self.rss_start if self.rss_start is not None else 0.0
 
-            try:
-                if hasattr(process, 'memory_info_ex'):
-                    mem_ext = process.memory_info_ex()
-                    if hasattr(mem_ext, 'peak_wss'): 
-                        self.rss_peak = max(self.rss_peak, mem_ext.peak_wss / (1024 * 1024))
-            except Exception:
-                pass
-        else:
-            usage = resource.getrusage(resource.RUSAGE_SELF)
-            rss_current = usage.ru_maxrss / 1024
-            if sys.platform == 'darwin': 
-                rss_current = rss_current / 1024
-            self.rss_peak = max(self.rss_start, rss_current) if self.rss_start else rss_current
+    # RECORDS MEMORY USAGE AT END USING PSUTIL
+    def _record_rss_end_psutil(self):
+        process = psutil.Process()
+        mem_info = process.memory_info()
+        self.rss_peak = mem_info.rss / (1024 * 1024) # MB
+
+        try:
+            if hasattr(process, 'memory_info_ex'):
+                mem_ext = process.memory_info_ex()
+                if hasattr(mem_ext, 'peak_wss'): self.rss_peak = max(self.rss_peak, mem_ext.peak_wss / (1024 * 1024))
+        except Exception:
+            pass
+
+    # RECORDS MEMORY USAGE AT END USING RESOURCE
+    def _record_rss_end_resource(self):
+        usage = resource.getrusage(resource.RUSAGE_SELF)
+        rss_current = usage.ru_maxrss / 1024
+        if sys.platform == 'darwin': rss_current = rss_current / 1024
+        self.rss_peak = max(self.rss_start, rss_current) if self.rss_start else rss_current
             
     # RECORDS FILESYSTEM I/O AT START
     def _record_fs_start(self):
@@ -217,15 +249,15 @@ class PerformanceMetrics:
         
     # CALCULATES DURATION METRICS IN MILLISECONDS
     def _calculate_durations(self) -> Tuple[float, float, float]:
-        total_duration_ms = (self.process_end - self.process_start) * 1000 if self.process_end and self.process_start else 0
-        startup_duration_ms = (self.startup_end - self.startup_start) * 1000 if self.startup_end and self.startup_start else 0
-        command_duration_ms = (self.command_end - self.command_start) * 1000 if self.command_end and self.command_start else 0
+        total_duration_ms = (self.process_end - self.process_start) * 1000 if self.process_end is not None and self.process_start is not None else 0
+        startup_duration_ms = (self.startup_end - self.startup_start) * 1000 if self.startup_end is not None and self.startup_start is not None else 0
+        command_duration_ms = (self.command_end - self.command_start) * 1000 if self.command_end is not None and self.command_start is not None else 0
         return total_duration_ms, startup_duration_ms, command_duration_ms
         
     # CALCULATES CPU TIME METRICS IN MILLISECONDS
     def _calculate_cpu_time(self) -> Tuple[float, float, float]:
-        cpu_user_ms = (self.cpu_user_end - self.cpu_user_start) * 1000 if self.cpu_user_end and self.cpu_user_start else 0
-        cpu_sys_ms = (self.cpu_sys_end - self.cpu_sys_start) * 1000 if self.cpu_sys_end and self.cpu_sys_start else 0
+        cpu_user_ms = (self.cpu_user_end - self.cpu_user_start) * 1000 if self.cpu_user_end is not None and self.cpu_user_start is not None else 0
+        cpu_sys_ms = (self.cpu_sys_end - self.cpu_sys_start) * 1000 if self.cpu_sys_end is not None and self.cpu_sys_start is not None else 0
         cpu_time_total_ms = cpu_user_ms + cpu_sys_ms
         return cpu_time_total_ms, cpu_user_ms, cpu_sys_ms
         
@@ -260,9 +292,9 @@ class PerformanceMetrics:
         
     # CALCULATES FILESYSTEM I/O METRICS
     def _calculate_fs_io(self) -> Tuple[int, int, int]:
-        fs_bytes_read_total = self.fs_read_end - self.fs_read_start if self.fs_read_end and self.fs_read_start else 0
-        fs_bytes_written_total = self.fs_write_end - self.fs_write_start if self.fs_write_end and self.fs_write_start else 0
-        fs_ops_count = self.fs_ops_end - self.fs_ops_start if self.fs_ops_end and self.fs_ops_start else 0
+        fs_bytes_read_total = self.fs_read_end - self.fs_read_start if self.fs_read_end is not None and self.fs_read_start is not None else 0
+        fs_bytes_written_total = self.fs_write_end - self.fs_write_start if self.fs_write_end is not None and self.fs_write_start is not None else 0
+        fs_ops_count = self.fs_ops_end - self.fs_ops_start if self.fs_ops_end is not None and self.fs_ops_start is not None else 0
         return fs_bytes_read_total, fs_bytes_written_total, fs_ops_count
 
     # CALCULATES AND RETURNS ALL PERFORMANCE METRICS AS A DICTIONARY

autotools/utils/requirements.py

@@ -0,0 +1,21 @@
+import os
+
+# READ REQUIREMENTS FROM A FILE AND RETURN AS A LIST
+# HANDLES MISSING FILES GRACEFULLY BY RETURNING AN EMPTY LIST
+# THE FILENAME IS RELATIVE TO THE PROJECT ROOT (WHERE SETUP.PY IS LOCATED)
+def read_requirements(filename="requirements.txt"):
+    project_root = os.path.join(os.path.dirname(__file__), "..", "..")
+    requirements_path = os.path.join(os.path.abspath(project_root), filename)
+
+    try:
+        with open(requirements_path, "r", encoding="utf-8") as fh:
+            requirements = []
+
+            for line in fh:
+                line = line.strip()
+                if line.startswith("-r") or line.startswith("--requirement"): continue
+                if line and not line.startswith("#"): requirements.append(line)
+
+            return requirements
+    except FileNotFoundError:
+        return []

autotools/utils/smoke.py

@@ -0,0 +1,246 @@
+import os
+import sys
+import time
+import click
+import tempfile
+import subprocess
+
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple
+from .commands import discover_tool_command_entries, get_tool_category
+
+# NORMALIZES SMOKE TEST DEFINITIONS TO A LIST OF (NAME, ARGS)
+def _normalize_smoke_test_item(item: Any, default_name: str) -> Tuple[str, List[str]]:
+    if isinstance(item, dict):
+        name = item.get('name') or default_name
+        args = item.get('args') or []
+        if not isinstance(args, list):
+            raise TypeError("SMOKE_TESTS ITEM 'args' MUST BE A LIST")
+        return str(name), [str(x) for x in args]
+
+    if isinstance(item, (list, tuple)) and len(item) == 2 and isinstance(item[0], str):
+        name = item[0] or default_name
+        args = item[1] or []
+        if not isinstance(args, list):
+            raise TypeError("SMOKE_TESTS TUPLE SECOND ITEM MUST BE A LIST")
+        return str(name), [str(x) for x in args]
+
+    if isinstance(item, list): return default_name, [str(x) for x in item]
+    raise TypeError("SMOKE_TESTS ITEMS MUST BE dict OR (name, args) OR args-list")
+
+def _normalize_smoke_tests(value: Any) -> List[Tuple[str, List[str]]]:
+    if not value: return []
+    if not isinstance(value, list):
+        raise TypeError("SMOKE_TESTS MUST BE A LIST")
+
+    tests: List[Tuple[str, List[str]]] = []
+    for idx, item in enumerate(value):
+        tests.append(_normalize_smoke_test_item(item, default_name=f"case{idx + 1}"))
+
+    return tests
+
+# BUILDS A BASIC INVOCATION FOR A TOOL USING CLICK PARAMS (BEST-EFFORT)
+def _build_default_case(tool: str, cmd: click.Command, tool_dir: Path) -> Tuple[str, List[str]]:
+    if tool == 'autocolor': return ('basic', ['#FF5733'])
+
+    if tool == 'autoconvert':
+        input_path = tool_dir / 'input.txt'
+        input_path.parent.mkdir(parents=True, exist_ok=True)
+        input_path.write_text('SMOKE TEST\n', encoding='utf-8')
+
+        output_path = tool_dir / 'output.json'
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        return ('txt-json', [str(input_path), str(output_path)])
+
+    required_opts = [p for p in cmd.params if isinstance(p, click.Option) and p.required]
+    args_params = [p for p in cmd.params if isinstance(p, click.Argument)]
+    argv: List[str] = []
+
+    for opt in required_opts:
+        flag = (opt.opts[0] if opt.opts else f'--{opt.name}')
+        if opt.is_flag:
+            argv.append(flag)
+            continue
+        argv.extend([flag, _value_for_param(opt, tool_dir)])
+
+    for arg in args_params:
+        count = 1
+        if isinstance(arg.nargs, int) and arg.nargs > 1: count = arg.nargs
+        for _ in range(count): argv.append(_value_for_param(arg, tool_dir))
+
+    return ('default', argv)
+
+# GENERATES A VALUE FOR A CLICK PARAM (BEST-EFFORT)
+def _value_for_param(param: click.Parameter, tool_dir: Path) -> str:
+    name = (param.name or '').lower()
+    if 'color' in name: return '#FF5733'
+
+    looks_like_path = any(k in name for k in ['file', 'path', 'source', 'input', 'output', 'dir', 'folder', 'archive'])
+    if isinstance(getattr(param, 'type', None), click.Path) or looks_like_path:
+        if any(k in name for k in ['input', 'source']):
+            p = tool_dir / f'{param.name or "input"}.txt'
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text('SMOKE TEST\n', encoding='utf-8')
+            return str(p)
+
+        suffix = '.zip' if 'zip' in name or 'archive' in name or 'output' in name else '.out'
+        p = tool_dir / f'{param.name or "output"}{suffix}'
+        p.parent.mkdir(parents=True, exist_ok=True)
+        return str(p)
+
+    t = getattr(param, 'type', None)
+    if isinstance(t, click.Choice) and t.choices: return str(t.choices[0])
+
+    return 'test'
+
+# VERBOSE HELPERS (KEEP _run_subprocess SIMPLE)
+# FOR CMD
+def _echo_cmd(argv: Sequence[str], verbose: bool) -> None:
+    if not verbose: return
+    click.echo(click.style(f"$ {' '.join(argv)}", fg='cyan', bold=True))
+
+# FOR OUTPUT
+def _echo_output(output: str, verbose: bool) -> None:
+    if not verbose: return
+    if not output.strip(): return
+    click.echo(output.rstrip())
+
+# FOR DURATION
+def _echo_duration(duration: float, verbose: bool) -> None:
+    if not verbose: return
+    click.echo(click.style(f"({duration:.2f}s)", fg='bright_black'))
+
+# FOR TIMEOUT
+def _echo_timeout(timeout_s: int, verbose: bool) -> None:
+    if not verbose: return
+    click.echo(click.style(f"TIMEOUT AFTER {timeout_s}s", fg='red', bold=True))
+
+# FOR PERMISSION ERROR
+def _echo_permission_error(err: Exception, verbose: bool) -> None:
+    if not verbose: return
+    click.echo(click.style(f"PERMISSION ERROR: {err}", fg='red', bold=True))
+
+# RUNS ONE COMMAND AND RETURNS (STATUS, RC, DURATION_S, OUTPUT)
+def _run_subprocess(argv: Sequence[str], timeout_s: int, verbose: bool) -> Tuple[str, int, float, str]:
+    start = time.perf_counter()
+    try:
+        completed = subprocess.run( list(argv), text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=timeout_s, env=dict(os.environ))
+        duration = time.perf_counter() - start
+        output = completed.stdout or ''
+        status = 'OK' if completed.returncode == 0 else 'X'
+
+        _echo_cmd(argv, verbose)
+        _echo_output(output, verbose)
+        _echo_duration(duration, verbose)
+
+        return status, completed.returncode, duration, output
+    except PermissionError as e:
+        duration = time.perf_counter() - start
+        if duration >= timeout_s:
+            _echo_cmd(argv, verbose)
+            _echo_timeout(timeout_s, verbose)
+            return 'TIMEOUT', 124, duration, ''
+
+        _echo_cmd(argv, verbose)
+        _echo_permission_error(e, verbose)
+        return 'X', 126, duration, str(e)
+    except subprocess.TimeoutExpired as e:
+        duration = time.perf_counter() - start
+        output = (e.stdout or '') if hasattr(e, 'stdout') else ''
+
+        _echo_cmd(argv, verbose)
+        _echo_timeout(timeout_s, verbose)
+
+        return 'TIMEOUT', 124, duration, output
+
+# PRINTS A SUMMARY TABLE (SIMILAR TO docker/run_tests.sh)
+def _print_summary(results: List[Dict[str, Any]], platform: str) -> None:
+    click.echo(f"\n=== Smoke Test Results Summary for {platform} ===")
+    click.echo("┌────────────────┬──────────────────┬──────────────┬────────┐")
+    click.echo("│ Category      │ Tool            │ Feature      │ Status │")
+    click.echo("├────────────────┼──────────────────┼──────────────┼────────┤")
+
+    for r in results:
+        category = r.get('category', 'Other')
+        tool = r.get('tool', '')
+        feature = r.get('case', '')
+        status = r.get('status', '')
+        click.echo(f"│ {category:<12} │ {tool:<14} │ {feature:<12} │ {status:<6} │")
+
+    click.echo("└────────────────┴──────────────────┴──────────────┴────────┘")
+
+# RETURNS THE PUBLIC CLI NAME FOR A TOOL PACKAGE
+def _tool_public_name(tool_name: str) -> str:
+    return 'test' if tool_name == 'autotest' else tool_name
+
+# DECIDES WHETHER A TOOL SHOULD RUN GIVEN include/exclude FILTERS
+def _should_run_tool(tool_name: str, public_name: str, include: set[str], exclude: set[str]) -> bool:
+    if include and tool_name not in include and public_name not in include: return False
+    if tool_name in exclude or public_name in exclude: return False
+    return True
+
+# CHOOSES SMOKE TESTS FOR A TOOL (MODULE-DEFINED OR DEFAULT)
+def _get_smoke_tests(mod: Any, tool_name: str, cmd: click.Command, tool_dir: Path) -> List[Tuple[str, List[str]]]:
+    smoke_tests = _normalize_smoke_tests(getattr(mod, 'SMOKE_TESTS', None))
+    if smoke_tests: return smoke_tests
+    return [_build_default_case(tool_name, cmd, tool_dir)]
+
+# WORKDIR CONTEXT (CLEANUP ONLY WHEN WE CREATED THE TEMP DIR)
+@contextmanager
+def _smoke_root(workdir: Optional[str]) -> Iterator[Path]:
+    if workdir:
+        root = Path(workdir)
+        root.mkdir(parents=True, exist_ok=True)
+        yield root
+        return
+
+    with tempfile.TemporaryDirectory(prefix='autotools_smoke_') as d: yield Path(d)
+
+# RUNS ALL CASES FOR A TOOL AND RETURNS RESULT ROWS
+def _run_tool_smoke(public_name: str, mod: Any, smoke_tests: List[Tuple[str, List[str]]], timeout_s: int, verbose: bool) -> List[Dict[str, Any]]:
+    rows: List[Dict[str, Any]] = []
+    for case_name, case_args in smoke_tests:
+        argv = [sys.executable, '-m', 'autotools.cli', public_name, *case_args]
+        status, rc, duration_s, output = _run_subprocess(argv, timeout_s=timeout_s, verbose=verbose)
+
+        rows.append({
+            'category': get_tool_category(mod),
+            'tool': public_name,
+            'case': case_name,
+            'status': status if status in ('OK', 'X') else 'X',
+            'returncode': rc,
+            'duration_s': round(duration_s, 3),
+            'cmd': argv,
+            'output': output if (verbose or status != 'OK') else '',
+        })
+
+    return rows
+
+# MAIN SMOKE ENTRYPOINT
+def run_smoke(workdir: Optional[str], timeout_s: int, include: set[str], exclude: set[str], verbose: bool, platform: str, print_table: bool = True) -> List[Dict[str, Any]]:
+    entries = discover_tool_command_entries()
+
+    if 'test' not in include and 'autotest' not in include: exclude = set(exclude) | {'autotest', 'test'}
+
+    with _smoke_root(workdir) as root:
+        run_root = root / f"smoke_{int(time.time())}"
+        run_root.mkdir(parents=True, exist_ok=True)
+
+        results: List[Dict[str, Any]] = []
+        for tool_name in sorted(entries):
+            mod, cmd = entries[tool_name]
+            public_name = _tool_public_name(tool_name)
+
+            if not _should_run_tool(tool_name, public_name, include, exclude): continue
+
+            tool_dir = run_root / tool_name
+            tool_dir.mkdir(parents=True, exist_ok=True)
+
+            smoke_tests = _get_smoke_tests(mod, tool_name, cmd, tool_dir)
+            results.extend(_run_tool_smoke(public_name, mod, smoke_tests, timeout_s=timeout_s, verbose=verbose))
+
+        if print_table: _print_summary(results, platform=platform)
+
+        return results
+

autotools/utils/text.py

@@ -0,0 +1,73 @@
+import sys
+import os
+import re
+from typing import Any
+
+# ENSURE TEXT IS SAFE TO WRITE TO THE CURRENT STDOUT ENCODING
+# SOME WINDOWS TERMINALS USE LEGACY ENCODINGS THAT CANNOT ENCODE CERTAIN CHARACTERS
+def safe_text(text: Any) -> Any:
+    if not isinstance(text, str): return text
+
+    encoding = getattr(sys.stdout, "encoding", None) or "utf-8"
+
+    try:
+        text.encode(encoding)
+        return text
+    except Exception:
+        try: return text.encode(encoding, errors="replace").decode(encoding)
+        except Exception: return text.encode("ascii", errors="replace").decode("ascii")
+
+# DETECTS IF RUNNING IN A CI/CD ENVIRONMENT
+def is_ci_environment():
+    ci_vars = ['CI', 'GITHUB_ACTIONS', 'GITLAB_CI', 'JENKINS_URL', 'TRAVIS', 'CIRCLECI', 'APPVEYOR', 'BUILDKITE', 'TEAMCITY']
+    return any(os.getenv(var) for var in ci_vars)
+
+# MASKS IPV4 ADDRESSES (EXAMPLE: 192.168.1.1 -> xxx.xxx.xxx.xxx)
+def mask_ipv4(ip: str) -> str:
+    if not ip or not isinstance(ip, str): return ip
+    parts = ip.split('.')
+    if len(parts) == 4 and all(p.isdigit() and 0 <= int(p) <= 255 for p in parts): return 'xxx.xxx.xxx.xxx'
+    return ip
+
+# MASKS IPV6 ADDRESSES (EXAMPLE: 2001:0db8::1 -> xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx)
+def mask_ipv6(ip: str) -> str:
+    if not ip or not isinstance(ip, str): return ip
+    clean_ip = ip.split('%')[0]
+    if ':' in clean_ip: return 'xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx'
+    return ip
+
+# MASKS ALL IP ADDRESSES IN A STRING
+def mask_ips_in_text(text: str) -> str:
+    if not isinstance(text, str): return text
+    
+    # MASK IPV4 ADDRESSES FIRST
+    ipv4_pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
+    text = re.sub(ipv4_pattern, lambda m: mask_ipv4(m.group()) if all(0 <= int(p) <= 255 for p in m.group().split('.')) else m.group(), text)
+    
+    # MASK IPV6 ADDRESSES - HANDLE ALL FORMATS INCLUDING COMPRESSED
+    # COMPRESSED AT START: ::1, ::8a2e:370:7334
+    ipv6_compressed_start = r'(?<![0-9a-fA-F:])::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}(?![0-9a-fA-F:])'
+    text = re.sub(ipv6_compressed_start, lambda m: mask_ipv6(m.group()), text)
+    
+    # COMPRESSED WITH :: IN MIDDLE: 2001:db8::1, 2001:db8::8a2e:370:7334
+    # FLEXIBLE PATTERN: ANY NUMBER OF HEX GROUPS BEFORE ::, THEN ::, THEN ANY NUMBER AFTER
+    ipv6_compressed_mid = r'(?<![0-9a-fA-F:])[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})+::[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})*(?![0-9a-fA-F:])'
+    text = re.sub(ipv6_compressed_mid, lambda m: mask_ipv6(m.group()), text)
+    
+    # COMPRESSED AT END: 2001:db8::
+    ipv6_compressed_end = r'(?<![0-9a-fA-F:])[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})+::(?![0-9a-fA-F:])'
+    text = re.sub(ipv6_compressed_end, lambda m: mask_ipv6(m.group()), text)
+    
+    # FULL FORMAT: 2001:0db8:85a3:0000:0000:8a2e:0370:7334
+    ipv6_full = r'(?<![0-9a-fA-F:])(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}(?![0-9a-fA-F:])'
+    text = re.sub(ipv6_full, lambda m: mask_ipv6(m.group()), text)
+    
+    return text
+
+# MASKS SENSITIVE INFORMATION IN TEXT (IPS, LOCATION DATA, ETC.)
+def mask_sensitive_info(text: str, mask_ips: bool = True) -> str:
+    if not isinstance(text, str): return text    
+    if mask_ips: text = mask_ips_in_text(text)
+    coord_pattern = r'-?\d+\.\d+,-?\d+\.\d+'
+    text = re.sub(coord_pattern, '[REDACTED]', text)
+    return text

open_autotools-0.0.5.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: Open-AutoTools
+Version: 0.0.5
+Summary: A suite of automated tools accessible via CLI with a simple `autotools` command
+Home-page: https://github.com/BabylooPro/Open-AutoTools
+Author: BabylooPro
+Author-email: maxremy.dev@gmail.com
+License: MIT
+Project-URL: Bug Tracker, https://github.com/BabylooPro/Open-AutoTools/issues
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.3
+Requires-Dist: requests>=2.31.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: packaging>=23.0
+Requires-Dist: halo>=0.0.31
+Requires-Dist: pyperclip>=1.8.2
+Requires-Dist: speedtest-cli>=2.1.3
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: cryptography>=42.0.2
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: pydub>=0.25.1
+Requires-Dist: moviepy>=1.0.3
+Requires-Dist: pint>=0.23
+Provides-Extra: dev
+Provides-Extra: test
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# OPEN-AUTOTOOLS
+
+[PYPI_BADGE]: https://badge.fury.io/py/Open-AutoTools.svg
+[PYPI_URL]: https://pypi.org/project/Open-AutoTools/
+[PYTHON_BADGE]: https://img.shields.io/badge/Python-3.10+-blue.svg
+[PYTHON_URL]: https://www.python.org/downloads/
+[CHANGELOG_BADGE]: https://img.shields.io/badge/CHANGELOG-red.svg
+[CHANGELOG_URL]: CHANGELOG.md
+[TODO_BADGE]: https://img.shields.io/badge/TODO-purple.svg
+[TODO_URL]: TODO.md
+
+[![PyPI][PYPI_BADGE]][PYPI_URL] [![Python][PYTHON_BADGE]][PYTHON_URL] [![CHANGELOG][CHANGELOG_BADGE]][CHANGELOG_URL] [![TODO][TODO_BADGE]][TODO_URL]
+
+Python CLI toolkit for everyday developer tasks. Boost productivity directly from your terminal.
+
+https://github.com/user-attachments/assets/f959327b-b4ae-481d-8be0-c8957fb6ad36
+
+## Quick Install
+
+```bash
+pip install open-autotools
+```
+
+- **Platform**: Windows 10/11 ✓ | macOS ✓ | Linux ✓
+- **Python**: 3.10 | 3.11 | 3.12 | 3.13 | 3.14
+
+See [Installation Guide](docs/installation.md) for more details.
+
+## Tools
+
+- **[AutoCaps](docs/tools/autocaps.md)** - Convert text to uppercase
+- **[AutoLower](docs/tools/autolower.md)** - Convert text to lowercase
+- **[AutoPassword](docs/tools/autopassword.md)** - Generate secure passwords and encryption keys
+- **[AutoIP](docs/tools/autoip.md)** - Display network information and diagnostics
+- **[AutoConvert](docs/tools/autoconvert.md)** - Convert text, images, audio, and video between formats
+- **[AutoColor](docs/tools/autocolor.md)** - Convert color codes between different formats (hex, RGB, HSL, etc)
+- **[AutoUnit](docs/tools/autounit.md)** - Convert measurement units (meters to feet, liters to gallons, etc)
+- **[AutoZip](docs/tools/autozip.md)** - Compress files and directories into various archive formats (ZIP, TAR.GZ, TAR.BZ2, TAR.XZ, TAR)
+- **[AutoTodo](docs/tools/autotodo.md)** - Create and manage a simple task list in a Markdown file
+- **[AutoNote](docs/tools/autonote.md)** - Takes quick notes and saves them to a Markdown file
+- **[Test Suite](docs/tools/autotest.md)** - Run the test suite (development only)
+
+## Documentation
+
+- [Installation](docs/installation.md) - Install the CLI and verify your setup
+- [Development](docs/development.md) - Dev environment, tooling, and contribution workflow
+- [Testing](docs/testing.md) - Run tests, install test deps, and check coverage
+- [Performance](docs/performance.md) - Performance metrics: what’s collected and how to enable them
+- [Docker Support](docs/docker.md) - Run the toolkit and tests in Docker
+
+## License
+
+MIT - see [LICENSE](LICENSE).

open_autotools-0.0.5.dist-info/RECORD

@@ -0,0 +1,54 @@
+autotools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/cli.py,sha256=N05N7kJV1290lHhTMw5YT18t_G-aAUuaMTvNOig1aZs,6703
+autotools/autocaps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autocaps/commands.py,sha256=MzAseF0zQ7pm8gHZK-a1DI8a-9xMDNd1smOfvHVuAho,1058
+autotools/autocaps/core.py,sha256=v0VGndr_6LAN7j5eQiUe1dGnP8GMRNsZmOoL-Z5hJbM,259
+autotools/autocolor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autocolor/commands.py,sha256=7qsUQLtsp3qjR5QkCXaFolN8mlKkxqf9h-zEUadOUls,2118
+autotools/autocolor/core.py,sha256=kAR81-pNwOQiEXPB2hD4ungiBOy8fWwmpIZsRZeBEx8,3853
+autotools/autoconvert/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autoconvert/commands.py,sha256=3E_TIbHPKYooSWEJRaV_L7WyRlirlrt9EyncAB_ST04,3169
+autotools/autoconvert/core.py,sha256=QD82THQOzu77j_aF1G8sOseP1byIqVqGYncJt50jnts,2278
+autotools/autoconvert/conversion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autoconvert/conversion/convert_audio.py,sha256=LSn1vx0R6oqHuYusuiuSGndterTBCvxe6OfJQJK2XgA,932
+autotools/autoconvert/conversion/convert_image.py,sha256=aeWyYsU4JATe3ALD1OjB7wQTNcvjOK3lveEJQMnbws4,1258
+autotools/autoconvert/conversion/convert_text.py,sha256=_q2qdZMIx8eMRUc_kdG0Cci2UqA3uvgo224ayV71l98,3466
+autotools/autoconvert/conversion/convert_video.py,sha256=IptBrQsOHmD2_72MQmO3KzZXgz5g_DlaROytP0LJ6Bo,969
+autotools/autoip/__init__.py,sha256=T_5hz9G4reFPXDucdzRoMFPYlAKwTPt9TejOpkRPgn0,23
+autotools/autoip/commands.py,sha256=5kWfNugQTJRWuwgWN2cVB33h-nISxHsv1EiaL_0vQK4,2276
+autotools/autoip/core.py,sha256=x4Fuq3yiyjkgoAGBWsaAHkmImpIpes3OtHM-RXOlitU,11369
+autotools/autolower/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autolower/commands.py,sha256=R5yzyVB50uRQFHiMske2h_1TSv2aKurfb2Hfhsog8kQ,1064
+autotools/autolower/core.py,sha256=PLxP9eKoC_NY-ZGPgTxRLxNufv0VGrmOJjjSC_n1zog,259
+autotools/autonote/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autonote/commands.py,sha256=srvlbG9F2KQH3c5gU_4N435bzkJrBSgqHckTMgICGdM,2787
+autotools/autonote/core.py,sha256=bWTagr0XoM1CArB079m4Km_ZHHWZty3nfeGq_0MN28U,3525
+autotools/autopassword/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autotools/autopassword/commands.py,sha256=LAQWw7jhJj7OBTNOSHI_QXYaEjJiQuYydZg-28OjIFs,4378
+autotools/autopassword/core.py,sha256=xSD4--oqEgnWQD4mlymUfL_qbH_7J8caqfenGCYBXcA,2481
+autotools/autotest/__init__.py,sha256=G4bK86_araxN2j10W8wEX-ol9zXKNhXq8FtPcOj4_p4,55
+autotools/autotest/commands.py,sha256=QntQrRkJnLavjaJ3AnkGTtn_C4tMwJzllbbOy00f960,8540
+autotools/autotodo/__init__.py,sha256=P5LHjf1OTx78PfSSn2Ex7i7KIq94IF-rruWdV_sH3ak,2349
+autotools/autotodo/commands.py,sha256=uu8jSSOhiq3qfQt_lLAJozqPXnn_OvFxR7FB62kfEts,5981
+autotools/autotodo/core.py,sha256=EBkpkYanBJK8Uw7h5CEnIX044EOO86NdOk1LgQnnVTk,25301
+autotools/autounit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autounit/commands.py,sha256=-RO26l0tmCsU4XkzRfMylHpdpQCEnrty51CawTWYObU,1978
+autotools/autounit/core.py,sha256=ty2j15-f3LoF6902aZq70TfXZR82YAb-PGrYMA3rbfY,1331
+autotools/autozip/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autozip/commands.py,sha256=AjlB3rWOBaz_6ghb5k7747jz1JPXxtqeUXliNWb4nmg,3283
+autotools/autozip/core.py,sha256=ATVh9Trd5RlW7fha3jTeSE2MldA00Ii6r-NprjPCloE,4881
+autotools/utils/__init__.py,sha256=2uAirI6ZbOwSFPSg5wuEjA0gMWf1XBJ4yP_WcGeND7M,183
+autotools/utils/commands.py,sha256=V2EVGiAG2o4dlc7vqdkDA1lQLQJ7IL2QeGWqiTUqC0E,5272
+autotools/utils/loading.py,sha256=yvXQI6FdIJBjRb40R2LTIgDxxNyiv_23p5ixYkQcGtg,752
+autotools/utils/performance.py,sha256=wa9dL9NM8XzLz5yEkQvV9jjKXj8qAVWf6QrIzMyFqA0,17945
+autotools/utils/requirements.py,sha256=hngCUozh_r9lGXk0CmL7H9JOpvk1whEZp9uaa-oXCrI,822
+autotools/utils/smoke.py,sha256=QjdN3u1t1PPw8npxFBk1oUZVVsqZUsZfLgff4ZYg6Y8,10472
+autotools/utils/text.py,sha256=IERFAD6Zu9dDz60kcnEomTmjKM3BzgDjDBNPDwJZADw,3286
+autotools/utils/updates.py,sha256=FrwGGMI9rv-bUrsIpttRnBNXUAOlPpBb85GcYXa_o6A,1447
+autotools/utils/version.py,sha256=ruKZcuLN77yO2x0AwjfyaHlncaHE-8GDzzSIBr-agTc,3082
+open_autotools-0.0.5.dist-info/licenses/LICENSE,sha256=SpbSRxNWos2l0-geleCa6d0L9G_bOsZRkY4rB9OduJ0,1069
+open_autotools-0.0.5.dist-info/METADATA,sha256=wu9AduzHU1TbCoHOVo7MNTXTE3qkSbIA4EQjY-9MP0k,3999
+open_autotools-0.0.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+open_autotools-0.0.5.dist-info/entry_points.txt,sha256=lAzrnUr-_1qL4QHM7YgyVe11ipdmnbkvYYQWhkgDRHU,400
+open_autotools-0.0.5.dist-info/top_level.txt,sha256=x5ZRvdQw7DQnVmR0YDqVSAuuS94KTHDmk6uIeW7YOPw,10
+open_autotools-0.0.5.dist-info/RECORD,,

{open_autotools-0.0.4rc1.dist-info → open_autotools-0.0.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any