machineconfig 5.15__py3-none-any.whl → 7.66__py3-none-any.whl

machineconfig/utils/path_helper.py

@@ -1,18 +1,16 @@
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.options import choose_from_options
 from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
 from rich.console import Console
 from rich.panel import Panel
 import platform
 import subprocess
 from pathlib import Path
-
+from typing import Optional
 
 console = Console()
 
 
-def sanitize_path(a_path: str) -> PathExtended:
-    path = PathExtended(a_path)
+def sanitize_path(a_path: str) -> Path:
+    path = Path(a_path)
     if Path.cwd() == Path.home() and not path.exists():
         result = input("Current working directory is home, and passed path is not full path, are you sure you want to continue, [y]/n? ") or "y"
         if result == "y":
@@ -23,13 +21,13 @@ def sanitize_path(a_path: str) -> PathExtended:
         if platform.system() == "Windows":  # path copied from Linux/Mac to Windows
             # For Linux: /home/username, for Mac: /Users/username
             skip_parts = 3 if path.as_posix().startswith("/home") else 3  # Both have 3 parts to skip
-            path = PathExtended.home().joinpath(*path.parts[skip_parts:])
+            path = Path.home().joinpath(*path.parts[skip_parts:])
             assert path.exists(), f"File not found: {path}"
             source_os = "Linux" if path.as_posix().startswith("/home") else "macOS"
             console.print(Panel(f"🔗 PATH MAPPING | {source_os} → Windows: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
-        elif platform.system() in ["Linux", "Darwin"] and PathExtended.home().as_posix() not in path.as_posix():  # copied between Unix-like systems with different username
+        elif platform.system() in ["Linux", "Darwin"] and Path.home().as_posix() not in path.as_posix():  # copied between Unix-like systems with different username
             skip_parts = 3  # Both /home/username and /Users/username have 3 parts to skip
-            path = PathExtended.home().joinpath(*path.parts[skip_parts:])
+            path = Path.home().joinpath(*path.parts[skip_parts:])
             assert path.exists(), f"File not found: {path}"
             current_os = "Linux" if platform.system() == "Linux" else "macOS"
             source_os = "Linux" if path.as_posix().startswith("/home") else "macOS"
@@ -37,12 +35,12 @@ def sanitize_path(a_path: str) -> PathExtended:
     elif path.as_posix().startswith("C:"):
         if platform.system() in ["Linux", "Darwin"]:  # path copied from Windows to Linux/Mac
             xx = str(a_path).replace("\\\\", "/")
-            path = PathExtended.home().joinpath(*PathExtended(xx).parts[3:])  # exclude C:\\Users\\username
+            path = Path.home().joinpath(*Path(xx).parts[3:])  # exclude C:\\Users\\username
             assert path.exists(), f"File not found: {path}"
             target_os = "Linux" if platform.system() == "Linux" else "macOS"
             console.print(Panel(f"🔗 PATH MAPPING | Windows → {target_os}: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
-        elif platform.system() == "Windows" and PathExtended.home().as_posix() not in path.as_posix():  # copied from Windows to Windows with different username
-            path = PathExtended.home().joinpath(*path.parts[2:])
+        elif platform.system() == "Windows" and Path.home().as_posix() not in path.as_posix():  # copied from Windows to Windows with different username
+            path = Path.home().joinpath(*path.parts[2:])
             assert path.exists(), f"File not found: {path}"
             console.print(Panel(f"🔗 PATH MAPPING | Windows → Windows: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
     return path.expanduser().absolute()
@@ -67,49 +65,58 @@ def find_scripts(root: Path, name_substring: str, suffixes: set[str]) -> tuple[l
     return filename_matches, partial_path_matches
 
 
-def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[str]) -> PathExtended:
+def match_file_name(sub_string: str, search_root: Path, suffixes: set[str]) -> Path:
     search_root_obj = search_root.absolute()
     # assume subscript is filename only, not a sub_path. There is no need to fzf over the paths.
     filename_matches, partial_path_matches = find_scripts(search_root_obj, sub_string, suffixes)
     if len(filename_matches) == 1:
-        return PathExtended(filename_matches[0])
+        return Path(filename_matches[0])
     console.print(Panel(f"Partial filename {search_root_obj} match with case-insensitivity failed. This generated #{len(filename_matches)} results.", title="Search", expand=False))
     if len(filename_matches) < 20:
         print("\n".join([a_potential_match.as_posix() for a_potential_match in filename_matches]))
     if len(filename_matches) > 1:
-        print("Try to narrow down filename_matches search by case-sensitivity.")
+        print(f"Try to narrow down filename_matches search by case-sensitivity, found {len(filename_matches)} results. First @ {filename_matches[0].as_posix()}")
         # let's see if avoiding .lower() helps narrowing down to one result
         reduced_scripts = [a_potential_match for a_potential_match in filename_matches if sub_string in a_potential_match.name]
         if len(reduced_scripts) == 1:
-            return PathExtended(reduced_scripts[0])
+            return Path(reduced_scripts[0])
         elif len(reduced_scripts) > 1:
+            from machineconfig.utils.options import choose_from_options
             choice = choose_from_options(multi=False, msg="Multiple matches found", options=reduced_scripts, fzf=True)
-            return PathExtended(choice)
+            return Path(choice)
         print(f"Result: This still generated {len(reduced_scripts)} results.")
         if len(reduced_scripts) < 10:
             print("\n".join([a_potential_match.as_posix() for a_potential_match in reduced_scripts]))
 
     console.print(Panel(f"Partial path match with case-insensitivity failed. This generated #{len(partial_path_matches)} results.", title="Search", expand=False))
     if len(partial_path_matches) == 1:
-        return PathExtended(partial_path_matches[0])
+        return Path(partial_path_matches[0])
     elif len(partial_path_matches) > 1:
         print("Try to narrow down partial_path_matches search by case-sensitivity.")
         reduced_scripts = [a_potential_match for a_potential_match in partial_path_matches if sub_string in a_potential_match.as_posix()]
         if len(reduced_scripts) == 1:
-            return PathExtended(reduced_scripts[0])
-        print(f"Result: This still generated {len(reduced_scripts)} results.")
+            return Path(reduced_scripts[0])
+        print(f"Result: This still generated {len(reduced_scripts)} results.")        
+
     try:
-        fzf_cmd = f"cd '{search_root_obj}'; fd --type file --strip-cwd-prefix | fzf --ignore-case --exact --query={sub_string}"
+
+        if len(partial_path_matches) == 0:
+            print("No partial path matches found, trying to do fd with --no-ignore ...")
+            fzf_cmd = f"cd '{search_root_obj}'; fd --no-ignore --type file --strip-cwd-prefix | fzf --ignore-case --exact --query={sub_string}"
+        else:
+            fzf_cmd = f"cd '{search_root_obj}'; fd --type file --strip-cwd-prefix | fzf --ignore-case --exact --query={sub_string}"
         console.print(Panel(f"🔍 Second attempt: SEARCH STRATEGY | Using fd to search for '{sub_string}' in '{search_root_obj}' ...\n{fzf_cmd}", title="Search Strategy", expand=False))
         search_res_raw = subprocess.run(fzf_cmd, stdout=subprocess.PIPE, text=True, check=True, shell=True).stdout
-        search_res = search_res_raw.strip().split("\\n")[:-1]
+        search_res = search_res_raw.strip().split("\n")
     except subprocess.CalledProcessError as cpe:
         console.print(Panel(f"❌ ERROR | FZF search failed with '{sub_string}' in '{search_root_obj}'.\n{cpe}", title="Error", expand=False))
         import sys
-
         sys.exit(f"💥 FILE NOT FOUND | Path {sub_string} does not exist @ root {search_root_obj}. No search results.")
     if len(search_res) == 1:
         return search_root_obj.joinpath(search_res_raw)
+    elif len(search_res) == 0:
+        msg = Panel(f"💥 FILE NOT FOUND | Path {sub_string} does not exist @ root {search_root_obj}. No search results", title="File Not Found", expand=False)
+        raise FileNotFoundError(msg)
 
     print(f"⚠️ WARNING | Multiple search results found for `{sub_string}`:\n'{search_res}'")
     cmd = f"cd '{search_root_obj}'; fd --type file | fzf --select-1 --query={sub_string}"
@@ -121,3 +128,49 @@ def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[st
         msg = Panel(f"💥 FILE NOT FOUND | Path {sub_string} does not exist @ root {search_root_obj}. No search results", title="File Not Found", expand=False)
         raise FileNotFoundError(msg) from cpe
     return search_root_obj.joinpath(res)
+
+
+def search_for_files_of_interest(path_obj: Path, suffixes: set[str]) -> list[Path]:
+    if path_obj.is_file():
+        return [path_obj]
+    files: list[Path] = []
+    directories_to_visit: list[Path] = [path_obj]
+    while directories_to_visit:
+        current_dir = directories_to_visit.pop()
+        for entry in current_dir.iterdir():
+            if entry.is_dir():
+                if entry.name == ".venv":
+                    continue
+                directories_to_visit.append(entry)
+                continue
+            if entry.suffix not in suffixes:
+                continue
+            if entry.suffix == ".py" and entry.name == "__init__.py":
+                continue
+            files.append(entry)
+    return files
+
+
+def get_choice_file(path: str, suffixes: Optional[set[str]]):
+    path_obj = sanitize_path(path)
+    if suffixes is None:
+        import platform
+        if platform.system() == "Windows":
+            suffixes = {".py", ".ps1", ".sh"}
+        elif platform.system() in ["Linux", "Darwin"]:
+            suffixes = {".py", ".sh"}
+        else:
+            suffixes = {".py"}
+    if not path_obj.exists():
+        print(f"🔍 Searching for file matching `{path}` under `{Path.cwd()}`, but only if suffix matches {suffixes}")
+        choice_file = match_file_name(sub_string=path, search_root=Path.cwd(), suffixes=suffixes)
+    elif path_obj.is_dir():
+        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
+        files = search_for_files_of_interest(path_obj, suffixes=suffixes)
+        print(f"🔍 Got #{len(files)} results.")
+        from machineconfig.utils.options import choose_from_options
+        choice_file = choose_from_options(multi=False, options=files, fzf=True, msg="Choose one option")
+        choice_file = Path(choice_file)
+    else:
+        choice_file = path_obj
+    return choice_file

machineconfig/utils/procs.py

@@ -2,12 +2,11 @@
 
 import psutil
 from rich.progress import Progress, SpinnerColumn, TextColumn
-from zoneinfo import ZoneInfo
 from machineconfig.utils.options import choose_from_options
-from typing import Optional, Any
+from typing import Optional, TypedDict, List, Dict
 from rich.console import Console
 from rich.panel import Panel
-from datetime import datetime, timezone
+from datetime import datetime
 from machineconfig.utils.accessories import pprint
 
 console = Console()
@@ -15,11 +14,29 @@ console = Console()
 BOX_WIDTH = 78  # width for box drawing
 
 
-def get_processes_accessing_file(path: str):
+class ProcessInfo(TypedDict):
+    """TypedDict for process information."""
+    command: str
+    pid: int
+    name: str
+    username: str
+    cpu_percent: float
+    memory_usage_mb: float
+    status: str
+    create_time: datetime
+
+
+class FileAccessInfo(TypedDict):
+    """TypedDict for file access information."""
+    pid: int
+    files: List[str]
+
+
+def get_processes_accessing_file(path: str) -> List[FileAccessInfo]:
     # header for searching processes
     title = "🔍  SEARCHING FOR PROCESSES ACCESSING FILE"
     console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
-    res: dict[int, list[str]] = {}
+    res: Dict[int, List[str]] = {}
 
     with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
         progress.add_task("🔎 Scanning processes...", total=None)
@@ -34,22 +51,22 @@ def get_processes_accessing_file(path: str):
                 res[proc.pid] = tmp
 
     # Convert to list of dictionaries for consistent data structure
-    result_data = [{"pid": pid, "files": files} for pid, files in res.items()]
+    result_data: List[FileAccessInfo] = [{"pid": pid, "files": files} for pid, files in res.items()]
     console.print(Panel(f"✅ Found {len(res)} processes accessing the specified file", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
     return result_data
 
 
 def kill_process(name: str):
-    print(f"⚠️  Attempting to kill process: {name}...")
+    console.print(f"⚠️  Attempting to kill process: {name}...", style="yellow")
     killed = False
     for proc in psutil.process_iter():
         if proc.name() == name:
             proc.kill()
-            print(f"💀 Process {name} (PID: {proc.pid}) terminated successfully")
+            console.print(f"💀 Process {name} (PID: {proc.pid}) terminated successfully", style="green")
             killed = True
     if not killed:
-        print(f"❓ No process with name '{name}' was found")
-    print(f"{'─' * 80}\n")
+        console.print(f"❓ No process with name '{name}' was found", style="red")
+    console.rule(style="dim")
 
 
 class ProcessManager:
@@ -57,15 +74,13 @@ class ProcessManager:
         # header for initializing process manager
         title = "📊  INITIALIZING PROCESS MANAGER"
         console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
-        process_info = []
+        process_info: List[ProcessInfo] = []
         with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
             progress.add_task("🔍 Reading system processes...", total=None)
             for proc in psutil.process_iter():
                 try:
                     mem_usage_mb = proc.memory_info().rss / (1024 * 1024)
-                    # Convert create_time to local timezone
-                    create_time_utc = datetime.fromtimestamp(proc.create_time(), tz=timezone.utc)
-                    create_time_local = create_time_utc.astimezone(ZoneInfo("Australia/Adelaide"))
+                    create_time = datetime.fromtimestamp(proc.create_time(), tz=None)
 
                     process_info.append(
                         {
@@ -75,7 +90,7 @@ class ProcessManager:
                             "cpu_percent": proc.cpu_percent(),
                             "memory_usage_mb": mem_usage_mb,
                             "status": proc.status(),
-                            "create_time": create_time_local,
+                            "create_time": create_time,
                             "command": " ".join(proc.cmdline()),
                         }
                     )
@@ -91,57 +106,51 @@ class ProcessManager:
         """Format process data as table string for display."""
         if not self.data:
             return ""
-
         # Create header
-        _headers = ["PID", "Name", "Username", "CPU%", "Memory(MB)", "Status", "Create Time", "Command"]
-        header_line = f"{'PID':<8} {'Name':<20} {'Username':<12} {'CPU%':<8} {'Memory(MB)':<12} {'Status':<12} {'Create Time':<20} {'Command':<50}"
+        _headers = ["Command", "PID", "Name", "Username", "CPU%", "Memory(MB)", "Status", "Create Time"]
+        header_line = f"{'Command':<50} {'PID':<8} {'Name':<20} {'Username':<12} {'CPU%':<8} {'Memory(MB)':<12} {'Status':<12} {'Create Time':<20}"
         separator = "-" * len(header_line)
-
         lines = [header_line, separator]
-
         for process in self.data:
             # Format create_time as string
             create_time_str = process["create_time"].strftime("%Y-%m-%d %H:%M:%S")
             # Truncate command if too long
             command = process["command"][:47] + "..." if len(process["command"]) > 50 else process["command"]
-
-            line = f"{process['pid']:<8} {process['name'][:19]:<20} {process['username'][:11]:<12} {process['cpu_percent']:<8.1f} {process['memory_usage_mb']:<12.2f} {process['status'][:11]:<12} {create_time_str:<20} {command:<50}"
+            line = f"{command:<50} {process['pid']:<8} {process['name'][:19]:<20} {process['username'][:11]:<12} {process['cpu_percent']:<8.1f} {process['memory_usage_mb']:<12.2f} {process['status'][:11]:<12} {create_time_str:<20}"
             lines.append(line)
-
         return "\n".join(lines)
 
     def choose_and_kill(self):
         # header for interactive process selection
         title = "🎯  INTERACTIVE PROCESS SELECTION AND TERMINATION"
         console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
-
         # Format data as table for display
         formatted_data = self._format_process_table()
-        options = formatted_data.split("\n")[1:]  # Skip header
-        res = choose_from_options(options=formatted_data.split("\n"), msg="📋 Select processes to manage:", fzf=True, multi=True)
-        indices = [options.index(val) for val in res]
+        all_lines = formatted_data.split("\n")
+        header_and_separator = all_lines[:2]  # First two lines: header and separator
+        options = all_lines[2:]  # Skip header and separator, only process lines
+        res = choose_from_options(options=all_lines, msg="📋 Select processes to manage:", fzf=True, multi=True)
+        # Filter out header and separator if they were selected
+        selected_lines = [line for line in res if line not in header_and_separator]
+        indices = [options.index(val) for val in selected_lines]
         selected_processes = [self.data[i] for i in indices]
-
         print("\n📊 All Processes:")
         print(formatted_data)
         print("\n🎯 Selected Processes:")
         for process in selected_processes:
             print(f"PID: {process['pid']}, Name: {process['name']}, Memory: {process['memory_usage_mb']:.2f}MB")
-
         for idx, process in enumerate(selected_processes):
-            pprint(process, f"📌 Process {idx}")
-
+            pprint(dict(process), f"📌 Process {idx}")
         kill_all = input("\n⚠️  Confirm killing ALL selected processes? y/[n] ").lower() == "y"
         if kill_all:
             self.kill(pids=[p["pid"] for p in selected_processes])
             return
-
         kill_by_index = input("\n🔫 Kill by index? (enter numbers separated by spaces, e.g. '1 4') or [n] to cancel: ")
         if kill_by_index != "" and kill_by_index != "n":
             indices = [int(val) for val in kill_by_index.split(" ")]
             target_processes = [selected_processes[i] for i in indices]
             for idx2, process in enumerate(target_processes):
-                pprint(process, f"🎯 Target Process {idx2}")
+                pprint(dict(process), f"🎯 Target Process {idx2}")
             _ = self.kill(pids=[p["pid"] for p in target_processes]) if input("\n⚠️  Confirm termination? y/[n] ").lower() == "y" else None
         console.print(Panel("🔔 No processes were terminated.", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
 
@@ -149,12 +158,10 @@ class ProcessManager:
         # header for filtering processes by name
         title = "🔍  FILTERING AND TERMINATING PROCESSES BY NAME"
         console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
-
         # Filter processes by name
         filtered_processes = [p for p in self.data if p["name"] == name]
         # Sort by create_time (ascending)
         filtered_processes.sort(key=lambda x: x["create_time"])
-
         print(f"🎯 Found {len(filtered_processes)} processes matching name: '{name}'")
         self.kill(pids=[p["pid"] for p in filtered_processes])
         console.print(Panel("", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
@@ -171,69 +178,42 @@ class ProcessManager:
             pids = []
         if commands is None:
             commands = []
-
         killed_count = 0
-
         for name in names:
             matching_processes = [p for p in self.data if p["name"] == name]
             if len(matching_processes) > 0:
                 for process in matching_processes:
                     psutil.Process(process["pid"]).kill()
-                    print(f"💀 Killed process {name} with PID {process['pid']}. It lived {get_age(process['create_time'])}. RIP 🪦💐")
+                    print(f"💀 Killed process {name} with PID {process['pid']}. It lived {get_age(process['create_time'])}. RIP 💐")
                     killed_count += 1
             else:
                 print(f'❓ No process named "{name}" found')
-
         for pid in pids:
             try:
                 proc = psutil.Process(pid)
                 proc_name = proc.name()
-                proc_lifetime = get_age(proc.create_time())
+                proc_lifetime = get_age(datetime.fromtimestamp(proc.create_time(), tz=None))
                 proc.kill()
-                print(f'💀 Killed process with PID {pid} and name "{proc_name}". It lived {proc_lifetime}. RIP 🪦💐')
+                print(f'💀 Killed process with PID {pid} and name "{proc_name}". It lived {proc_lifetime}. RIP 💐')
                 killed_count += 1
             except psutil.NoSuchProcess:
                 print(f"❓ No process with PID {pid} found")
-
         for command in commands:
             matching_processes = [p for p in self.data if command in p["command"]]
             if len(matching_processes) > 0:
                 for process in matching_processes:
                     psutil.Process(process["pid"]).kill()
-                    print(f'💀 Killed process with "{command}" in its command & PID {process["pid"]}. It lived {get_age(process["create_time"])}. RIP 🪦💐')
+                    print(f'💀 Killed process with "{command}" in its command & PID {process["pid"]}. It lived {get_age(process["create_time"])}. RIP 💐')
                     killed_count += 1
             else:
                 print(f'❓ No process has "{command}" in its command.')
-
         console.print(Panel(f"✅ Termination complete: {killed_count} processes terminated", title="[bold blue]Process Info[/bold blue]", border_style="blue"))
 
 
-def get_age(create_time: Any) -> str:
-    """Calculate age from create_time which can be either float timestamp or datetime object."""
-    try:
-        if isinstance(create_time, (int, float)):
-            # Handle timestampz
-            create_time_utc = datetime.fromtimestamp(create_time, tz=timezone.utc)
-            create_time_local = create_time_utc.astimezone(ZoneInfo("Australia/Adelaide"))
-        else:
-            # Already a datetime object
-            create_time_local = create_time
-
-        now_local = datetime.now(tz=ZoneInfo("Australia/Adelaide"))
-        age = now_local - create_time_local
-        return str(age)
-    except Exception as e:
-        try:
-            # Fallback without timezone
-            if isinstance(create_time, (int, float)):
-                create_time_dt = datetime.fromtimestamp(create_time)
-            else:
-                create_time_dt = create_time.replace(tzinfo=None) if create_time.tzinfo else create_time
-            now_dt = datetime.now()
-            age = now_dt - create_time_dt
-            return str(age)
-        except Exception as ee:
-            return f"unknown due to {ee} and {e}"
+def get_age(create_time: datetime) -> str:
+    dtm_now = datetime.now()
+    delta = dtm_now - create_time
+    return str(delta).split(".")[0]  # remove microseconds
 
 
 def main():