machineconfig 3.7__py3-none-any.whl → 7.69__py3-none-any.whl

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,17 +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(
                         {
@@ -77,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()),
                         }
                     )
@@ -93,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"))
 
@@ -151,18 +158,15 @@ 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"))
 
     def kill(self, names: Optional[list[str]] = None, pids: Optional[list[int]] = None, commands: Optional[list[str]] = None):
-        # header for process termination
         title = "💀  PROCESS TERMINATION"
         console.print(Panel(title, title="[bold blue]Process Info[/bold blue]", border_style="blue"))
         if names is None and pids is None and commands is None:
@@ -174,74 +178,46 @@ 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():
     from machineconfig.utils.procs import ProcessManager
-
     ProcessManager().choose_and_kill()
 
 

machineconfig/utils/scheduler.py

@@ -1,10 +1,10 @@
+
 from pathlib import Path
-from typing import Callable, Optional, Union, Any, NoReturn, TypeVar, Protocol, List, Generic
+from typing import Callable, Optional, Union, Any, Protocol, List, TypeVar
 import logging
 import time
 from datetime import datetime, timezone, timedelta
 from machineconfig.utils.io import from_pickle
-from machineconfig.utils.path_extended import PathExtended as PathExtended
 
 
 class LoggerTemplate(Protocol):
@@ -143,145 +143,142 @@ class Scheduler:
         raise ex
 
 
-T = TypeVar("T")
+# T = TypeVar("T")
 T2 = TypeVar("T2")
-
-
-class PrintFunc(Protocol):
-    def __call__(self, msg: str) -> Union[NoReturn, None]: ...
-
-
 def to_pickle(obj: Any, path: Path) -> None:
     import pickle
-
-    path.parent.mkdir(parents=True, exist_ok=True)
     path.write_bytes(pickle.dumps(obj))
 
 
-class Cache(Generic[T]):  # This class helps to accelrate access to latest data coming from expensive function. The class has two flavours, memory-based and disk-based variants."""
-    # source_func: Callable[[], T]
+class CacheMemory[T]():
+    def __init__(
+        self, source_func: Callable[[], T], expire: timedelta, logger: LoggerTemplate, name: Optional[str] = None
+    ) -> None:
+        self.cache: T
+        self.source_func = source_func
+        self.time_produced = datetime.now()
+        self.logger = logger
+        self.expire = expire
+        self.name = name if isinstance(name, str) else self.source_func.__name__
+    def __call__(self, fresh: bool, tolerance_seconds: float | int) -> T:
+        if fresh or not hasattr(self, "cache"):
+            why = "There was an explicit fresh order." if fresh else "Previous cache never existed."
+            t0 = time.time()
+            self.logger.warning(f"""
+🆕 ════════════════════ NEW {self.name} CACHE ════════════════════
+ℹ️ Reason: {why}""")
+            self.cache = self.source_func()
+            self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
+            self.time_produced = datetime.now()
+        else:
+            age = datetime.now() - self.time_produced
+            if (age > self.expire) or (fresh and (age.total_seconds() > tolerance_seconds)):
+                self.logger.warning(f"""
+🔄 ════════════════════ CACHE UPDATE ════════════════════
+⚠️  {self.name} cache: Updating cache from source func
+⏱️  Age = {age} > {self.expire}""")
+                t0 = time.time()
+                self.cache = self.source_func()
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
+                self.time_produced = datetime.now()
+            else:
+                self.logger.warning(f"""
+✅ ════════════════════ USING CACHE ════════════════════
+📦 {self.name} cache: Using cached values
+⏱️  Lag = {age}""")
+        return self.cache
+
+    @staticmethod
+    def as_decorator(expire: timedelta, logger: LoggerTemplate, name: Optional[str] = None):
+        def decorator(source_func: Callable[[], T2]) -> CacheMemory["T2"]:
+            res = CacheMemory(source_func=source_func, expire=expire, logger=logger, name=name)
+            return res
+        return decorator
+
+
+class Cache[T]():  # This class helps to accelrate access to latest data coming from expensive function. The class has two flavours, memory-based and disk-based variants."""
     def __init__(
-        self, source_func: Callable[[], T], expire: timedelta, logger: Optional[PrintFunc] = None, path: Optional[Path] = None, saver: Callable[[T, Path], Any] = to_pickle, reader: Callable[[Path], T] = from_pickle, name: Optional[str] = None
+        self, source_func: Callable[[], T], expire: timedelta, logger: LoggerTemplate, path: Path, saver: Callable[[T, Path], Any] = to_pickle, reader: Callable[[Path], T] = from_pickle, name: Optional[str] = None
     ) -> None:
         self.cache: T
         self.source_func = source_func  # function which when called returns a fresh object to be frozen.
