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

machineconfig/utils/ssh.py

@@ -5,6 +5,7 @@ import rich.console
 from machineconfig.utils.terminal import Terminal, Response, MACHINE
 from machineconfig.utils.path_reduced import PathExtended, PLike, OPLike
 from machineconfig.utils.utils2 import pprint
+# from machineconfig.utils.ve import get_ve_activate_line
 
 
 @dataclass
@@ -95,7 +96,6 @@ class SSH:  # inferior alternative: https://github.com/fabric/fabric
         self.ssh.load_system_host_keys()
         self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
         pprint(dict(host=self.host, hostname=self.hostname, username=self.username, password="***", port=self.port, key_filename=self.sshkey, ve=self.ve), title="SSHing To")
-
         sock = paramiko.ProxyCommand(self.proxycommand) if self.proxycommand is not None else None
         try:
             if pwd is None:
@@ -109,7 +109,6 @@ class SSH:  # inferior alternative: https://github.com/fabric/fabric
             rich.console.Console().print_exception()
             self.pwd = getpass.getpass(f"Enter password for {self.username}@{self.hostname}: ")
             self.ssh.connect(hostname=self.hostname, username=self.username, password=self.pwd, port=self.port, key_filename=self.sshkey, compress=self.compress, sock=sock, allow_agent=False, look_for_keys=False)  # type: ignore
-
         try:
             self.sftp: Optional[paramiko.SFTPClient] = self.ssh.open_sftp()
         except Exception as err:
@@ -120,24 +119,13 @@ 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
-        self.remote_env_cmd = rf"""~/code/machineconfig/{self.ve}/Scripts/Activate.ps1""" if self.get_remote_machine() == "Windows" else rf"""source ~/code/machineconfig/{self.ve}/bin/activate"""
-        self.local_env_cmd = rf"""~/code/machineconfig/{self.ve}/Scripts/Activate.ps1""" if self.platform.system() == "Windows" else rf"""source ~/code/machineconfig/{self.ve}/bin/activate"""  # works for both cmd and pwsh
-
-    def __getstate__(self):
-        return {attr: self.__getattribute__(attr) for attr in ["username", "hostname", "host", "port", "sshkey", "compress", "pwd", "ve"]}
-
-    def __setstate__(self, state: dict[str, Any]):
-        SSH(**state)
-
     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":
@@ -150,16 +138,14 @@ 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:
-            self._remote_distro = self.run_py("print(install_n_import('distro').name(pretty=True))", verbose=False).op_if_successfull_or_default() or ""
-            # q.run("""~/.local/bin/uv run --with distro python -c "import distro; print(distro.name(pretty=True))" """)
+            res = self.run("""~/.local/bin/uv run --with distro python -c "import distro; print(distro.name(pretty=True))" """)
+            self._remote_distro = res.op_if_successfull_or_default() or ""
         return self._remote_distro
 
     def restart_computer(self):
@@ -192,13 +178,9 @@ 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 open_console(self, cmd: str = '', new_window: bool = True, terminal: Optional[str] = None, shell: str = "pwsh"): Terminal().run_async(*(self.get_ssh_conn_str(cmd=cmd).split(" ")), new_window=new_window, terminal=terminal, shell=shell)
-    def run(self, cmd: str, verbose: bool = True, desc: str = "", strict_err: bool = False, strict_returncode: bool = False, env_prefix: bool = False) -> Response:  # most central method.
-        cmd = (self.remote_env_cmd + "; " + cmd) if env_prefix else cmd
+    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
         if not verbose:
