machineconfig 2.2__py3-none-any.whl → 2.3__py3-none-any.whl

machineconfig/scripts/python/fire_jobs_args_helper.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass
+from typing import Optional
+import argparse
+
+
+@dataclass
+class FireJobArgs:
+    """Type-safe dataclass for fire_jobs command line arguments."""
+
+    path: str = "."
+    function: Optional[str] = None
+    ve: str = ""
+    cmd: bool = False
+    interactive: bool = False
+    debug: bool = False
+    choose_function: bool = False
+    loop: bool = False
+    jupyter: bool = False
+    submit_to_cloud: bool = False
+    remote: bool = False
+    module: bool = False
+    streamlit: bool = False
+    environment: str = ""
+    holdDirectory: bool = False
+    PathExport: bool = False
+    git_pull: bool = False
+    optimized: bool = False
+    Nprocess: int = 1
+    zellij_tab: Optional[str] = None
+    watch: bool = False
+    kw: Optional[list[str]] = None
+    layout: bool = False
+
+
+def get_args() -> FireJobArgs:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("path", nargs="?", type=str, help="The directory containing the jobs", default=".")
+    parser.add_argument("function", nargs="?", type=str, help="Fuction to run", default=None)
+    parser.add_argument("--ve", "-v", type=str, help="virtual enviroment name", default="")
+    parser.add_argument("--cmd", "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
+    parser.add_argument("--interactive", "-i", action="store_true", help="Whether to run the job interactively using IPython")
+    parser.add_argument("--debug", "-d", action="store_true", help="debug")
+    parser.add_argument("--choose_function", "-c", action="store_true", help="debug")
+    parser.add_argument("--loop", "-l", action="store_true", help="infinite recusion (runs again after completion/interruption)")
+    parser.add_argument("--jupyter", "-j", action="store_true", help="open in a jupyter notebook")
+    parser.add_argument("--submit_to_cloud", "-C", action="store_true", help="submit to cloud compute")
+    parser.add_argument("--remote", "-r", action="store_true", help="launch on a remote machine")
+    parser.add_argument("--module", "-m", action="store_true", help="launch the main file")
+    parser.add_argument("--streamlit", "-S", action="store_true", help="run as streamlit app")
+    parser.add_argument("--environment", "-E", type=str, help="Choose ip, localhost, hostname or arbitrary url", default="")
+    parser.add_argument("--holdDirectory", "-D", action="store_true", help="hold current directory and avoid cd'ing to the script directory")
+    parser.add_argument("--PathExport", "-P", action="store_true", help="augment the PYTHONPATH with repo root.")
+    parser.add_argument("--git_pull", "-g", action="store_true", help="Start by pulling the git repo")
+    parser.add_argument("--optimized", "-O", action="store_true", help="Run the optimized version of the function")
+    parser.add_argument("--Nprocess", "-p", type=int, help="Number of processes to use", default=1)
+    parser.add_argument("--zellij_tab", "-z", type=str, dest="zellij_tab", help="open in a new zellij tab")
+    parser.add_argument("--watch", "-w", action="store_true", help="watch the file for changes")
+    parser.add_argument("--kw", nargs="*", default=None, help="keyword arguments to pass to the function in the form of k1 v1 k2 v2 ... (meaning k1=v1, k2=v2, etc)")
+    parser.add_argument("--layout", "-L", action="store_true", help="use layout configuration (Zellij Or WindowsTerminal)")
+
+    try:
+        args_raw = parser.parse_args()
+    except Exception as ex:
+        print(f"❌ Failed to parse arguments: {ex}")
+        parser.print_help()
+        raise ex
+    args = FireJobArgs(**vars(args_raw))
+    return args
+
+
+def extract_kwargs(args: FireJobArgs) -> dict[str, object]:
+    str2obj = {"True": True, "False": False, "None": None}
+    if args.kw is not None:
+        assert len(args.kw) % 2 == 0, f"args.kw must be a list of even length. Got {len(args.kw)}"
+        kwargs = dict(zip(args.kw[::2], args.kw[1::2]))
+        kwargs: dict[str, object]
+        for key, value in kwargs.items():
+            if value in str2obj:
+                kwargs[key] = str2obj[str(value)]
+        if args.function is None:  # if user passed arguments and forgot to pass function, then assume they want to run the main function.
+            args.choose_function = True
+    else:
+        kwargs = {}
+    return kwargs

machineconfig/scripts/python/fire_jobs_layout_helper.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig, LayoutsFile
+from typing import Optional, TYPE_CHECKING
+from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
+from machineconfig.utils.options import choose_one_option
+from machineconfig.utils.path import match_file_name, sanitize_path
+from machineconfig.utils.path_reduced import PathExtended as PathExtended
+
+if TYPE_CHECKING:
+    from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs
+
+
+def select_layout(layouts_json_file: Path, layout_name: Optional[str]):
+    import json
+
+    layout_file: LayoutsFile = json.loads(layouts_json_file.read_text(encoding="utf-8"))
+    if len(layout_file["layouts"]) == 0:
+        raise ValueError(f"No layouts found in {layouts_json_file}")
+    if layout_name is None:
+        options = [layout["layoutName"] for layout in layout_file["layouts"]]
+        from machineconfig.utils.options import choose_one_option
+
+        layout_name = choose_one_option(options=options, prompt="Choose a layout configuration:", fzf=True)
+    print(f"Selected layout: {layout_name}")
+    layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == layout_name), None)
+    if layout_chosen is None:
+        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == layout_name.lower()), None)
+    if layout_chosen is None:
+        available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+        raise ValueError(f"Layout '{layout_name}' not found. Available layouts: {available_layouts}")
+    return layout_chosen
+
+
+def launch_layout(layout_config: LayoutConfig) -> Optional[Exception]:
+    import platform
+
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        print("🧑‍💻 Launching layout using Zellij terminal multiplexer...")
+        from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
+
+        run_zellij_layout(layout_config=layout_config)
+    elif platform.system() == "Windows":
+        print("🧑‍💻 Launching layout using Windows Terminal...")
+        from machineconfig.cluster.sessions_managers.wt_local import run_wt_layout
+
+        run_wt_layout(layout_config=layout_config)
+    else:
+        print(f"❌ Unsupported platform: {platform.system()}")
+    return None
+
+
+def handle_layout_args(args: "FireJobArgs") -> None:
+    # args.function = args.path
+    # args.path = "layout.json"
+    path_obj = sanitize_path(args.path)
+    if not path_obj.exists():
+        choice_file = match_file_name(sub_string=args.path, search_root=PathExtended.cwd(), suffixes={".json"})
+    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)
+        print(f"🔍 Got #{len(files)} results.")
+        choice_file = choose_one_option(options=files, fzf=True)
+        choice_file = PathExtended(choice_file)
+    else:
+        choice_file = path_obj
+    launch_layout(layout_config=select_layout(layouts_json_file=choice_file, layout_name=args.function))