-        self.path: Optional[PathExtended] = PathExtended(path) if path is not None else None  # if path is passed, it will function as disk-based flavour.
+        self.path: Path = path
+        _ = self.path.parent.mkdir(parents=True, exist_ok=True)
         self.time_produced = datetime.now()  # if path is None else
         self.save = saver
         self.reader = reader
         self.logger = logger
         self.expire = expire
-        self.name = name if isinstance(name, str) else str(self.source_func)
-        self.last_call_is_fresh = False
-
-    @property
-    def age(self):
-        """Throws AttributeError if called before cache is populated and path doesn't exists"""
-        if self.path is None:  # memory-based cache.
-            return datetime.now() - self.time_produced
-        return datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)
-
-    # def __setstate__(self, state: dict[str, Any]) -> None:
-    #     self.__dict__.update(state)
-    #     self.path = P.home() / self.path if self.path is not None else self.path
-    # def __getstate__(self) -> dict[str, Any]:
-    #     state = self.__dict__.copy()
-    #     state["path"] = self.path.rel2home() if self.path is not None else state["path"]
-    #     return state  # With this implementation, instances can be pickled and loaded up in different machine and still works.
-    def __call__(self, fresh: bool = False) -> T:
-        self.last_call_is_fresh = False
-        if fresh or not hasattr(self, "cache"):  # populate cache for the first time
-            if not fresh and self.path is not None and self.path.exists():
+        self.name = name if isinstance(name, str) else self.source_func.__name__
+    def __call__(self, fresh: bool, tolerance_seconds: float | int) -> T:
+        if not hasattr(self, "cache"):  # populate cache for the first time: we have two options, populate from disk or from source func.
+            if self.path.exists():  # prefer to read from disk over source func as a default source of cache.
                 age = datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)