@@ -207,20 +189,16 @@ 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"""{self.remote_env_cmd}; python -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
-
-        res_bytes = res.read_bytes()
-        return pickle.loads(res_bytes)
+        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]]:
         if init:
@@ -239,7 +217,9 @@ class SSH:  # inferior alternative: https://github.com/fabric/fabric
             source_list: list[PathExtended] = source_obj.search("*", folders=False, files=True, r=True)
             remote_root = (
                 self.run_py(
-                    f"path=P(r'{PathExtended(target).as_posix()}').expanduser()\n{'path.delete(sure=True)' if overwrite else ''}\nprint(path.create())", desc=f"Creating Target directory `{PathExtended(target).as_posix()}` @ {self.get_remote_repr()}", verbose=False
+                    f"path=P(r'{PathExtended(target).as_posix()}').expanduser()\n{'path.delete(sure=True)' if overwrite else ''}\nprint(path.create())",
+                    desc=f"Creating Target directory `{PathExtended(target).as_posix()}` @ {self.get_remote_repr()}",
+                    verbose=False,
                 ).op
                 or ""
             )

machineconfig/utils/terminal.py

@@ -143,7 +143,8 @@ class Terminal:
     def run_script(self, script: str, shell: SHELLS = "default", verbose: bool = False):
         if self.machine == "Linux":
             script = "#!/bin/bash" + "\n" + script  # `source` is only available in bash.
-        script_file = PathExtended.tmpfile(name="tmp_shell_script", suffix=".ps1" if self.machine == "Windows" else ".sh", folder="tmp_scripts").write_text(script, newline={"Windows": None, "Linux": "\n"}[self.machine])
+        script_file = PathExtended.tmpfile(name="tmp_shell_script", suffix=".ps1" if self.machine == "Windows" else ".sh", folder="tmp_scripts")
+        script_file.write_text(script, newline={"Windows": None, "Linux": "\n"}[self.machine])
         if shell == "default":
             if self.machine == "Windows":
                 start_cmd = "powershell"  # default shell on Windows is cmd which is not very useful. (./source is not available)
@@ -188,7 +189,8 @@ class Terminal:
 {f"cd {wdir}" if wdir is not None else ""}
 {"ipython" if ipython else "python"} {"-i" if interactive else ""} {py_script}
 """
-        shell_script = PathExtended.tmpfile(name="tmp_shell_script", suffix=".sh" if self.machine == "Linux" else ".ps1", folder="tmp_scripts/shell").write_text(shell_script)
+        shell_path = PathExtended.tmpfile(name="tmp_shell_script", suffix=".sh" if self.machine == "Linux" else ".ps1", folder="tmp_scripts/shell")
+        shell_path.write_text(shell_script)
         if shell is None and self.machine == "Windows":
             shell = "pwsh"
         window = "start" if new_window and self.machine == "Windows" else ""

machineconfig/utils/upgrade_packages.py

@@ -0,0 +1,91 @@
+"""
+Generate uv add commands from pyproject.toml dependency groups.
+"""
+
+from pathlib import Path
+import tomllib
+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
+    """
+    # 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"]
+        if main_deps:
+            # 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"]
+        for group_name, deps in optional_deps.items():
+            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"]
+        for group_name, deps in dep_groups.items():
+            if deps:
+                package_names = [extract_package_name(dep) for dep in deps]
+                if group_name == "dev":
+                    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"
+        "pywin32" -> "pywin32"
+        "package[extra]>=1.0" -> "package"
+    """
+    # 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()
+
+
+if __name__ == "__main__":
+    # Example usage
+    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}")

machineconfig/utils/utils2.py

@@ -1,7 +1,5 @@
 from pathlib import Path
 from typing import Optional, Any
-# import time
-# from typing import Callable, Literal, TypeVar, ParamSpec
 
 
 def randstr(length: int = 10, lower: bool = True, upper: bool = True, digits: bool = True, punctuation: bool = False, safe: bool = False, noun: bool = False) -> str:
@@ -51,6 +49,7 @@ def read_toml(path: "Path"):
 
 def pprint(obj: dict[Any, Any], title: str) -> None:
     from rich import inspect
+
     inspect(type("TempStruct", (object,), obj)(), value=False, title=title, docs=False, dunder=False, sort=False)
 
 

machineconfig/utils/utils5.py

@@ -149,20 +149,25 @@ 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))
+
+
 def from_pickle(path: Path) -> Any:
     import pickle