machineconfig/scripts/python/helpers/helpers4.py

@@ -43,7 +43,6 @@ def parse_pyfile(file_path: str):
 
     args_spec = NamedTuple("args_spec", [("name", str), ("type", str), ("default", Optional[str])])
     func_args: list[list[args_spec]] = [[]]  # this firt prepopulated dict is for the option 'RUN AS MAIN' which has no args
-
     import ast
 
     parsed_ast = ast.parse(PathExtended(file_path).read_text(encoding="utf-8"))

machineconfig/scripts/python/wifi_conn.py

@@ -187,7 +187,6 @@ def connect_to_new_network(ssid: str, password: str):
 def display_available_networks():
     """Display available networks (legacy function for compatibility)"""
     console.print("\n[blue]📡 Scanning for available networks...[/blue]")
-
     try:
         if platform.system() == "Windows":
             subprocess.run(["netsh", "wlan", "show", "networks", "interface=Wi-Fi"], check=True)

machineconfig/utils/code.py

@@ -1,4 +1,3 @@
-
 import platform
 from typing import Optional
 import subprocess

machineconfig/utils/installer_utils/installer_abc.py

@@ -1,4 +1,3 @@
-
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH
 from typing import Optional, TypeAlias, Literal

machineconfig/utils/options.py

@@ -5,25 +5,25 @@ from rich.console import Console
 import platform
 import subprocess
 from typing import Optional, Union, TypeVar, Iterable