+                if (age > self.expire) or (fresh and (age.total_seconds() > tolerance_seconds)):  # cache is old or if fresh flag is raised
+                    self.logger.warning(f"""
+🔄 ════════════════════ CACHE STALE ════════════════════
+📦 {self.name} cache: Populating fresh cache from source func
+⏱️  Lag = {age}""")
+                    t0 = time.time()
+                    self.cache = self.source_func()  # fresh data.
+                    self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
+                    self.time_produced = datetime.now()
+                    self.save(self.cache, self.path)
+                    return self.cache
+
                 msg1 = f"""
 📦 ════════════════════ CACHE OPERATION ════════════════════
 🔄 {self.name} cache: Reading cached values from `{self.path}`
-⏱️  Lag = {age}
-════════════════════════════════════════════════════════════
-"""
+⏱️  Lag = {age}"""
                 try:
                     self.cache = self.reader(self.path)
                 except Exception as ex:
-                    if self.logger:
-                        msg2 = f"""
+                    msg2 = f"""
 ❌ ════════════════════ CACHE ERROR ════════════════════
 ⚠️  {self.name} cache: Cache file is corrupted
-🔍 Error: {ex}
-════════════════════════════════════════════════════════
-"""
-                        self.logger(msg1 + msg2)
+🔍 Error: {ex}"""
+                    self.logger.warning(msg1 + msg2)
+                    t0 = time.time()
                     self.cache = self.source_func()
-                    self.last_call_is_fresh = True
+                    self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                     self.time_produced = datetime.now()
-                    # if self.path is not None:
-                    #     self.save(self.cache, self.path)
+                    self.save(self.cache, self.path)
                     return self.cache
-                return self(fresh=False)  # may be the cache is old ==> check that by passing it through the logic again.
-            else:
-                if self.logger:
-                    # Previous cache never existed or there was an explicit fresh order.
-                    why = "There was an explicit fresh order." if fresh else "Previous cache never existed or is corrupted."
-                    self.logger(f"""
+            else:  # disk cache does not exist, populate from source func.
+                why = "Previous cache never existed."
+                self.logger.warning(f"""
 🆕 ════════════════════ NEW CACHE ════════════════════
 🔄 {self.name} cache: Populating fresh cache from source func
-ℹ️  Reason: {why}
-════════════════════════════════════════════════════════
-""")
+ℹ️  Reason: {why}""")
+                t0 = time.time()
                 self.cache = self.source_func()  # fresh data.
-                self.last_call_is_fresh = True
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                 self.time_produced = datetime.now()
-                if self.path is not None:
-                    self.save(self.cache, self.path)
-        else:  # cache exists
-            try:
-                age = self.age
-            except AttributeError:  # path doesn't exist (may be deleted) ==> need to repopulate cache form source_func.
-                return self(fresh=True)
-            if age > self.expire:
-                if self.logger:
-                    self.logger(f"""
+                self.save(self.cache, self.path)
+        else:  # memory cache exists
+            age = datetime.now() - self.time_produced
+            if (age > self.expire) or (fresh and (age.total_seconds() > tolerance_seconds)):  # cache is old or if fresh flag is raised
+                self.logger.warning(f"""
 🔄 ════════════════════ CACHE UPDATE ════════════════════
 ⚠️  {self.name} cache: Updating cache from source func
-⏱️  Age = {age} > {self.expire}
-════════════════════════════════════════════════════════""")
+⏱️  Age = {age} > {self.expire}""")
+                t0 = time.time()
                 self.cache = self.source_func()
-                self.last_call_is_fresh = True
+                self.logger.warning(f"⏱️  Cache population took {time.time() - t0:.2f} seconds.")
                 self.time_produced = datetime.now()
-                if self.path is not None:
-                    self.save(self.cache, self.path)
+                self.save(self.cache, self.path)
             else:
-                if self.logger:
-                    self.logger(f"""
+                self.logger.warning(f"""
 ✅ ════════════════════ USING CACHE ════════════════════
 📦 {self.name} cache: Using cached values
-⏱️  Lag = {age}
-════════════════════════════════════════════════════════""")
+⏱️  Lag = {age}""")
         return self.cache
 
     @staticmethod
     def as_decorator(
-        expire: timedelta, logger: Optional[PrintFunc] = None, path: Optional[Path] = None, saver: Callable[[T2, Path], Any] = to_pickle, reader: Callable[[Path], T2] = from_pickle, name: Optional[str] = None
+        expire: timedelta, logger: LoggerTemplate, path: Path, saver: Callable[[T2, Path], Any] = to_pickle, reader: Callable[[Path], T2] = from_pickle, name: Optional[str] = None
     ):  # -> Callable[..., 'Cache[T2]']:
         def decorator(source_func: Callable[[], T2]) -> Cache["T2"]:
             res = Cache(source_func=source_func, expire=expire, logger=logger, path=path, name=name, reader=reader, saver=saver)
             return res
-
         return decorator
-
-    def from_cloud(self, cloud: str, rel2home: bool = True, root: Optional[str] = None):
-        assert self.path is not None
-        exists = self.path.exists()
-        exists_but_old = exists and ((datetime.now() - datetime.fromtimestamp(self.path.stat().st_mtime)) > self.expire)
-        if not exists or exists_but_old:
-            returned_path = self.path.from_cloud(cloud=cloud, rel2home=rel2home, root=root)
-            if returned_path is None and not exists:
-                raise FileNotFoundError(f"❌ Failed to get @ {self.path}. Build the cache first with signed API.")
-            elif returned_path is None and exists and self.logger is not None:
-                self.logger(f"""
-⚠️ ════════════════════ CLOUD FETCH WARNING ════════════════════
-🔄 Failed to get fresh data from cloud
-📦 Using old cache @ {self.path}
-════════════════════════════════════════════════════════════════""")
-        else:
-            pass  # maybe we don't need to fetch it from cloud, if its too hot
-        return self.reader(self.path)

machineconfig/utils/scheduling.py

@@ -1,7 +1,6 @@
 # """Task scheduler
 # """
 
-# from machineconfig.utils.utils import get_shell_script_executing_python_file
 # from machineconfig.utils.utils2 import read_ini
 # from dataclasses import dataclass
 # from datetime import datetime, timedelta
@@ -140,8 +139,6 @@
 #     start: datetime
 #     end: datetime
 #     status: str
-
-#     @classmethod
 #     def from_path(cls, path: PathExtended, return_default_if_not_found: bool=False):
 #         if not path.exists():
 #             if return_default_if_not_found:

machineconfig/utils/schemas/fire_agents/fire_agents_input.py

