machineconfig 5.81__tar.gz → 5.83__tar.gz

{machineconfig-5.81/src/machineconfig.egg-info → machineconfig-5.83}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 5.81
+Version: 5.83
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{machineconfig-5.81 → machineconfig-5.83}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "5.81"
+version = "5.83"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}

{machineconfig-5.81 → machineconfig-5.83}/src/machineconfig/scripts/python/nw/ssh_debug_linux.py

@@ -83,6 +83,27 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
         results["ssh_service"] = {"status": "warning", "message": "systemctl not found, cannot check service status", "action": "Check SSH service manually"}
         console.print(Panel("⚠️  systemctl not found\n💡 Check SSH service status manually", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
     
+    console.print(Panel("🌐 Checking network interfaces and IP addresses...", title="[bold blue]Network Interfaces[/bold blue]", border_style="blue"))
+    
+    try:
+        ip_addr_check = subprocess.run(["ip", "addr", "show"], capture_output=True, text=True, check=False)
+        if ip_addr_check.returncode == 0:
+            ip_output = ip_addr_check.stdout
+            import re
+            inet_pattern = re.compile(r'inet\s+(\d+\.\d+\.\d+\.\d+)/\d+.*scope\s+global')
+            ip_addresses = inet_pattern.findall(ip_output)
+            
+            if ip_addresses:
+                results["network_interfaces"] = {"status": "ok", "message": f"Found {len(ip_addresses)} network interface(s)", "action": ""}
+                console.print(Panel("✅ Network interfaces found:\n" + "\n".join([f"  • {ip}" for ip in ip_addresses]), title="[bold green]IP Addresses[/bold green]", border_style="green"))
+            else:
+                results["network_interfaces"] = {"status": "warning", "message": "No global IP addresses found", "action": "Check network configuration"}
+                issues_found.append("No network IP addresses")
+                console.print(Panel("⚠️  No global IP addresses found\n💡 This machine may not be reachable on the network\n💡 Check: ip addr show", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
+    except FileNotFoundError:
+        results["network_interfaces"] = {"status": "warning", "message": "ip command not found", "action": "Check network manually"}
+        console.print(Panel("⚠️  'ip' command not found\n💡 Try: ifconfig", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
+    
     console.print(Panel("🔌 Checking SSH port and listening status...", title="[bold blue]Network Status[/bold blue]", border_style="blue"))
     
     sshd_config_paths = [PathExtended("/etc/ssh/sshd_config"), PathExtended("/etc/sshd_config")]
@@ -129,8 +150,20 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
         if listening_check.returncode == 0:
             listening_output = listening_check.stdout
             if f":{ssh_port}" in listening_output:
-                results["ssh_listening"] = {"status": "ok", "message": f"SSH is listening on port {ssh_port}", "action": ""}
-                console.print(Panel(f"✅ SSH is listening on port {ssh_port}", title="[bold green]OK[/bold green]", border_style="green"))
+                ssh_lines = [line for line in listening_output.split("\n") if f":{ssh_port}" in line]
+                listening_on_all = any("0.0.0.0" in line or "[::]" in line for line in ssh_lines)
+                listening_on_localhost_only = all("127.0.0.1" in line or "[::1]" in line for line in ssh_lines)
+                
+                if listening_on_localhost_only:
+                    results["ssh_listening"] = {"status": "error", "message": f"SSH is listening ONLY on localhost (127.0.0.1:{ssh_port}), not accessible from network", "action": "Edit /etc/ssh/sshd_config, check ListenAddress, restart SSH"}
+                    issues_found.append("SSH listening only on localhost")
+                    console.print(Panel(f"❌ SSH is listening ONLY on localhost (127.0.0.1:{ssh_port})\n💡 This prevents external connections!\n💡 Check /etc/ssh/sshd_config for 'ListenAddress'\n💡 Remove or comment out 'ListenAddress 127.0.0.1'\n💡 Or change to 'ListenAddress 0.0.0.0'\n💡 Then: sudo systemctl restart ssh", title="[bold red]Critical Issue[/bold red]", border_style="red"))
+                elif listening_on_all:
+                    results["ssh_listening"] = {"status": "ok", "message": f"SSH is listening on all interfaces (0.0.0.0:{ssh_port})", "action": ""}
+                    console.print(Panel(f"✅ SSH is listening on all interfaces (0.0.0.0:{ssh_port})\n✅ Should be accessible from network", title="[bold green]OK[/bold green]", border_style="green"))
+                else:
+                    results["ssh_listening"] = {"status": "ok", "message": f"SSH is listening on port {ssh_port}", "action": ""}
+                    console.print(Panel(f"✅ SSH is listening on port {ssh_port}\n\nListening on:\n" + "\n".join([f"  {line.strip()}" for line in ssh_lines[:3]]), title="[bold green]OK[/bold green]", border_style="green"))
             else:
                 results["ssh_listening"] = {"status": "error", "message": f"SSH is NOT listening on port {ssh_port}", "action": "Check if SSH service is running and configured correctly"}
                 issues_found.append(f"SSH not listening on port {ssh_port}")
@@ -206,7 +239,9 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
     hosts_deny = PathExtended("/etc/hosts.deny")
     if hosts_deny.exists():
         hosts_deny_content = hosts_deny.read_text(encoding="utf-8")
-        if "sshd" in hosts_deny_content.lower() or "all" in hosts_deny_content.lower():
+        active_lines = [line.strip() for line in hosts_deny_content.splitlines() if line.strip() and not line.strip().startswith("#")]
+        active_content_lower = " ".join(active_lines).lower()
+        if "sshd" in active_content_lower or "all" in active_content_lower:
             results["hosts_deny"] = {"status": "error", "message": "/etc/hosts.deny may be blocking SSH connections", "action": "Review /etc/hosts.deny and remove SSH blocks"}
             issues_found.append("/etc/hosts.deny blocking SSH")
             console.print(Panel("❌ /etc/hosts.deny may be blocking SSH\n💡 Check: cat /etc/hosts.deny\n💡 Remove any lines blocking 'sshd' or 'ALL'", title="[bold red]Critical Issue[/bold red]", border_style="red"))
@@ -285,6 +320,30 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
         results["ssh_logs"] = {"status": "warning", "message": "SSH log files not found", "action": "Check journalctl: sudo journalctl -u ssh"}
         console.print(Panel("⚠️  SSH log files not found\n💡 Check: sudo journalctl -u ssh -n 50", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
     
+    console.print(Panel("🧪 Testing local SSH connection...", title="[bold blue]Connection Test[/bold blue]", border_style="blue"))
+    
+    try:
+        local_user = os.environ.get("USER", os.environ.get("USERNAME", "unknown"))
+        ssh_test = subprocess.run(["ssh", "-o", "ConnectTimeout=5", "-o", "StrictHostKeyChecking=no", "-o", "BatchMode=yes", f"{local_user}@localhost", "echo", "test"], capture_output=True, text=True, check=False, timeout=10)
+        
+        if ssh_test.returncode == 0:
+            results["local_ssh_test"] = {"status": "ok", "message": "Local SSH connection successful", "action": ""}
+            console.print(Panel("✅ Local SSH connection works\n✅ SSH server is functional", title="[bold green]OK[/bold green]", border_style="green"))
+        else:
+            error_output = ssh_test.stderr
+            results["local_ssh_test"] = {"status": "warning", "message": f"Local SSH test failed: {error_output[:100]}", "action": "Check SSH keys and configuration"}
+            console.print(Panel(f"⚠️  Local SSH test failed\n💡 Error: {error_output[:200]}\n💡 This may be normal if key authentication is not set up for localhost", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
+    except subprocess.TimeoutExpired:
+        results["local_ssh_test"] = {"status": "error", "message": "Local SSH connection timed out", "action": "SSH may be hanging or not responding"}
+        issues_found.append("SSH connection timeout")
+        console.print(Panel("❌ Local SSH connection timed out\n💡 SSH server may not be responding\n💡 Check: sudo systemctl status ssh", title="[bold red]Critical Issue[/bold red]", border_style="red"))
+    except FileNotFoundError:
+        results["local_ssh_test"] = {"status": "warning", "message": "ssh client not found", "action": "Install SSH client"}
+        console.print(Panel("⚠️  SSH client not installed\n💡 Install: sudo apt install openssh-client", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
+    except Exception as test_error:
+        results["local_ssh_test"] = {"status": "warning", "message": f"Could not test SSH: {str(test_error)}", "action": ""}
+        console.print(Panel(f"⚠️  Could not test SSH connection: {str(test_error)}", title="[bold yellow]Warning[/bold yellow]", border_style="yellow"))
+    
     console.print(Panel("📊 DIAGNOSTIC SUMMARY", box=box.DOUBLE_EDGE, title_align="left"))
     
     if issues_found:
@@ -292,6 +351,39 @@ def ssh_debug_linux() -> dict[str, dict[str, str | bool]]:
     else:
         console.print(Panel("✅ No critical issues detected\n\nIf you still cannot connect:\n• Check client-side configuration\n• Verify network connectivity\n• Ensure correct username and hostname\n• Check if public key is correctly added to authorized_keys", title="[bold green]All Checks Passed[/bold green]", border_style="green"))
     
+    console.print(Panel("🔗 CONNECTION INFORMATION", box=box.DOUBLE_EDGE, title_align="left"))
+    
+    try:
+        current_user = os.environ.get("USER", os.environ.get("USERNAME", "unknown"))
+        hostname_result = subprocess.run(["hostname"], capture_output=True, text=True, check=False)
+        hostname = hostname_result.stdout.strip() if hostname_result.returncode == 0 else "unknown"
+        
+        ip_addr_result = subprocess.run(["ip", "addr", "show"], capture_output=True, text=True, check=False)
+        connection_ips: list[str] = []
+        if ip_addr_result.returncode == 0:
+            import re
+            inet_pattern = re.compile(r'inet\s+(\d+\.\d+\.\d+\.\d+)/\d+.*scope\s+global')
+            connection_ips = inet_pattern.findall(ip_addr_result.stdout)
+        
+        connection_info = f"👤 Username: {current_user}\n🖥️  Hostname: {hostname}\n🔌 SSH Port: {ssh_port}\n"
+        
+        if connection_ips:
+            connection_info += "\n🌐 This machine can be accessed via SSH from other machines on the same network using:\n\n"
+            for ip in connection_ips:
+                connection_info += f"   ssh {current_user}@{ip}\n"
+            if ssh_port != "22":
+                connection_info += f"\n   (Port {ssh_port} should be used: ssh -p {ssh_port} {current_user}@<IP>)\n"
+        else:
+            connection_info += "\n⚠️  No network IP addresses found - this machine may not be reachable from the network"
+        
+        connection_info += "\n\n💡 From another machine on the same network, use one of the commands above"
+        connection_info += "\n💡 Ensure your public key is in ~/.ssh/authorized_keys on this machine"
+        connection_info += "\n💡 Or use password authentication if enabled in sshd_config"
+        
+        console.print(Panel(connection_info, title="[bold cyan]SSH Connection Details[/bold cyan]", border_style="cyan"))
+    except Exception as conn_error:
+        console.print(Panel(f"⚠️  Could not gather connection information: {str(conn_error)}", title="[bold yellow]Connection Info[/bold yellow]", border_style="yellow"))
+    
     return results
 
 

{machineconfig-5.81 → machineconfig-5.83}/src/machineconfig/utils/ssh.py

@@ -1,4 +1,4 @@
-from typing import Optional, Any, Union
+from typing import Callable, Optional, Any, Union
 import os
 from pathlib import Path
 import rich.console
@@ -6,7 +6,7 @@ from machineconfig.utils.terminal import Response, MACHINE
 from machineconfig.utils.accessories import pprint
 
 UV_RUN_CMD = "$HOME/.local/bin/uv run"
-MACHINECONFIG_VERSION = """ "machineconfig>=5.74" """
+MACHINECONFIG_VERSION = "machineconfig>=5.74"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"
 
 
@@ -186,15 +186,32 @@ class SSH:
             res.capture().print_if_unsuccessful(desc=description, strict_err=strict_stderr, strict_returncode=strict_return_code, assert_success=False)
         self.terminal_responses.append(res)
         return res
-    def run_py(self, python_code: str, description: str, verbose_output: bool, strict_stderr: bool, strict_return_code: bool) -> Response:
+    def run_py(self, python_code: str, dependencies: list[str], venv_path: Optional[str],
+               description: str, verbose_output: bool, strict_stderr: bool, strict_return_code: bool) -> Response:
         from machineconfig.utils.accessories import randstr
         cmd_path = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/runpy_{randstr()}.py")
         cmd_path.parent.mkdir(parents=True, exist_ok=True)
         cmd_path.write_text(python_code, encoding="utf-8")
         self.copy_from_here(source_path=cmd_path, target_path=None, compress_with_zip=False, recursive=False, overwrite_existing=False)
-        uv_cmd = f"""{UV_RUN_CMD} --with {MACHINECONFIG_VERSION} python {cmd_path.relative_to(Path.home())}"""
+        if len(dependencies) > 0:
+            with_clause = " --with " + '"', ",".join(dependencies) + '"'
+        else:
+            with_clause = ""
+        uv_cmd = f"""{UV_RUN_CMD} {with_clause} python {cmd_path.relative_to(Path.home())}"""
+        if venv_path is not None:
+            if self.get_remote_machine() == "Windows":
+                venv_export = f"$env:UV_PROJECT_ENVIRONMENT='{venv_path}';"
+                uv_cmd = venv_export + uv_cmd
+            else:
+                venv_export = f"UV_PROJECT_ENVIRONMENT={venv_path}"
+                uv_cmd = venv_export + " " + uv_cmd
         return self.run_shell(command=uv_cmd, verbose_output=verbose_output, description=description or f"run_py on {self.get_remote_repr(add_machine=False)}", strict_stderr=strict_stderr, strict_return_code=strict_return_code)
 
+    def run_py_func(self, func: Callable[..., Any], dependencies: list[str], venv_path: Optional[str]) -> Response:
+        from machineconfig.utils.meta import function_to_script
+        command = function_to_script(func=func, call_with_kwargs={})
+        return self.run_py(python_code=command, dependencies=dependencies, venv_path=venv_path, description=f"run_py_func {func.__name__} on {self.get_remote_repr(add_machine=False)}", verbose_output=True, strict_stderr=True, strict_return_code=True)
+
     def _simple_sftp_get(self, remote_path: str, local_path: Path) -> None:
         """Simple SFTP get without any recursion or path expansion - for internal use only."""
         if self.sftp is None:
@@ -225,7 +242,7 @@ class SSH:
         from machineconfig.utils.accessories import randstr
         remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
         command = function_to_script(func=create_target_dir, call_with_kwargs={"target_dir_path": Path(target_path).as_posix(), "overwrite": overwrite_existing, "json_output_path": remote_json_output})
-        response = self.run_py(python_code=command, description=f"Creating target directory `{Path(target_path).parent.as_posix()}` @ {self.get_remote_repr(add_machine=False)}", verbose_output=False, strict_stderr=False, strict_return_code=False)
+        response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description=f"Creating target directory `{Path(target_path).parent.as_posix()}` @ {self.get_remote_repr(add_machine=False)}", verbose_output=False, strict_stderr=False, strict_return_code=False)
         remote_json_path = response.op.strip()
         if not remote_json_path:
             raise RuntimeError(f"Failed to create target directory {target_path} - no response from remote")
@@ -308,7 +325,7 @@ class SSH:
                 archive_path.unlink()
             from machineconfig.utils.meta import function_to_script
             command = function_to_script(func=unzip_archive, call_with_kwargs={"zip_file_path": remotepath.as_posix(), "overwrite_flag": overwrite_existing})
-            _resp = self.run_py(python_code=command, description=f"UNZIPPING {remotepath.as_posix()}", verbose_output=False, strict_stderr=True, strict_return_code=True)
+            _resp = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description=f"UNZIPPING {remotepath.as_posix()}", verbose_output=False, strict_stderr=True, strict_return_code=True)
             source_obj.unlink()
             print("\n")        
         return source_obj
@@ -329,7 +346,7 @@ class SSH:
         from machineconfig.utils.accessories import randstr
         remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
         command = function_to_script(func=check_is_dir, call_with_kwargs={"path_to_check": str(source_path), "json_output_path": remote_json_output})
-        response = self.run_py(python_code=command, description=f"Check if source `{source_path}` is a dir", verbose_output=False, strict_stderr=False, strict_return_code=False)
+        response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description=f"Check if source `{source_path}` is a dir", verbose_output=False, strict_stderr=False, strict_return_code=False)
         remote_json_path = response.op.strip()
         if not remote_json_path:
             raise RuntimeError(f"Failed to check if {source_path} is directory - no response from remote")
@@ -363,7 +380,7 @@ class SSH:
         from machineconfig.utils.accessories import randstr
         remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
         command = function_to_script(func=expand_source, call_with_kwargs={"path_to_expand": str(source_path), "json_output_path": remote_json_output})
-        response = self.run_py(python_code=command, description="Resolving source path by expanding user", verbose_output=False, strict_stderr=False, strict_return_code=False)
+        response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Resolving source path by expanding user", verbose_output=False, strict_stderr=False, strict_return_code=False)
         remote_json_path = response.op.strip()
         if not remote_json_path:
             raise RuntimeError(f"Could not resolve source path {source_path} - no response from remote")
@@ -412,7 +429,7 @@ class SSH:
                 from machineconfig.utils.accessories import randstr
                 remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
                 command = function_to_script(func=search_files, call_with_kwargs={"directory_path": expanded_source, "json_output_path": remote_json_output})
-                response = self.run_py(python_code=command, description="Searching for files in source", verbose_output=False, strict_stderr=False, strict_return_code=False)
+                response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Searching for files in source", verbose_output=False, strict_stderr=False, strict_return_code=False)
                 remote_json_path = response.op.strip()
                 if not remote_json_path:
                     raise RuntimeError(f"Could not resolve source path {source} - no response from remote")
@@ -450,7 +467,7 @@ class SSH:
                     from machineconfig.utils.accessories import randstr
                     remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
                     command = function_to_script(func=collapse_to_home_dir, call_with_kwargs={"absolute_path": expanded_source, "json_output_path": remote_json_output})
-                    response = self.run_py(python_code=command, description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
+                    response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
                     remote_json_path_dir = response.op.strip()
                     if not remote_json_path_dir:
                         raise RuntimeError("Could not resolve target path - no response from remote")
@@ -502,7 +519,7 @@ class SSH:
             from machineconfig.utils.accessories import randstr
             remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
             command = function_to_script(func=zip_source, call_with_kwargs={"path_to_zip": expanded_source, "json_output_path": remote_json_output})
-            response = self.run_py(python_code=command, description=f"Zipping source file {source}", verbose_output=False, strict_stderr=False, strict_return_code=False)
+            response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description=f"Zipping source file {source}", verbose_output=False, strict_stderr=False, strict_return_code=False)
             remote_json_path = response.op.strip()
             if not remote_json_path:
                 raise RuntimeError(f"Could not zip {source} - no response from remote")
@@ -541,7 +558,7 @@ class SSH:
             from machineconfig.utils.accessories import randstr
             remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
             command = function_to_script(func=collapse_to_home, call_with_kwargs={"absolute_path": expanded_source, "json_output_path": remote_json_output})
-            response = self.run_py(python_code=command, description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
+            response = self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
             remote_json_path = response.op.strip()
             if not remote_json_path:
                 raise RuntimeError("Could not resolve target path - no response from remote")
@@ -597,7 +614,7 @@ class SSH:
             
             from machineconfig.utils.meta import function_to_script
             command = function_to_script(func=delete_temp_zip, call_with_kwargs={"path_to_delete": expanded_source})
-            self.run_py(python_code=command, description="Cleaning temp zip files @ remote.", verbose_output=False, strict_stderr=True, strict_return_code=True)
+            self.run_py(python_code=command, dependencies=[MACHINECONFIG_VERSION], venv_path=None, description="Cleaning temp zip files @ remote.", verbose_output=False, strict_stderr=True, strict_return_code=True)
         
         print("\n")
         return target_obj

machineconfig-5.83/src/machineconfig/utils/tst.py

@@ -0,0 +1,20 @@
+from typing import Callable, ParamSpec, TypeVar, Any, Dict
+
+P = ParamSpec('P')
+R = TypeVar('R')
+
+def typed_function(func: Callable[P, R], signature_dict: Dict[str, Any]) -> Callable[P, R]:
+    """
+    Returns the function with its signature preserved using ParamSpec.
+
+    The signature_dict is passed for potential future use or documentation,
+    but is not currently used in the implementation.
+
+    Args:
+        func: The function whose signature is to be preserved.
+        signature_dict: A dictionary describing the function's signature (not used).
+
+    Returns:
+        The original function, typed with ParamSpec to preserve its signature.
+    """
+    return func

{machineconfig-5.81 → machineconfig-5.83/src/machineconfig.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 5.81
+Version: 5.83
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{machineconfig-5.81 → machineconfig-5.83}/src/machineconfig.egg-info/SOURCES.txt

@@ -407,6 +407,7 @@ src/machineconfig/utils/scheduling.py
 src/machineconfig/utils/source_of_truth.py
 src/machineconfig/utils/ssh.py
 src/machineconfig/utils/terminal.py
+src/machineconfig/utils/tst.py
 src/machineconfig/utils/upgrade_packages.py
 src/machineconfig/utils/ve.py
 src/machineconfig/utils/ai/__init__.py