+from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH
+
 
 T = TypeVar("T")
 
 
 def check_tool_exists(tool_name: str) -> bool:
-    if platform.system() == "Windows": tool_name = tool_name.replace(".exe", "") + ".exe"
-
-    from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH
-
     if platform.system() == "Windows":
+        tool_name = tool_name.replace(".exe", "") + ".exe"
         cmd = "where.exe"
         root_path = Path(WINDOWS_INSTALL_PATH)
     elif platform.system() in ["Linux", "Darwin"]:
         cmd = "which"
         root_path = Path(LINUX_INSTALL_PATH)
-    else: raise NotImplementedError(f"platform {platform.system()} not implemented")
-
+        return any([Path("/usr/local/bin").joinpath(tool_name).is_file(), Path("/usr/bin").joinpath(tool_name).is_file(), root_path.joinpath(tool_name).is_file()])
+    else:
+        raise NotImplementedError(f"platform {platform.system()} not implemented")
     _ = cmd
-    # try:
+    # try:  # talking to terminal is too slow.
     #     _tmp = subprocess.check_output([cmd, tool_name], stderr=subprocess.DEVNULL)
     #     res: bool = True
     # except (subprocess.CalledProcessError, FileNotFoundError):

machineconfig/utils/path.py

@@ -12,7 +12,7 @@ T = TypeVar("T")
 console = Console()
 
 
-def sanitize_path(a_path: PathExtended) -> PathExtended:
+def sanitize_path(a_path: str) -> PathExtended:
     path = PathExtended(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"
@@ -26,14 +26,14 @@ def sanitize_path(a_path: PathExtended) -> PathExtended:
             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:])
             assert path.exists(), f"File not found: {path}"
-            source_os = "Linux" if a_path.as_posix().startswith("/home") else "macOS"
+            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
             skip_parts = 3  # Both /home/username and /Users/username have 3 parts to skip
             path = PathExtended.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 a_path.as_posix().startswith("/home") else "macOS"
+            source_os = "Linux" if path.as_posix().startswith("/home") else "macOS"
             console.print(Panel(f"🔗 PATH MAPPING | {source_os} → {current_os}: `{a_path}` ➡️ `{path}`", title="Path Mapping", expand=False))
     elif path.as_posix().startswith("C:"):
         if platform.system() in ["Linux", "Darwin"]:  # path copied from Windows to Linux/Mac
@@ -49,18 +49,18 @@ def sanitize_path(a_path: PathExtended) -> PathExtended:
     return path.expanduser().absolute()
 
 
-def find_scripts(root: Path, name_substring: str) -> tuple[list[Path], list[Path]]:
+def find_scripts(root: Path, name_substring: str, suffixes: set[str]) -> tuple[list[Path], list[Path]]:
     filename_matches = []
     partial_path_matches = []
     for entry in root.iterdir():
         if entry.is_dir():
