machineconfig 6.61__py3-none-any.whl → 6.62__py3-none-any.whl

machineconfig/scripts/python/ftpx.py

@@ -183,7 +183,7 @@ def ftpx(
                     padding=(1, 2),
                 )
             )
-            received_file = ssh.copy_from_here(source_path=resolved_source, target_path=resolved_target, compress_with_zip=zipFirst, recursive=recursive, overwrite_existing=False)
+            received_file = ssh.copy_from_here(source_path=resolved_source, target_rel2home=resolved_target, compress_with_zip=zipFirst, recursive=recursive, overwrite_existing=False)
 
     if source_is_remote and isinstance(received_file, PathExtended):
         console.print(

machineconfig/scripts/python/helpers_devops/cli_utils.py

@@ -1,7 +1,7 @@
 
 
 import typer
-from typing import Annotated, Optional
+from typing import Annotated, Optional, TypedDict
 from pathlib import Path
 import subprocess
 import requests
@@ -115,3 +115,28 @@ def merge_pdfs(
     from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=["pypdf"], uv_project_dir=None)
     run_shell_script(uv_command)
+
+
+class MachineSpecs(TypedDict):
+    system: str
+    distro: str
+    home_dir: str
+def get_machine_specs() -> MachineSpecs:
+    """Write print and return the local machine specs."""
+    import platform
+    UV_RUN_CMD = "$HOME/.local/bin/uv run" if platform.system() != "Windows" else """& "$env:USERPROFILE/.local/bin/uv" run"""
+    command = f"""{UV_RUN_CMD} --with distro python -c "import distro; print(distro.name(pretty=True))" """
+    import subprocess
+    distro = subprocess.run(command, shell=True, capture_output=True, text=True).stdout.strip()
+    specs: MachineSpecs = {
+        "system": platform.system(),
+        "distro": distro,
+        "home_dir": str(Path.home()),
+    }
+    print(specs)
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+    path = CONFIG_ROOT.joinpath("machine_specs.json")
+    CONFIG_ROOT.mkdir(parents=True, exist_ok=True)
+    import json
+    path.write_text(json.dumps(specs, indent=4), encoding="utf-8")
+    return specs

machineconfig/scripts/python/utils.py

@@ -1,6 +1,6 @@
 
 
-from machineconfig.scripts.python.helpers_devops.cli_utils import download, merge_pdfs
+from machineconfig.scripts.python.helpers_devops.cli_utils import download, merge_pdfs, get_machine_specs
 import typer
 
 
@@ -11,6 +11,8 @@ def get_app() -> typer.Typer:
     app.command(name="d", no_args_is_help=True, hidden=True)(download)
     app.command(name="merge-pdfs", no_args_is_help=True, help="[m] Merge two PDF files into one.")(merge_pdfs)
     app.command(name="m", no_args_is_help=True, hidden=True)(merge_pdfs)
+    app.command(name="get-machine-specs", no_args_is_help=False, help="[g] Get machine specifications.")(get_machine_specs)
+    app.command(name="g", no_args_is_help=False, hidden=True)(get_machine_specs)
     return app
 
 

machineconfig/utils/ssh.py

@@ -1,16 +1,16 @@
-from typing import Callable, Optional, Any, Union
+from typing import Callable, Optional, Any, Union, cast
 import os
 from pathlib import Path
 import platform
+from machineconfig.scripts.python.helpers_devops.cli_utils import MachineSpecs
 import rich.console
-from machineconfig.utils.terminal import Response, MACHINE
-from machineconfig.utils.accessories import pprint
-
+from machineconfig.utils.terminal import Response
+from machineconfig.utils.accessories import pprint, randstr
+from machineconfig.utils.meta import lambda_to_python_script
 UV_RUN_CMD = "$HOME/.local/bin/uv run" if platform.system() != "Windows" else """& "$env:USERPROFILE/.local/bin/uv" run"""
 MACHINECONFIG_VERSION = "machineconfig>=6.61"
 DEFAULT_PICKLE_SUBDIR = "tmp_results/tmp_scripts/ssh"
 
-
 class SSH:
     def __init__(
         self, host: Optional[str], username: Optional[str], hostname: Optional[str], ssh_key_path: Optional[str], password: Optional[str], port: int, enable_compression: bool):
@@ -22,7 +22,6 @@ class SSH:
         self.username: str
         self.port: int = port
         self.proxycommand: Optional[str] = None
-        import platform
         import paramiko  # type: ignore
         import getpass
 
@@ -109,13 +108,15 @@ class SSH:
             def view_bar(self, transferred: int, total: int) -> None:
                 if self.progress and self.task is not None:
                     self.progress.update(self.task, completed=transferred, total=total)
-
         self.tqdm_wrap = RichProgressWrapper
-        self._local_distro: Optional[str] = None
-        self._remote_distro: Optional[str] = None
-        self._remote_machine: Optional[MACHINE] = None
+        from machineconfig.scripts.python.helpers_devops.cli_utils import get_machine_specs
+        self.local_specs: MachineSpecs = get_machine_specs()
+        resp = self.run_shell(command=f"""~/.local/bin/utils get-machine-specs """, verbose_output=False, description="Getting remote machine specs", strict_stderr=False, strict_return_code=False)
+        import json
+        json_str = resp.op
+        print(f"Remote machine specs JSON: {resp}")
+        self.remote_specs: MachineSpecs = cast(MachineSpecs, json.loads(json_str))
         self.terminal_responses: list[Response] = []
-        self.platform = platform
 
     def __enter__(self) -> "SSH":
         return self
@@ -126,34 +127,11 @@ class SSH:
             self.sftp.close()
             self.sftp = None
         self.ssh.close()
-    def get_remote_machine(self) -> MACHINE:
-        if self._remote_machine is None:
-            windows_test1 = self.run_shell(command="$env:OS", verbose_output=False, description="Testing Remote OS Type", strict_stderr=False, strict_return_code=False).op
-            windows_test2 = self.run_shell(command="echo %OS%", verbose_output=False, description="Testing Remote OS Type Again", strict_stderr=False, strict_return_code=False).op
-            if windows_test1 == "Windows_NT" or windows_test2 == "Windows_NT":
-                self._remote_machine = "Windows"
-            else:
-                self._remote_machine = "Linux"
-        return self._remote_machine
-    def get_local_distro(self) -> str:
-        if self._local_distro is None:
-            command = f"""{UV_RUN_CMD} --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) -> str:
-        if self._remote_distro is None:
-            command_str = f"""{UV_RUN_CMD} --with distro python -c "import distro; print(distro.name(pretty=True))" """
-            res = self.run_shell(command=command_str, verbose_output=True, description="", strict_stderr=False, strict_return_code=False)
-            self._remote_distro = res.op_if_successfull_or_default() or ""
-        return self._remote_distro
     def restart_computer(self) -> Response:
-        return self.run_shell(command="Restart-Computer -Force" if self.get_remote_machine() == "Windows" else "sudo reboot", verbose_output=True, description="", strict_stderr=False, strict_return_code=False)
+        return self.run_shell(command="Restart-Computer -Force" if self.remote_specs["system"] == "Windows" else "sudo reboot", verbose_output=True, description="", strict_stderr=False, strict_return_code=False)
     def send_ssh_key(self) -> Response:
-        self.copy_from_here(source_path=Path("~/.ssh/id_rsa.pub"), target_path=None, compress_with_zip=False, recursive=False, overwrite_existing=False)
-        if self.get_remote_machine() != "Windows":
+        self.copy_from_here(source_path="~/.ssh/id_rsa.pub", target_rel2home=None, compress_with_zip=False, recursive=False, overwrite_existing=False)
+        if self.remote_specs["system"] != "Windows":
             raise RuntimeError("send_ssh_key is only supported for Windows remote machines")
         code_url = "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/setup_windows/openssh-server_add-sshkey.ps1"
         import urllib.request
@@ -162,17 +140,17 @@ class SSH:
         return self.run_shell(command=code, verbose_output=True, description="", strict_stderr=False, strict_return_code=False)
 
     def get_remote_repr(self, add_machine: bool = False) -> str:
-        return f"{self.username}@{self.hostname}:{self.port}" + (f" [{self.get_remote_machine()}][{self.get_remote_distro()}]" if add_machine else "")
+        return f"{self.username}@{self.hostname}:{self.port}" + (f" [{self.remote_specs['system']}][{self.remote_specs['distro']}]" if add_machine else "")
     def get_local_repr(self, add_machine: bool = False) -> str:
         import getpass
-        return f"{getpass.getuser()}@{self.platform.node()}" + (f" [{self.platform.system()}][{self.get_local_distro()}]" if add_machine else "")
+        return f"{getpass.getuser()}@{platform.node()}" + (f" [{platform.system()}][{self.local_specs['distro']}]" if add_machine else "")
     def get_ssh_conn_str(self, command: str) -> str:
         return "ssh " + (f" -i {self.ssh_key_path}" if self.ssh_key_path else "") + self.get_remote_repr(add_machine=False).replace(":", " -p ") + (f" -t {command} " if command != "" else " ")
     def __repr__(self) -> str:
         return f"local {self.get_local_repr(add_machine=True)} >>> SSH TO >>> remote {self.get_remote_repr(add_machine=True)}"
 
     def run_locally(self, command: str) -> Response:
-        print(f"""💻 [LOCAL EXECUTION] Running command on node: {self.platform.node()} Command: {command}""")
+        print(f"""💻 [LOCAL EXECUTION] Running command on node: {self.local_specs['system']} Command: {command}""")
         res = Response(cmd=command)
         res.output.returncode = os.system(command)
         return res
@@ -184,15 +162,14 @@ class SSH:
             res.print()
         else:
             res.capture().print_if_unsuccessful(desc=description, strict_err=strict_stderr, strict_returncode=strict_return_code, assert_success=False)
-        self.terminal_responses.append(res)
+        # self.terminal_responses.append(res)
         return res
     def run_py(self, python_code: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str],
                description: str, verbose_output: bool, strict_stderr: bool, strict_return_code: bool) -> Response:
-        from machineconfig.utils.accessories import randstr
         py_path = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/runpy_{randstr()}.py")
         py_path.parent.mkdir(parents=True, exist_ok=True)
         py_path.write_text(python_code, encoding="utf-8")
-        self.copy_from_here(source_path=py_path, target_path=None, compress_with_zip=False, recursive=False, overwrite_existing=False)
+        self.copy_from_here(source_path=str(py_path), target_rel2home=None, compress_with_zip=False, recursive=False, overwrite_existing=False)
         if uv_with is not None and len(uv_with) > 0:
             with_clause = " --with " + '"' + ",".join(uv_with) + '"'
         else:
@@ -205,7 +182,6 @@ class SSH:
         return self.run_shell(command=uv_cmd, verbose_output=verbose_output, description=description or f"run_py on {self.get_remote_repr(add_machine=False)}", strict_stderr=strict_stderr, strict_return_code=strict_return_code)
 
     def run_py_func(self, func: Callable[..., Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> Response:
-        from machineconfig.utils.meta import lambda_to_python_script
         command = lambda_to_python_script(lmb=func, in_global=True)
         return self.run_py(python_code=command, uv_with=uv_with, uv_project_dir=uv_project_dir,
                            description=f"run_py_func {func.__name__} on {self.get_remote_repr(add_machine=False)}",
@@ -218,77 +194,45 @@ class SSH:
         local_path.parent.mkdir(parents=True, exist_ok=True)
         self.sftp.get(remotepath=remote_path, localpath=str(local_path))
 
-    def _create_remote_target_dir(self, target_path: Union[str, Path], overwrite_existing: bool) -> str:
+    def create_dir(self, path_rel2home: str, overwrite_existing: bool) -> None:
         """Helper to create a directory on remote machine and return its path."""
-        def create_target_dir(target_dir_path: str, overwrite: bool, json_output_path: str) -> str:
+        def create_target_dir(target_rel2home: str, overwrite: bool) -> None:
             from pathlib import Path
             import shutil
-            import json
-            directory_path = Path(target_dir_path).expanduser()
+            directory_path = Path(target_rel2home).expanduser()
             if overwrite and directory_path.exists():
                 if directory_path.is_dir():
                     shutil.rmtree(directory_path)
                 else:
                     directory_path.unlink()
             directory_path.parent.mkdir(parents=True, exist_ok=True)
-            result_path_posix = directory_path.as_posix()
-            json_result_path = Path(json_output_path)
-            json_result_path.parent.mkdir(parents=True, exist_ok=True)
-            json_result_path.write_text(json.dumps(result_path_posix, indent=2), encoding="utf-8")
-            print(json_result_path.as_posix())
-            return result_path_posix
-        from machineconfig.utils.meta import lambda_to_python_script
-        from machineconfig.utils.accessories import randstr
-        remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
-        # command = function_to_script(func=create_target_dir, call_with_kwargs={"target_dir_path": Path(target_path).as_posix(), "overwrite": overwrite_existing, "json_output_path": remote_json_output})
-        command = lambda_to_python_script(lmb=lambda: create_target_dir(target_dir_path=str(target_path), overwrite=overwrite_existing, json_output_path=remote_json_output), in_global=True)
-        response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,
-                               description=f"Creating target directory `{Path(target_path).parent.as_posix()}` @ {self.get_remote_repr(add_machine=False)}",
-                               verbose_output=False, strict_stderr=False, strict_return_code=False)
-        remote_json_path = response.op.strip()
-        if not remote_json_path:
-            raise RuntimeError(f"Failed to create target directory {target_path} - no response from remote")
-        from machineconfig.utils.accessories import randstr
-        local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
-        self._simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
-        import json
-        try:
-            result = json.loads(local_json.read_text(encoding="utf-8"))
-        except (json.JSONDecodeError, FileNotFoundError) as err:
-            raise RuntimeError(f"Failed to create target directory {target_path} - invalid JSON response: {err}") from err
-        finally:
-            if local_json.exists():
-                local_json.unlink()
-        assert isinstance(result, str), f"Failed to create target directory {target_path} on remote"
-        return result
-
+            return
+        command = lambda_to_python_script(lmb=lambda: create_target_dir(target_rel2home=path_rel2home, overwrite=overwrite_existing), in_global=True)
+        tmp_py_file = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/create_target_dir_{randstr()}.py")
+        tmp_py_file.parent.mkdir(parents=True, exist_ok=True)
+        tmp_py_file.write_text(command, encoding="utf-8")
+        self.copy_from_here(source_path=str(tmp_py_file), target_rel2home=None, compress_with_zip=False, recursive=False, overwrite_existing=True)
+        self.run_shell(command=f"""{UV_RUN_CMD} python {tmp_py_file.as_posix()}""", verbose_output=False, description=f"Creating target dir {path_rel2home}", strict_stderr=True, strict_return_code=True)
 
-    def copy_from_here(self, source_path: Union[str, Path], target_path: Optional[Union[str, Path]], compress_with_zip: bool, recursive: bool, overwrite_existing: bool) -> Path:
-        if self.sftp is None:
-            raise RuntimeError(f"SFTP connection not available for {self.hostname}. Cannot transfer files.")
-        
+    def copy_from_here(self, source_path: str, target_rel2home: Optional[str], compress_with_zip: bool, recursive: bool, overwrite_existing: bool) -> None:
+        if self.sftp is None: raise RuntimeError(f"SFTP connection not available for {self.hostname}. Cannot transfer files.")
         source_obj = Path(source_path).expanduser().absolute()
-        if not source_obj.exists():
-            raise RuntimeError(f"SSH Error: source `{source_obj}` does not exist!")
-        
-        if target_path is None:
-            try:
-                target_path_relative = source_obj.relative_to(Path.home())
-                target_path = Path("~") / target_path_relative
+        if not source_obj.exists(): raise RuntimeError(f"SSH Error: source `{source_obj}` does not exist!")
+        if target_rel2home is None:
+            try: target_rel2home = str(source_obj.relative_to(Path.home()))
             except ValueError:
                 raise RuntimeError(f"If target is not specified, source must be relative to home directory, but got: {source_obj}")
-        
         if not compress_with_zip and source_obj.is_dir():
             if not recursive:
                 raise RuntimeError(f"SSH Error: source `{source_obj}` is a directory! Set `recursive=True` for recursive sending or `compress_with_zip=True` to zip it first.")            
             file_paths_to_upload: list[Path] = [file_path for file_path in source_obj.rglob("*") if file_path.is_file()]
-            remote_root = self._create_remote_target_dir(target_path=target_path, overwrite_existing=overwrite_existing)
+            # self.create_dir(path_rel2home=target_rel2home, overwrite_existing=overwrite_existing)
             for idx, file_path in enumerate(file_paths_to_upload):
                 print(f"   {idx + 1:03d}. {file_path}")
             for file_path in file_paths_to_upload:
-                remote_file_target = Path(remote_root).joinpath(file_path.relative_to(source_obj))
-                self.copy_from_here(source_path=file_path, target_path=remote_file_target, compress_with_zip=False, recursive=False, overwrite_existing=overwrite_existing)
-            return Path(remote_root)
+                remote_file_target = Path(target_rel2home).joinpath(file_path.relative_to(source_obj))
+                self.copy_from_here(source_path=str(file_path), target_rel2home=str(remote_file_target), compress_with_zip=False, recursive=False, overwrite_existing=overwrite_existing)
+            return None
         if compress_with_zip:
             print("🗜️ ZIPPING ...")
             import shutil
@@ -298,16 +242,14 @@ class SSH:
             else:
                 shutil.make_archive(str(zip_path), "zip", source_obj.parent, source_obj.name)
             source_obj = Path(str(zip_path) + ".zip")
-            if not str(target_path).endswith(".zip"):
-                target_path = Path(str(target_path) + ".zip")
-        remotepath_str = self._create_remote_target_dir(target_path=target_path, overwrite_existing=overwrite_existing)
-        remotepath = Path(remotepath_str)        
-        print(f"""📤 [SFTP UPLOAD] Sending file: {repr(source_obj)}  ==>  Remote Path: {remotepath.as_posix()}""")
+            if not target_rel2home.endswith(".zip"): target_rel2home = target_rel2home + ".zip"
+        # remotepath_str = self.create_dir(target_path=target_path, overwrite_existing=overwrite_existing)
+        print(f"""📤 [SFTP UPLOAD] Sending file: {repr(source_obj)}  ==>  Remote Path: {target_rel2home}""")
         try:
             with self.tqdm_wrap(ascii=True, unit="b", unit_scale=True) as pbar:
                 if self.sftp is None:  # type: ignore[unreachable]
                     raise RuntimeError(f"SFTP connection lost for {self.hostname}")
-                self.sftp.put(localpath=str(source_obj), remotepath=remotepath.as_posix(), callback=pbar.view_bar)  # type: ignore
+                self.sftp.put(localpath=str(source_obj), remotepath=str(Path(self.remote_specs["home_dir"]).joinpath(target_rel2home)), callback=pbar.view_bar)
         except Exception:
             if compress_with_zip and source_obj.exists() and str(source_obj).endswith("_archive.zip"):
                 source_obj.unlink()
@@ -325,11 +267,14 @@ class SSH:
                 with zipfile.ZipFile(archive_path, "r") as archive_handle:
                     archive_handle.extractall(extraction_directory)
                 archive_path.unlink()
-            from machineconfig.utils.meta import lambda_to_python_script
-            command = lambda_to_python_script(lmb=lambda: unzip_archive(zip_file_path=remotepath.as_posix(), overwrite_flag=overwrite_existing), in_global=True)
-            _resp = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description=f"UNZIPPING {remotepath.as_posix()}", verbose_output=False, strict_stderr=True, strict_return_code=True)
+            command = lambda_to_python_script(lmb=lambda: unzip_archive(zip_file_path=str(Path(self.remote_specs["home_dir"]).joinpath(target_rel2home)), overwrite_flag=overwrite_existing), in_global=True)
+            tmp_py_file = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/create_target_dir_{randstr()}.py")
+            tmp_py_file.parent.mkdir(parents=True, exist_ok=True)
+            tmp_py_file.write_text(command, encoding="utf-8")
+            transferred_py_file = self.copy_from_here(source_path=str(tmp_py_file), target_rel2home=None, compress_with_zip=True, recursive=False, overwrite_existing=True)
+            self.run_shell(command=f"""{UV_RUN_CMD} python {transferred_py_file}""", verbose_output=False, description=f"UNZIPPING {target_rel2home}", strict_stderr=True, strict_return_code=True)
             source_obj.unlink()
-        return source_obj
+        return None
 
     def _check_remote_is_dir(self, source_path: Union[str, Path]) -> bool:
         """Helper to check if a remote path is a directory."""
@@ -342,16 +287,13 @@ class SSH:
             json_result_path.write_text(json.dumps(is_directory, indent=2), encoding="utf-8")
             print(json_result_path.as_posix())
             return is_directory
-        
-        from machineconfig.utils.meta import lambda_to_python_script
-        from machineconfig.utils.accessories import randstr
         remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
         command = lambda_to_python_script(lmb=lambda: check_is_dir(path_to_check=str(source_path), json_output_path=remote_json_output), in_global=True)
         response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description=f"Check if source `{source_path}` is a dir", verbose_output=False, strict_stderr=False, strict_return_code=False)
         remote_json_path = response.op.strip()
         if not remote_json_path:
             raise RuntimeError(f"Failed to check if {source_path} is directory - no response from remote")
-        from machineconfig.utils.accessories import randstr
+        
         local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
         self._simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
         import json
@@ -377,15 +319,15 @@ class SSH:
             print(json_result_path.as_posix())
             return expanded_path_posix
         
-        from machineconfig.utils.meta import lambda_to_python_script
-        from machineconfig.utils.accessories import randstr
+        
+        
         remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
         command = lambda_to_python_script(lmb=lambda: expand_source(path_to_expand=str(source_path), json_output_path=remote_json_output), in_global=True)
         response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Resolving source path by expanding user", verbose_output=False, strict_stderr=False, strict_return_code=False)
         remote_json_path = response.op.strip()
         if not remote_json_path:
             raise RuntimeError(f"Could not resolve source path {source_path} - no response from remote")
-        from machineconfig.utils.accessories import randstr
+        
         local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
         self._simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
         import json
@@ -426,15 +368,15 @@ class SSH:
                     print(json_result_path.as_posix())
                     return file_paths_list
                 
-                from machineconfig.utils.meta import lambda_to_python_script
-                from machineconfig.utils.accessories import randstr
+                
+                
                 remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
                 command = lambda_to_python_script(lmb=lambda: search_files(directory_path=expanded_source, json_output_path=remote_json_output), in_global=True)
                 response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Searching for files in source", verbose_output=False, strict_stderr=False, strict_return_code=False)
                 remote_json_path = response.op.strip()
                 if not remote_json_path:
                     raise RuntimeError(f"Could not resolve source path {source} - no response from remote")
-                from machineconfig.utils.accessories import randstr
+                
                 local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
                 self._simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
                 import json
@@ -464,15 +406,15 @@ class SSH:
                         except ValueError:
                             raise RuntimeError(f"Source path must be relative to home directory: {source_absolute_path}")
                     
-                    from machineconfig.utils.meta import lambda_to_python_script
-                    from machineconfig.utils.accessories import randstr
+                    
+                    
                     remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
                     command = lambda_to_python_script(lmb=lambda: collapse_to_home_dir(absolute_path=expanded_source, json_output_path=remote_json_output), in_global=True)
                     response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
                     remote_json_path_dir = response.op.strip()
                     if not remote_json_path_dir:
                         raise RuntimeError("Could not resolve target path - no response from remote")
-                    from machineconfig.utils.accessories import randstr
+                    
                     local_json_dir = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
                     self._simple_sftp_get(remote_path=remote_json_path_dir, local_path=local_json_dir)
                     import json
@@ -516,15 +458,15 @@ class SSH:
                 print(json_result_path.as_posix())
                 return zip_file_path
             
-            from machineconfig.utils.meta import lambda_to_python_script
-            from machineconfig.utils.accessories import randstr
+            
+            
             remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
             command = lambda_to_python_script(lmb=lambda: zip_source(path_to_zip=expanded_source, json_output_path=remote_json_output), in_global=True)
             response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description=f"Zipping source file {source}", verbose_output=False, strict_stderr=False, strict_return_code=False)
             remote_json_path = response.op.strip()
             if not remote_json_path:
                 raise RuntimeError(f"Could not zip {source} - no response from remote")
-            from machineconfig.utils.accessories import randstr
+            
             local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
             self._simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
             import json
@@ -555,15 +497,15 @@ class SSH:
                 except ValueError:
                     raise RuntimeError(f"Source path must be relative to home directory: {source_absolute_path}")
             
-            from machineconfig.utils.meta import lambda_to_python_script
-            from machineconfig.utils.accessories import randstr
+            
+            
             remote_json_output = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/return_{randstr()}.json").as_posix()
             command = lambda_to_python_script(lmb=lambda: collapse_to_home(absolute_path=expanded_source, json_output_path=remote_json_output), in_global=True)
             response = self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Finding default target via relative source path", verbose_output=False, strict_stderr=False, strict_return_code=False)
             remote_json_path = response.op.strip()
             if not remote_json_path:
                 raise RuntimeError("Could not resolve target path - no response from remote")
-            from machineconfig.utils.accessories import randstr
+            
             local_json = Path.home().joinpath(f"{DEFAULT_PICKLE_SUBDIR}/local_{randstr()}.json")
             self._simple_sftp_get(remote_path=remote_json_path, local_path=local_json)
             import json
@@ -613,10 +555,12 @@ class SSH:
                     else:
                         file_or_dir_path.unlink()
             
-            from machineconfig.utils.meta import lambda_to_python_script
+            
             command = lambda_to_python_script(lmb=lambda: delete_temp_zip(path_to_delete=expanded_source), in_global=True)
             self.run_py(python_code=command, uv_with=[MACHINECONFIG_VERSION], uv_project_dir=None,  description="Cleaning temp zip files @ remote.", verbose_output=False, strict_stderr=True, strict_return_code=True)
         
         print("\n")
         return target_obj
 
+if __name__ == "__main__":
+    ssh = SSH(host="p51s", username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=False)

machineconfig/utils/terminal.py

@@ -35,7 +35,8 @@ class Response:
     def __call__(self, *args: Any, **kwargs: Any) -> Optional[str]:
         _ = args, kwargs
         return self.op.rstrip() if type(self.op) is str else None
-
+    def __repr__(self) -> str:
+        return f"Response({self.input=}, {self.output=}, {self.desc=}, {self.op=}, {self.ip=}, {self.err=}, {self.returncode=})"
     @property
     def op(self) -> str:
         return self.output.stdout
@@ -97,115 +98,3 @@ class Response:
         txt = tmp1 + Text(str(self.input), style="white") + tmp2 + Text("\n".join(list_str), style="white")
         con.print(Panel(txt, title=f"🖥️  {self.desc}", subtitle=f"📋 {desc}", width=150, style="bold cyan on black"))
         return self
-
-
-'''
-class Terminal:
-    def __init__(self, stdout: Optional[int] = subprocess.PIPE, stderr: Optional[int] = subprocess.PIPE, stdin: Optional[int] = subprocess.PIPE, elevated: bool = False):
-        self.machine: str = platform.system()
-        self.elevated: bool = elevated
-        self.stdout = stdout
-        self.stderr = stderr
-        self.stdin = stdin
-
-    # def set_std_system(self): self.stdout = sys.stdout; self.stderr = sys.stderr; self.stdin = sys.stdin
-    # def set_std_pipe(self):
-    #     self.stdout = subprocess.PIPE
-    #     self.stderr = subprocess.PIPE
-    #     self.stdin = subprocess.PIPE
-
-    # def set_std_null(self):
-    #     self.stdout, self.stderr, self.stdin = subprocess.DEVNULL, subprocess.DEVNULL, subprocess.DEVNULL  # Equivalent to `echo 'foo' &> /dev/null`
-
-    def run(self, *cmds: str, shell: Optional[SHELLS] = "default", check: bool = False, ip: Optional[str] = None) -> Response:  # Runs SYSTEM commands like subprocess.run
-        """Blocking operation. Thus, if you start a shell via this method, it will run in the main and won't stop until you exit manually IF stdin is set to sys.stdin, otherwise it will run and close quickly. Other combinations of stdin, stdout can lead to funny behaviour like no output but accept input or opposite.
-        * This method is short for: res = subprocess.run("powershell command", capture_output=True, shell=True, text=True) and unlike os.system(cmd), subprocess.run(cmd) gives much more control over the output and input.
-        * `shell=True` loads up the profile of the shell called so more specific commands can be run. Importantly, on Windows, the `start` command becomes availalbe and new windows can be launched.
-        * `capture_output` prevents the stdout to redirect to the stdout of the script automatically, instead it will be stored in the Response object returned. # `capture_output=True` same as `stdout=subprocess.PIPE, stderr=subprocess.PIPE`"""
-        my_list = list(
-            cmds
-        )  # `subprocess.Popen` (process open) is the most general command. Used here to create asynchronous job. `subprocess.run` is a thin wrapper around Popen that makes it wait until it finishes the task. `suprocess.call` is an archaic command for pre-Python-3.5.
-        if self.machine == "Windows" and shell in {"powershell", "pwsh"}:
-            my_list = [shell, "-Command"] + my_list  # alternatively, one can run "cmd"
-        if self.elevated is False or self.is_user_admin():
-            resp: subprocess.CompletedProcess[str] = subprocess.run(my_list, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=check, input=ip)
-        else:
-            resp = __import__("ctypes").windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
-    return Response.from_completed_process(resp)
-    @staticmethod
-    def is_user_admin() -> bool:  # adopted from: https://stackoverflow.com/questions/19672352/how-to-run-script-with-elevated-privilege-on-windows"""
-        if os.name == "nt":
-            try:
-                return __import__("ctypes").windll.shell32.IsUserAnAdmin()
-            except Exception:
-                import traceback
-
-                traceback.print_exc()
-                print("Admin check failed, assuming not an admin.")
-                return False
-        else:
-            return os.getuid() == 0  # Check for root on Posix
-'''
-
-    # def run_shell_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")
-    #     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)
-    #             full_command: Union[list[str], str] = [start_cmd, str(script_file)]  # shell=True will cause this to be a string anyway (with space separation)
-    #         else:
-    #             start_cmd = "bash"
-    #             full_command = f"{start_cmd} {script_file}"  # full_command = [start_cmd, str(script_file)]
-    #     else:
-    #         full_command = f"{shell} {script_file}"  # full_command = [shell, str(tmp_file)]
-    #     if verbose:
-    #         desc = "Script to be executed:"
-    #         if platform.system() == "Windows":
-    #             lexer = "powershell"
-    #         elif platform.system() == "Linux":
-    #             lexer = "sh"
-    #         elif platform.system() == "Darwin":
-    #             lexer = "sh"  # macOS uses similar shell to Linux
-    #         else:
-    #             raise NotImplementedError(f"Platform {platform.system()} not supported.")
-    #         from rich.console import Console
-    #         from rich.panel import Panel
-    #         from rich.syntax import Syntax
-    #         import rich.progress as pb
-
-    #         console = Console()
-    #         console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 {desc}"), style="bold red")
-    #         with pb.Progress(transient=True) as progress:
-    #             _task = progress.add_task(f"Running Script @ {script_file}", total=None)
-    #             resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
-    #     else:
-    #         resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
-    #     return Response.from_completed_process(resp)
-
-#     def run_py(self, script: str, wdir: OPLike = None, interactive: bool = True, ipython: bool = True, shell: Optional[str] = None, terminal: str = "", new_window: bool = True, header: bool = True):  # async run, since sync run is meaningless.
-#         script = (Terminal.get_header(wdir=wdir, toolbox=True) if header else "") + script + ("\nDisplayData.set_pandas_auto_width()\n" if terminal in {"wt", "powershell", "pwsh"} else "")
-#         py_script = PathExtended.tmpfile(name="tmp_python_script", suffix=".py", folder="tmp_scripts/terminal")
-#         py_script.write_text(f"""print(r'''{script}''')""" + "\n" + script)
-#         print(f"""🚀 [ASYNC PYTHON SCRIPT] Script URI:
-#    {py_script.absolute().as_uri()}""")
-#         print("Script to be executed asyncronously: ", py_script.absolute().as_uri())
-#         shell_script = f"""
-# {f"cd {wdir}" if wdir is not None else ""}
-# {"ipython" if ipython else "python"} {"-i" if interactive else ""} {py_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 ""
-#         os.system(f"{window} {terminal} {shell} {shell_script}")
-
-    #     @staticmethod
-    #     def run_as_admin(file: PLike, params: Any, wait: bool = False):
-    #         proce_info = install_n_import(library="win32com", package="pywin32", fromlist=["shell.shell.ShellExecuteEx"]).shell.shell.ShellExecuteEx(lpVerb='runas', lpFile=file, lpParameters=params)
-    #         # TODO update PATH for this to take effect immediately.
-    #         if wait: time.sleep(1)
-    #         return proce_info

{machineconfig-6.61.dist-info → machineconfig-6.62.dist-info}/METADATA

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

{machineconfig-6.61.dist-info → machineconfig-6.62.dist-info}/RECORD

@@ -127,10 +127,10 @@ machineconfig/scripts/python/devops.py,sha256=Lv4d-UlyOREj4VTcu_pxswYo54Mawe3XGe
 machineconfig/scripts/python/devops_navigator.py,sha256=5Cm384D4S8_GsvMzTwr0C16D0ktf8_5Mk5bEJncwDO8,237
 machineconfig/scripts/python/entry.py,sha256=liCf186Msa6R-EjcQ0I6K80Km7Wi8qckJB6rXIHeHU0,2488
 machineconfig/scripts/python/fire_jobs.py,sha256=My7sFn1R2vh21uIHGfNppgX99WTEitCFgJ1MSasBUOQ,13597
-machineconfig/scripts/python/ftpx.py,sha256=vm4QNJA0z1Vu-85wFliGNoDHMZZ-Yy8zQACL6x7Wo6U,9760
+machineconfig/scripts/python/ftpx.py,sha256=A13hL_tDYfcsaK9PkshK-0lrUS6KPhPCtwqWtLSo6IM,9764
 machineconfig/scripts/python/interactive.py,sha256=zt3g6nGKR_Y5A57UnR4Y5-JpLzrpnCOSaqU1bnaikK0,11666
 machineconfig/scripts/python/sessions.py,sha256=UERxO472EDtN7nKHEULbn6G3S5PJIpsDG9Gq3TlByqI,9823
-machineconfig/scripts/python/utils.py,sha256=rlrTomPlvhzaMf2UWzVeyO_kTwNWFj1iASXIF2g9cx8,710
+machineconfig/scripts/python/utils.py,sha256=c9HsKG40i5ggwqKuS3O-LCScuFpmxMVKqWpsFHx2dJc,934
 machineconfig/scripts/python/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 machineconfig/scripts/python/ai/generate_files.py,sha256=VfjKdwgF8O6E4oiRtfWNliibLmmwGe7f9ld6wpOsXTw,14498
 machineconfig/scripts/python/ai/initai.py,sha256=9SZtWOcRuwk8ZU3wHOfPzjInERD79ZTYFY8tVACgza4,2260
@@ -187,7 +187,7 @@ machineconfig/scripts/python/helpers_devops/cli_repos.py,sha256=Xwkv1adqHZvTfRSP
 machineconfig/scripts/python/helpers_devops/cli_self.py,sha256=0-R7YDIQS2cH2n9C7lShFoBRwbytQz3BCuHGQrus7FU,6225
 machineconfig/scripts/python/helpers_devops/cli_share_server.py,sha256=q9pFJ6AxPuygMr3onMNOKEuuQHbVE_6Qoyo7xRT5FX0,4196
 machineconfig/scripts/python/helpers_devops/cli_terminal.py,sha256=k_PzXaiGyE0vXr0Ii1XcJz2A7UvyPJrR31TRWt4RKRI,6019
-machineconfig/scripts/python/helpers_devops/cli_utils.py,sha256=sCYKR6bXzr6DgVnQrCa_pjKdc7tOOY3T8h1A41UURBU,5066
+machineconfig/scripts/python/helpers_devops/cli_utils.py,sha256=jN_GeZyy-9tAJoBoASsmn9_tI7ZgkgXp7Ijgi2x_ssw,6053
 machineconfig/scripts/python/helpers_devops/devops_backup_retrieve.py,sha256=Dn8luB6QJzxKiiFSC-NMqiYddWZoca3A8eOjMYZDzTc,5598
 machineconfig/scripts/python/helpers_devops/devops_status.py,sha256=PJVPhfhXq8der6Xd-_fjZfnizfM-RGfJApkRGhGBmNo,20525
 machineconfig/scripts/python/helpers_devops/devops_update_repos.py,sha256=kSln8_-Wn7Qu0NaKdt-QTN_bBVyTIAWHH8xVYKK-vCM,10133
@@ -407,8 +407,8 @@ machineconfig/utils/procs.py,sha256=YPA_vEYQGwPd_o_Lc6nOTBo5BrB1tSs8PJ42XiGpenM,
 machineconfig/utils/scheduler.py,sha256=44CASABJg3epccxhAwv2CX7TVgZh6zVy3K4vqHKTuf4,14228
 machineconfig/utils/scheduling.py,sha256=6x5zLA7sY5gohrEtN6zGrXIqNFasMoyBfwLcOjrjiME,11109
 machineconfig/utils/source_of_truth.py,sha256=ZAnCRltiM07ig--P6g9_6nEAvNFC4X4ERFTVcvpIYsE,764
-machineconfig/utils/ssh.py,sha256=R2yOmz1HXwPpW1XlhzOZbneu3xejjoUoAIT1QnQ-ecA,39382
-machineconfig/utils/terminal.py,sha256=IlmOByfQG-vjhaFFxxzU5rWzP5_qUzmalRfuey3PAmc,11801
+machineconfig/utils/ssh.py,sha256=lTvhFr9A2yNe6MbtcBMSl_d3wjeIfrkMUrREgMcZ7zk,35791
+machineconfig/utils/terminal.py,sha256=VDgsjTjBmMGgZN0YIc0pJ8YksLDrBtiXON1EThy7_is,4264
 machineconfig/utils/tst.py,sha256=6u1GI49NdcpxH2BYGAusNfY5q9G_ytCGVzFM5b6HYpM,674
 machineconfig/utils/upgrade_packages.py,sha256=mSFyKvB3JhHte_x1dtmEgrJZCAXgTUQoaJUSx1OXQ3Y,4145
 machineconfig/utils/ve.py,sha256=L-6PBXnQGXThiwWgheJMQoisAZOZA6SVCbGw2J-GFnI,2414
@@ -436,8 +436,8 @@ machineconfig/utils/schemas/installer/installer_types.py,sha256=QClRY61QaduBPJoS
 machineconfig/utils/schemas/layouts/layout_types.py,sha256=TcqlZdGVoH8htG5fHn1KWXhRdPueAcoyApppZsPAPto,2020
 machineconfig/utils/schemas/repos/repos_types.py,sha256=ECVr-3IVIo8yjmYmVXX2mnDDN1SLSwvQIhx4KDDQHBQ,405
 machineconfig/utils/ssh_utils/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-machineconfig-6.61.dist-info/METADATA,sha256=W4hUI9UB2KnHVsMoV1OKaTStImXnD7iWzZ2tIkJGucs,2928
-machineconfig-6.61.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-machineconfig-6.61.dist-info/entry_points.txt,sha256=NTW7hbUlpt5Vx9DdQrONLkYMCuBXpvYh1dt0AtlGxeI,466
-machineconfig-6.61.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
-machineconfig-6.61.dist-info/RECORD,,
+machineconfig-6.62.dist-info/METADATA,sha256=VjucUVQDh7RyqFcRHJooUz1f528jVpPQ6_ilmkmPrVo,2928
+machineconfig-6.62.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+machineconfig-6.62.dist-info/entry_points.txt,sha256=NTW7hbUlpt5Vx9DdQrONLkYMCuBXpvYh1dt0AtlGxeI,466
+machineconfig-6.62.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
+machineconfig-6.62.dist-info/RECORD,,