@@ -6,8 +6,7 @@ capturing all user inputs collected during interactive execution.
 
 from pathlib import Path
 from typing import TypedDict, Literal, NotRequired
-from machineconfig.scripts.python.fire_agents_load_balancer import SPLITTING_STRATEGY
-from machineconfig.scripts.python.fire_agents_help_launch import AGENTS
+from machineconfig.scripts.python.helpers_agents.fire_agents_help_launch import AGENTS
 
 SEARCH_STRATEGIES = Literal["file_path", "keyword_search", "filename_pattern"]
 
@@ -21,26 +20,17 @@ class FilePathSearchInput(TypedDict):
 
 class KeywordSearchInput(TypedDict):
     """Input for keyword_search strategy."""
-
     keyword: str
 
 
 class FilenamePatternSearchInput(TypedDict):
     """Input for filename_pattern search strategy."""
-
     pattern: str  # e.g., '*.py', '*test*', 'config.*'
 
 
-class AgentCapSplittingInput(TypedDict):
-    """Input for agent_cap splitting strategy."""
-
-    agent_cap: int  # Default: 6
-
-
-class TaskRowsSplittingInput(TypedDict):
-    """Input for task_rows splitting strategy."""
-
-    task_rows: int  # Default: 13
+class TasksPerPromptSplittingInput(TypedDict):
+    """Input for tasks_per_prompt splitting strategy."""
+    tasks_per_prompt: int  # Default: 13
 
 
 class FireAgentsMainInput(TypedDict):
@@ -49,7 +39,6 @@ class FireAgentsMainInput(TypedDict):
     # Core configuration
     repo_root: Path
     search_strategy: SEARCH_STRATEGIES
-    splitting_strategy: SPLITTING_STRATEGY
     agent_selected: AGENTS
     prompt_prefix: str
     job_name: str  # Default: "AI_Agents"
@@ -62,8 +51,7 @@ class FireAgentsMainInput(TypedDict):
     filename_pattern_input: NotRequired[FilenamePatternSearchInput]
 
     # Splitting strategy specific inputs (only one will be present based on splitting_strategy)
-    agent_cap_input: NotRequired[AgentCapSplittingInput]
-    task_rows_input: NotRequired[TaskRowsSplittingInput]
+    tasks_per_prompt: TasksPerPromptSplittingInput
 
 
 class FireAgentsRuntimeData(TypedDict):

machineconfig/utils/schemas/installer/installer_types.py

@@ -1,20 +1,42 @@
-from typing import TypedDict, Literal, TypeAlias
+from typing import TypedDict, Literal, TypeAlias, Optional
+import platform
 
 
-APP_INSTALLER_CATEGORY: TypeAlias = Literal["OS_SPECIFIC", "OS_GENERIC", "CUSTOM", "OS_SPECIFIC_DEV", "OS_GENERIC_DEV", "CUSTOM_DEV"]
 CPU_ARCHITECTURES: TypeAlias = Literal["amd64", "arm64"]
 OPERATING_SYSTEMS: TypeAlias = Literal["windows", "linux", "macos"]
 
 
 class InstallerData(TypedDict):
     appName: str
-    repoURL: str
     doc: str
-    filenameTemplate: dict[CPU_ARCHITECTURES, dict[OPERATING_SYSTEMS, str]]
-    stripVersion: bool
-    exeName: str
+    repoURL: str
+    fileNamePattern: dict[CPU_ARCHITECTURES, dict[OPERATING_SYSTEMS, Optional[str]]]
 
 
 class InstallerDataFiles(TypedDict):
     version: str
     installers: list[InstallerData]
+
+
+def get_os_name() -> OPERATING_SYSTEMS:
+    """Get the operating system name in the format expected by the github parser."""
+    sys_name = platform.system()
+    if sys_name == "Windows":
+        return "windows"
+    elif sys_name == "Linux":
+        return "linux"
+    elif sys_name == "Darwin":
+        return "macos"
+    else:
+        raise NotImplementedError(f"System {sys_name} not supported")
+
+
+def get_normalized_arch() -> CPU_ARCHITECTURES:
+    """Get the normalized CPU architecture."""
+    arch_raw = platform.machine().lower()
+    if arch_raw in ("x86_64", "amd64"):
+        return "amd64" 
+    if arch_raw in ("aarch64", "arm64", "armv8", "armv8l"):
+        return "arm64"
+    # Default to amd64 if unknown architecture
+    return "amd64"