+
     return pickle.loads(path.read_bytes())
 
 
 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]
-    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) -> None:
+    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
+    ) -> 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.
@@ -173,12 +178,14 @@ class Cache(Generic[T]):  # This class helps to accelrate access to latest data
         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
@@ -228,9 +235,11 @@ class Cache(Generic[T]):  # This class helps to accelrate access to latest data
                 self.cache = self.source_func()  # fresh data.
                 self.last_call_is_fresh = True
                 self.time_produced = datetime.now()
-                if self.path is not None: self.save(self.cache, self.path)
+                if self.path is not None:
+                    self.save(self.cache, self.path)
         else:  # cache exists
-            try: age = self.age
+            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:
@@ -243,7 +252,8 @@ class Cache(Generic[T]):  # This class helps to accelrate access to latest data
                 self.cache = self.source_func()
                 self.last_call_is_fresh = True
                 self.time_produced = datetime.now()
-                if self.path is not None: self.save(self.cache, self.path)
+                if self.path is not None:
+                    self.save(self.cache, self.path)
             else:
                 if self.logger:
                     self.logger(f"""
@@ -252,15 +262,17 @@ class Cache(Generic[T]):  # This class helps to accelrate access to latest data
 ⏱️  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):  # -> Callable[..., 'Cache[T2]']:
-        def decorator(source_func: Callable[[], T2]) -> Cache['T2']:
+    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
+    ):  # -> 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()

machineconfig/utils/ve.py

@@ -13,7 +13,10 @@ def get_ve_path_and_ipython_profile(init_path: PathExtended) -> tuple[Optional[s
         if tmp.joinpath(".ve.ini").exists():
             ini = read_ini(tmp.joinpath(".ve.ini"))
             if ve_path is None:
-                ve_path = ini["specs"]["ve_path"]
+                try:
+                    ve_path = ini["specs"]["ve_path"]
+                except KeyError:
+                    raise KeyError(f".ve.ini file at {tmp.joinpath('.ve.ini')} is missing the 've_path' key in the 'specs' section.")
                 print(f"🐍 Using Virtual Environment: {ve_path}. This is based on this file {tmp.joinpath('.ve.ini')}")
             if ipy_profile is None:
                 ipy_profile = ini["specs"]["ipy_profile"]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 2.1
+Version: 2.2
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0
@@ -11,26 +11,26 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
-Requires-Dist: rich>=14.0.0
+Requires-Dist: cryptography>=44.0.2
+Requires-Dist: fire>=0.7.0
+Requires-Dist: gitpython>=3.1.44
+Requires-Dist: joblib>=1.5.2
+Requires-Dist: markdown>=3.9
 Requires-Dist: paramiko>=3.5.1
 Requires-Dist: psutil>=7.0.0
-Requires-Dist: fire>=0.7.0
 Requires-Dist: pydantic>=2.11.3
-Requires-Dist: gitpython>=3.1.44
 Requires-Dist: pyfzf>=0.3.1
-Requires-Dist: rclone-python>=0.1.23
+Requires-Dist: pyjson5>=1.6.9
 Requires-Dist: pytz>=2025.2
-Requires-Dist: tomli>=2.2.1
-Requires-Dist: toml>=0.10.2
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: pyjson5>=1.6.9
-Requires-Dist: requests>=2.32.5
-Requires-Dist: tqdm>=4.67.1
-Requires-Dist: joblib>=1.5.2
 Requires-Dist: randomname>=0.2.1
-Requires-Dist: cryptography>=44.0.2
+Requires-Dist: rclone-python>=0.1.23
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rich>=14.0.0
 Requires-Dist: tenacity>=9.1.2
-Requires-Dist: markdown>=3.9
+Requires-Dist: toml>=0.10.2
+Requires-Dist: tomli>=2.2.1
+Requires-Dist: tqdm>=4.67.1
 Provides-Extra: windows
 Requires-Dist: pywin32; extra == "windows"
 Provides-Extra: docs