-            if entry.name in {".links", ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__"}:
+            if entry.name in {".links", ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__", ".mypy_cache"}:
                 # prune this entire subtree
                 continue
-            tmp1, tmp2 = find_scripts(entry, name_substring)
+            tmp1, tmp2 = find_scripts(entry, name_substring, suffixes)
             filename_matches.extend(tmp1)
             partial_path_matches.extend(tmp2)
-        elif entry.is_file() and entry.suffix in {".py", ".sh", ".ps1"}:
+        elif entry.is_file() and entry.suffix in suffixes:
             if name_substring.lower() in entry.name.lower():
                 filename_matches.append(entry)
             elif name_substring.lower() in entry.as_posix().lower():
@@ -68,14 +68,14 @@ def find_scripts(root: Path, name_substring: str) -> tuple[list[Path], list[Path
     return filename_matches, partial_path_matches
 
 
-def match_file_name(sub_string: str, search_root: PathExtended) -> PathExtended:
+def match_file_name(sub_string: str, search_root: PathExtended, suffixes: set[str]) -> PathExtended:
     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)
+    filename_matches, partial_path_matches = find_scripts(search_root_obj, sub_string, suffixes)
     if len(filename_matches) == 1:
         return PathExtended(filename_matches[0])
-    console.print(Panel(f"Partial filename match with case-insensitivity failed. This generated #{len(filename_matches)} results.", title="Search", expand=False))
-    if len(filename_matches) < 10:
+    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.")
@@ -112,7 +112,7 @@ def match_file_name(sub_string: str, search_root: PathExtended) -> PathExtended:
     if len(search_res) == 1:
         return search_root_obj.joinpath(search_res_raw)
 
-    print(f"⚠️ WARNING | Multiple search results found for `{sub_string}`\n'{search_res_raw}'")
+    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}"
     console.print(Panel(f"🔍 SEARCH STRATEGY | Trying with raw fzf search ...\n{cmd}", title="Search Strategy", expand=False))
     try:

machineconfig/utils/path_reduced.py

@@ -1,4 +1,3 @@
-
 from machineconfig.utils.utils2 import randstr
 
 from datetime import datetime
@@ -18,13 +17,16 @@ SHUTIL_FORMATS: TypeAlias = Literal["zip", "tar", "gztar", "bztar", "xztar"]
 
 def pwd2key(password: str, salt: Optional[bytes] = None, iterations: int = 10) -> bytes:  # Derive a secret key from a given password and salt"""
     import base64
+
     if salt is None:
         import hashlib
+
         m = hashlib.sha256()
         m.update(password.encode(encoding="utf-8"))
         return base64.urlsafe_b64encode(s=m.digest())  # make url-safe bytes required by Ferent.
     from cryptography.hazmat.primitives import hashes
     from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
     return base64.urlsafe_b64encode(PBKDF2HMAC(algorithm=hashes.SHA256(), length=32, salt=salt, iterations=iterations, backend=None).derive(password.encode()))
 
 
@@ -394,6 +396,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
 
         if system() == "Windows" and not Terminal.is_user_admin():  # you cannot create symlink without priviliages.
             import win32com.shell.shell
+
             _proce_info = win32com.shell.shell.ShellExecuteEx(lpVerb="runas", lpFile=sys.executable, lpParameters=f" -c \"from pathlib import Path; Path(r'{self.expanduser()}').symlink_to(r'{str(target_obj)}')\"")
             # TODO update PATH for this to take effect immediately.
             time.sleep(1)  # wait=True equivalent
@@ -443,6 +446,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         if ".zip" in str(slf) and compressed:  # the root (self) is itself a zip archive (as opposed to some search results are zip archives)
             import zipfile
             import fnmatch
+
             root = slf.as_zip_path()
             if not r:
                 raw = list(root.iterdir())
@@ -665,6 +669,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
     def ungz(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, inplace: bool = False, orig: bool = False, verbose: bool = True) -> "PathExtended":
         op_path = self._resolve_path(folder, name, path, self.name.replace(".gz", "")).expanduser().resolve()
         import gzip
+
         PathExtended(str(op_path)).write_bytes(gzip.decompress(PathExtended(str(self.expanduser().resolve())).read_bytes()))
         msg = f"UNGZED {repr(self)} ==>  {repr(op_path)}"
         ret = self if orig else PathExtended(op_path)

machineconfig/utils/ssh.py

@@ -119,13 +119,16 @@ class SSH:  # inferior alternative: https://github.com/fabric/fabric
         def view_bar(slf: Any, a: Any, b: Any):
             slf.total = int(b)
             slf.update(int(a - slf.n))  # update pbar with increment
+
         from tqdm import tqdm
+
         self.tqdm_wrap = type("TqdmWrap", (tqdm,), {"view_bar": view_bar})
         self._local_distro: Optional[str] = None
         self._remote_distro: Optional[str] = None
         self._remote_machine: Optional[MACHINE] = None
         self.terminal_responses: list[Response] = []
         self.platform = platform
+
     def get_remote_machine(self) -> MACHINE:
         if self._remote_machine is None:
             if self.run("$env:OS", verbose=False, desc="Testing Remote OS Type").op == "Windows_NT" or self.run("echo %OS%", verbose=False, desc="Testing Remote OS Type Again").op == "Windows_NT":
@@ -138,10 +141,12 @@ class SSH:  # inferior alternative: https://github.com/fabric/fabric
         if self._local_distro is None:
             command = """uv run --with distro python -c "import distro; print(distro.name(pretty=True))" """
             import subprocess
+
             res = subprocess.run(command, shell=True, capture_output=True, text=True).stdout.strip()
             self._local_distro = res
             return res
         return self._local_distro
+
     def get_remote_distro(self):
         if self._remote_distro is None:
             res = self.run("""~/.local/bin/uv run --with distro python -c "import distro; print(distro.name(pretty=True))" """)
@@ -178,8 +183,10 @@ class SSH:  # inferior alternative: https://github.com/fabric/fabric
         res = Response(cmd=command)
         res.output.returncode = os.system(command)
         return res
+
     def get_ssh_conn_str(self, cmd: str = ""):
         return "ssh " + (f" -i {self.sshkey}" if self.sshkey else "") + self.get_remote_repr().replace(":", " -p ") + (f" -t {cmd} " if cmd != "" else " ")
+
     def run(self, cmd: str, verbose: bool = True, desc: str = "", strict_err: bool = False, strict_returncode: bool = False) -> Response:
         raw = self.ssh.exec_command(cmd)
         res = Response(stdin=raw[0], stdout=raw[1], stderr=raw[2], cmd=cmd, desc=desc)  # type: ignore
@@ -189,15 +196,18 @@ class SSH:  # inferior alternative: https://github.com/fabric/fabric
             res.print()
         self.terminal_responses.append(res)
         return res
+
     def run_py(self, cmd: str, desc: str = "", return_obj: bool = False, verbose: bool = True, strict_err: bool = False, strict_returncode: bool = False) -> Union[Any, Response]:
         assert '"' not in cmd, 'Avoid using `"` in your command. I dont know how to handle this when passing is as command to python in pwsh command.'
         if not return_obj:
             return self.run(
-                cmd=f"""uv run --with machineconfig -c "{Terminal.get_header(wdir=None, toolbox=True)}{cmd}\n""" + '"', desc=desc or f"run_py on {self.get_remote_repr()}", verbose=verbose, strict_err=strict_err, strict_returncode=strict_returncode)
+                cmd=f"""uv run --with machineconfig -c "{Terminal.get_header(wdir=None, toolbox=True)}{cmd}\n""" + '"', desc=desc or f"run_py on {self.get_remote_repr()}", verbose=verbose, strict_err=strict_err, strict_returncode=strict_returncode
+            )
         assert "obj=" in cmd, "The command sent to run_py must have `obj=` statement if return_obj is set to True"
         source_file = self.run_py(f"""{cmd}\npath = Save.pickle(obj=obj, path=P.tmpfile(suffix='.pkl'))\nprint(path)""", desc=desc, verbose=verbose, strict_err=True, strict_returncode=True).op.split("\n")[-1]
         res = self.copy_to_here(source=source_file, target=PathExtended.tmpfile(suffix=".pkl"))
         import pickle
+
         return pickle.loads(res.read_bytes())
 
     def copy_from_here(self, source: PLike, target: OPLike = None, z: bool = False, r: bool = False, overwrite: bool = False, init: bool = True) -> Union[PathExtended, list[PathExtended]]:

machineconfig/utils/upgrade_packages.py

@@ -10,7 +10,7 @@ from typing import Any
 def generate_uv_add_commands(pyproject_path: Path, output_path: Path) -> None:
     """
     Generate uv add commands for each dependency group in pyproject.toml.
-    
+
     Args:
         pyproject_path: Path to the pyproject.toml file
         output_path: Path where to write the uv add commands
@@ -18,9 +18,9 @@ def generate_uv_add_commands(pyproject_path: Path, output_path: Path) -> None:
     # Read pyproject.toml
     with open(pyproject_path, "rb") as f:
         pyproject_data: dict[str, Any] = tomllib.load(f)
-    
+
     commands: list[str] = []
-    
+
     # Handle main dependencies (no group)
     if "project" in pyproject_data and "dependencies" in pyproject_data["project"]:
         main_deps = pyproject_data["project"]["dependencies"]
@@ -28,7 +28,7 @@ def generate_uv_add_commands(pyproject_path: Path, output_path: Path) -> None:
             # Extract package names without version constraints
             package_names = [extract_package_name(dep) for dep in main_deps]
             commands.append(f"uv add {' '.join(package_names)}")
-    
+
     # Handle optional dependencies as groups
     if "project" in pyproject_data and "optional-dependencies" in pyproject_data["project"]:
         optional_deps = pyproject_data["project"]["optional-dependencies"]
@@ -36,7 +36,7 @@ def generate_uv_add_commands(pyproject_path: Path, output_path: Path) -> None:
             if deps:
                 package_names = [extract_package_name(dep) for dep in deps]
                 commands.append(f"uv add {' '.join(package_names)} --group {group_name}")
-    
+
     # Handle dependency-groups (like dev)
     if "dependency-groups" in pyproject_data:
         dep_groups = pyproject_data["dependency-groups"]
@@ -47,19 +47,19 @@ def generate_uv_add_commands(pyproject_path: Path, output_path: Path) -> None:
                     commands.append(f"uv add {' '.join(package_names)} --dev")
                 else:
                     commands.append(f"uv add {' '.join(package_names)} --group {group_name}")
-    
+
     # Write commands to output file
     with open(output_path, "w") as f:
         for command in commands:
             f.write(command + "\n")
-    
+
     print(f"Generated {len(commands)} uv add commands in {output_path}")
 
 
 def extract_package_name(dependency_spec: str) -> str:
     """
     Extract package name from dependency specification.
-    
+
     Examples:
         "rich>=14.0.0" -> "rich"
         "requests>=2.32.5" -> "requests"
@@ -69,12 +69,12 @@ def extract_package_name(dependency_spec: str) -> str:
     # Handle extras like "package[extra]>=1.0" first
     if "[" in dependency_spec:
         dependency_spec = dependency_spec.split("[")[0].strip()
-    
+
     # Split on common version operators and take the first part
     for operator in [">=", "<=", "==", "!=", ">", "<", "~=", "===", "@"]:
         if operator in dependency_spec:
             return dependency_spec.split(operator)[0].strip()
-    
+
     # Return as-is if no version constraint found
     return dependency_spec.strip()
 
@@ -84,8 +84,8 @@ if __name__ == "__main__":
     current_dir = Path.cwd()
     pyproject_file = current_dir / "pyproject.toml"
     output_file = current_dir / "uv_add_commands.txt"
-    
+
     if pyproject_file.exists():
         generate_uv_add_commands(pyproject_file, output_file)
     else:
-        print(f"pyproject.toml not found at {pyproject_file}")
+        print(f"pyproject.toml not found at {pyproject_file}")

{machineconfig-2.2.dist-info → machineconfig-2.3.dist-info}/METADATA

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