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

machineconfig/utils/path_extended.py

@@ -1,93 +1,60 @@
 from machineconfig.utils.accessories import randstr
+from machineconfig.utils.io import decrypt, encrypt
 
 from datetime import datetime
 import time
 from pathlib import Path
 import sys
 import subprocess
+import os
 from platform import system
 from typing import Any, Optional, Union, Callable, TypeAlias, Literal
 
 
+
 OPLike: TypeAlias = Union[str, "PathExtended", Path, None]
 PLike: TypeAlias = Union[str, "PathExtended", Path]
 FILE_MODE: TypeAlias = Literal["r", "w", "x", "a"]
 SHUTIL_FORMATS: TypeAlias = Literal["zip", "tar", "gztar", "bztar", "xztar"]
+DECOMPRESS_SUPPORTED_FORMATS = [".tar.gz", ".tgz", ".tar", ".gz", ".tar.bz", ".tbz", ".tar.xz", ".zip", ".7z"]
 
 
-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()))
-
-
-def encrypt(msg: bytes, key: Optional[bytes] = None, pwd: Optional[str] = None, salted: bool = True, iteration: Optional[int] = None, gen_key: bool = False) -> bytes:
-    import base64
-    from cryptography.fernet import Fernet
-
-    salt, iteration = None, None
-    if pwd is not None:  # generate it from password
-        assert (key is None) and (type(pwd) is str), "❌ You can either pass key or pwd, or none of them, but not both."
-        import secrets
-
-        iteration = iteration or secrets.randbelow(exclusive_upper_bound=1_000_000)
-        salt = secrets.token_bytes(nbytes=16) if salted else None
-        key_resolved = pwd2key(password=pwd, salt=salt, iterations=iteration)
-    elif key is None:
-        if gen_key:
-            key_resolved = Fernet.generate_key()
-            Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").write_bytes(key_resolved)
-        else:
-            try:
-                key_resolved = Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").read_bytes()
-                print(f"⚠️ Using key from: {Path.home().joinpath('dotfiles/creds/data/encrypted_files_key.bytes')}")
-            except FileNotFoundError as err:
-                print("\n" * 3, "~" * 50, """Consider Loading up your dotfiles or pass `gen_key=True` to make and save one.""", "~" * 50, "\n" * 3)
-                raise FileNotFoundError(err) from err
-    elif isinstance(key, (str, PathExtended, Path)):
-        key_resolved = Path(key).read_bytes()  # a path to a key file was passed, read it:
-    elif type(key) is bytes:
-        key_resolved = key  # key passed explicitly
-    else:
-        raise TypeError("❌ Key must be either a path, bytes object or None.")
-    code = Fernet(key=key_resolved).encrypt(msg)
-    if pwd is not None and salt is not None and iteration is not None:
-        return base64.urlsafe_b64encode(b"%b%b%b" % (salt, iteration.to_bytes(4, "big"), base64.urlsafe_b64decode(code)))
-    return code
-
-
-def decrypt(token: bytes, key: Optional[bytes] = None, pwd: Optional[str] = None, salted: bool = True) -> bytes:
-    import base64
-
-    if pwd is not None:
-        assert key is None, "❌ You can either pass key or pwd, or none of them, but not both."
-        if salted:
-            decoded = base64.urlsafe_b64decode(token)
-            salt, iterations, token = decoded[:16], decoded[16:20], base64.urlsafe_b64encode(decoded[20:])
-            key_resolved = pwd2key(password=pwd, salt=salt, iterations=int.from_bytes(bytes=iterations, byteorder="big"))
-        else:
-            key_resolved = pwd2key(password=pwd)  # trailing `;` prevents IPython from caching the result.
-    elif type(key) is bytes:
-        assert pwd is None, "❌ You can either pass key or pwd, or none of them, but not both."
-        key_resolved = key  # passsed explicitly
-    elif key is None:
-        key_resolved = Path.home().joinpath("dotfiles/creds/data/encrypted_files_key.bytes").read_bytes()  # read from file
-    elif isinstance(key, (str, Path)):
-        key_resolved = Path(key).read_bytes()  # passed a path to a file containing kwy
-    else:
-        raise TypeError(f"❌ Key must be either str, P, Path, bytes or None. Recieved: {type(key)}")
-    from cryptography.fernet import Fernet
-
-    return Fernet(key=key_resolved).decrypt(token)
+def _is_user_admin() -> bool:
+    if os.name == "nt":
+        try:
+            return __import__("ctypes").windll.shell32.IsUserAnAdmin()
+        except Exception:  # noqa: BLE001
+            import traceback
+
+            traceback.print_exc()
+            print("Admin check failed, assuming not an admin.")
+            return False
+    return os.getuid() == 0
+
+
+def _run_shell_command(
+    command: str,
+    shell_name: str,
+    *,
+    stdout: Optional[int] = subprocess.PIPE,
+    stderr: Optional[int] = subprocess.PIPE,
+    stdin: Optional[int] = None,
+    check: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    if shell_name in {"powershell", "pwsh"} and sys.platform == "win32":
+        args: list[str] = [shell_name, "-Command", command]
+        return subprocess.run(args, check=check, text=True, stdout=stdout, stderr=stderr, stdin=stdin)
+    executable = "/bin/bash" if shell_name == "bash" and sys.platform != "win32" else None
+    return subprocess.run(
+        command,
+        check=check,
+        text=True,
+        stdout=stdout,
+        stderr=stderr,
+        stdin=stdin,
+        shell=True,
+        executable=executable,
+    )
 
 
 def validate_name(astring: str, replace: str = "_") -> str:
@@ -128,7 +95,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             print(f"🗑️ ❌ DELETED {repr(self)}.")
         return self
 
-    def move(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, rel2it: bool = False, overwrite: bool = False, verbose: bool = True, parents: bool = True, content: bool = False) -> "PathExtended":
+    def move(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, rel2it: bool = False, overwrite: bool = False, verbose: bool = True, parents: bool = True, content: bool = False) -> "PathExtended":  # type: ignore
         path = self._resolve_path(folder=folder, name=name, path=path, default_name=self.absolute().name, rel2it=rel2it)
         if parents:
             path.parent.mkdir(parents=True, exist_ok=True)
@@ -154,9 +121,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             print(f"🚚 MOVED {repr(self)} ==> {repr(path)}`")
         return path
 
-    def copy(
-        self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, content: bool = False, verbose: bool = True, append: Optional[str] = None, overwrite: bool = False, orig: bool = False
-    ) -> "PathExtended":  # tested %100  # TODO: replace `content` flag with ability to interpret "*" in resolve method.
+    def copy(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, content: bool = False, verbose: bool = True, append: Optional[str] = None, overwrite: bool = False, orig: bool = False) -> "PathExtended":  # type: ignore
         dest = self._resolve_path(folder=folder, name=name, path=path, default_name=self.name, rel2it=False)
         dest = dest.expanduser().resolve()
         dest.parent.mkdir(parents=True, exist_ok=True)
@@ -188,7 +153,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
     # ======================================= File Editing / Reading ===================================
     def download(self, folder: OPLike = None, name: Optional[str] = None, allow_redirects: bool = True, timeout: Optional[int] = None, params: Any = None) -> "PathExtended":
         import requests
-
         response = requests.get(self.as_url_str(), allow_redirects=allow_redirects, timeout=timeout, params=params)  # Alternative: from urllib import request; request.urlopen(url).read().decode('utf-8').
         assert response.status_code == 200, f"Download failed with status code {response.status_code}\n{response.text}"
         if name is not None:
@@ -392,9 +356,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             assert target_obj.exists(), f"Target path `{target}` (aka `{target_obj}`) doesn't exist. This will create a broken link."
         if overwrite and (self.is_symlink() or self.exists()):
             self.delete(sure=True, verbose=verbose)
-        from machineconfig.utils.terminal import Terminal
-
-        if system() == "Windows" and not Terminal.is_user_admin():  # you cannot create symlink without priviliages.
+        if system() == "Windows" and not _is_user_admin():  # you cannot create symlink without priviliages.
             import win32com.shell.shell  # type: ignore # pylint: disable=E0401
 
             _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)}')\"")
@@ -518,9 +480,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         **kwargs: Any,
     ) -> "PathExtended":
         path_resolved, slf = self._resolve_path(folder, name, path, self.name).expanduser().resolve(), self.expanduser().resolve()
-        # if use_7z:  # benefits over regular zip and encrypt: can handle very large files with low memory footprint
-        #     path_resolved = path_resolved + '.7z' if not path_resolved.suffix == '.7z' else path_resolved
-        #     with install_n_import("py7zr").SevenZipFile(file=path_resolved, mode=mode, password=pwd) as archive: archive.writeall(path=str(slf), arcname=None)
         arcname_obj = PathExtended(arcname or slf.name)
         if arcname_obj.name != slf.name:
             arcname_obj /= slf.name  # arcname has to start from somewhere and end with filename
@@ -593,15 +552,6 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         folder = folder if not content else folder.parent
         if slf.suffix == ".7z":
             raise NotImplementedError("I have not implemented this yet")
-            # if overwrite: P(folder).delete(sure=True)
-            # result = folder
-            # import py7zr
-            # with py7zr.SevenZipFile(file=slf, mode='r', password=pwd) as archive:
-            #     if pattern is not None:
-            #         import re
-            #         pat = re.compile(pattern)
-            #         archive.extract(path=folder, targets=[f for f in archive.getnames() if pat.match(f)])
-            #     else: archive.extractall(path=folder)
         else:
             if overwrite:
                 if not content:
@@ -736,19 +686,52 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         return ret
 
     def decompress(self, folder: OPLike = None, name: Optional[str] = None, path: OPLike = None, inplace: bool = False, orig: bool = False, verbose: bool = True) -> "PathExtended":
-        if ".tar.gz" in str(self) or ".tgz" in str(self):
+        if str(self).endswith(".tar.gz") or str(self).endswith(".tgz"):
             # res = self.ungz_untar(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
             return self.ungz(name=f"tmp_{randstr()}.tar", inplace=inplace).untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)  # this works for .tgz suffix as well as .tar.gz
-        elif ".gz" in str(self):
+        elif str(self).endswith(".tar"):
+            res = self.untar(folder=folder, name=name, path=path, inplace=inplace, orig=orig, verbose=verbose)
+        elif str(self).endswith(".gz"):
             res = self.ungz(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
-        elif ".tar.bz" in str(self) or "tbz" in str(self):
+        elif str(self).endswith(".tar.bz") or str(self).endswith(".tbz"):
             res = self.unbz(name=f"tmp_{randstr()}.tar", inplace=inplace)
             return res.untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)
-        elif ".tar.xz" in str(self):
+        elif str(self).endswith(".tar.xz"):
             # res = self.unxz_untar(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
             res = self.unxz(inplace=inplace).untar(folder=folder, name=name, path=path, inplace=True, orig=orig, verbose=verbose)
-        elif ".zip" in str(self):
+        elif str(self).endswith(".zip"):
             res = self.unzip(folder=folder, path=path, name=name, inplace=inplace, verbose=verbose, orig=orig)
+        elif str(self).endswith(".7z"):
+            def unzip_7z(archive_path: str, dest_dir: Optional[str] = None) -> Path:
+                """
+                Uncompresses a .7z archive to a directory and returns the Path to the extraction directory.
+
+                :param archive_path: path to the .7z archive file
+                :param dest_dir: optional path to directory to extract into; if None a temporary dir will be created
+                :return: pathlib.Path pointing to the destination directory where contents were extracted
+                :raises: FileNotFoundError if archive does not exist; py7zr.Bad7zFile or other error if extraction fails
+                """
+                import py7zr  # type: ignore
+                import tempfile
+                from pathlib import Path
+                archive_path_obj = Path(archive_path)
+                if not archive_path_obj.is_file():
+                    raise FileNotFoundError(f"Archive file not found: {archive_path_obj!r}")
+                if dest_dir is None:
+                    # create a temporary directory
+                    dest = Path(tempfile.mkdtemp(prefix=f"unzip7z_{archive_path_obj.stem}_"))
+                else:
+                    dest = Path(dest_dir)
+                    dest.mkdir(parents=True, exist_ok=True)
+                # Perform extraction
+                with py7zr.SevenZipFile(str(archive_path_obj), mode='r') as archive:
+                    archive.extractall(path=str(dest))
+                # Return the extraction directory path
+                return dest
+            from machineconfig.utils.code import run_lambda_function
+            destination_dir = str(self.expanduser().resolve()).replace(".7z", "")
+            run_lambda_function(lambda: unzip_7z(archive_path=str(self), dest_dir=destination_dir), uv_project_dir=None, uv_with=["py7zr"])
+            res = PathExtended(destination_dir)
         else:
             res = self
         return res
@@ -826,7 +809,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             path = self
         else:
             try:
-                path = self.rel2home()
+                path = PathExtended(self.expanduser().absolute().relative_to(Path.home()))
             except ValueError as ve:
                 if strict:
                     raise ve
@@ -861,6 +844,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         transfers: int = 10,
         root: Optional[str] = "myhome",
     ) -> "PathExtended":
+        _ = transfers
         to_del = []
         localpath = self.expanduser().absolute() if not self.exists() else self
         if zip:
@@ -873,22 +857,21 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
             rp = localpath.get_remote_path(root=root, os_specific=os_specific, rel2home=rel2home, strict=strict)  # if rel2home else (P(root) / localpath if root is not None else localpath)
         else:
             rp = PathExtended(remotepath)
-        rclone_cmd = f"""rclone copyto '{localpath.as_posix()}' '{cloud}:{rp.as_posix()}' {"--progress" if verbose else ""} --transfers={transfers}"""
-        from machineconfig.utils.terminal import Terminal
+        from rclone_python import rclone
+        print(f"⬆️ UPLOADING {repr(localpath)} TO {cloud}:{rp.as_posix()}`") if verbose else None
+        rclone.copyto(in_path=localpath.as_posix(), out_path=f"{cloud}:{rp.as_posix()}", )
 
-        if verbose:
-            print(f"{'⬆️' * 5} UPLOADING with `{rclone_cmd}`")
-        shell_to_use = "powershell" if sys.platform == "win32" else "bash"
-        res = Terminal(stdout=None if verbose else subprocess.PIPE).run(rclone_cmd, shell=shell_to_use).capture()
         _ = [item.delete(sure=True) for item in to_del]
-        assert res.is_successful(strict_err=False, strict_returcode=True), res.print(capture=False, desc="Cloud Storage Operation")
         if verbose:
             print(f"{'⬆️' * 5} UPLOAD COMPLETED.")
         if share:
             if verbose:
                 print("🔗 SHARING FILE")
             shell_to_use = "powershell" if sys.platform == "win32" else "bash"
-            res = Terminal().run(f"""rclone link '{cloud}:{rp.as_posix()}'""", shell=shell_to_use).capture()
+            command = f"rclone link '{cloud}:{rp.as_posix()}'"
+            completed = _run_shell_command(command, shell_to_use)
+            from machineconfig.utils.terminal import Response
+            res = Response.from_completed_process(completed).capture()
             tmp = res.op2path(strict_err=False, strict_returncode=False)
             if tmp is None:
                 res.print()
@@ -916,6 +899,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         overwrite: bool = True,
         merge: bool = False,
     ):
+        _ = verbose, transfers
         if remotepath is None:
             remotepath = self.get_remote_path(root=root, os_specific=os_specific, rel2home=rel2home, strict=strict)
             remotepath += ".zip" if unzip else ""
@@ -925,16 +909,11 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         localpath = self.expanduser().absolute()
         localpath += ".zip" if unzip else ""
         localpath += ".enc" if decrypt else ""
-        rclone_cmd = f"""rclone copyto '{cloud}:{remotepath.as_posix()}' '{localpath.as_posix()}' {"--progress" if verbose else ""} --transfers={transfers}"""
-        from machineconfig.utils.terminal import Terminal
-
-        if verbose:
-            print(f"{'⬇️' * 5} DOWNLOADING with `{rclone_cmd}`")
-        shell_to_use = "powershell" if sys.platform == "win32" else "bash"
-        res = Terminal(stdout=None if verbose else subprocess.PIPE).run(rclone_cmd, shell=shell_to_use)
-        success = res.is_successful(strict_err=False, strict_returcode=True)
-        if not success:
-            res.print(capture=False, desc="Cloud Storage Operation")
+        from rclone_python import rclone
+        try:
+            rclone.copyto(in_path=f"{cloud}:{remotepath.as_posix()}", out_path=localpath.as_posix(), )
+        except Exception as e:
+            print("to_cloud error", e)
             return None
         if decrypt:
             localpath = localpath.decrypt(key=key, pwd=pwd, inplace=True)
@@ -946,23 +925,34 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
         tmp_path_obj = self.expanduser().absolute()
         tmp_path_obj.parent.mkdir(parents=True, exist_ok=True)
         tmp1, tmp2 = tmp_path_obj.as_posix(), self.get_remote_path(root=root, os_specific=os_specific).as_posix()
-        source, target = (tmp1, f"{cloud}:{tmp2 if rel2home else tmp1}") if sync_up else (f"{cloud}:{tmp2 if rel2home else tmp1}", tmp1)  # in bisync direction is irrelavent.
+        if sync_up:
+            source = tmp1
+            target = f"{cloud}:{tmp2 if rel2home else tmp1}"
+        else:
+            source = f"{cloud}:{tmp2 if rel2home else tmp1}"   # in bisync direction is irrelavent.
+            target = tmp1
+
         if not sync_down and not sync_up:
             _ = print(f"SYNCING 🔄️ {source} {'<>' * 7} {target}`") if verbose else None
             rclone_cmd = f"""rclone bisync '{source}' '{target}' --resync --remove-empty-dirs """
         else:
             print(f"SYNCING 🔄️ {source} {'>' * 15} {target}`")
             rclone_cmd = f"""rclone sync '{source}' '{target}' """
+
         rclone_cmd += f" --progress --transfers={transfers} --verbose"
         rclone_cmd += " --delete-during" if delete else ""
-        from machineconfig.utils.terminal import Terminal
-
         if verbose:
             print(rclone_cmd)
         shell_to_use = "powershell" if sys.platform == "win32" else "bash"
-        res = Terminal(stdout=None if verbose else subprocess.PIPE).run(rclone_cmd, shell=shell_to_use)
+        stdout_target: Optional[int] = None if verbose else subprocess.PIPE
+        stderr_target: Optional[int] = None if verbose else subprocess.PIPE
+        completed = _run_shell_command(rclone_cmd, shell_to_use, stdout=stdout_target, stderr=stderr_target)
+        from machineconfig.utils.terminal import Response
+
+        res = Response.from_completed_process(completed)
         success = res.is_successful(strict_err=False, strict_returcode=True)
         if not success:
             res.print(capture=False, desc="Cloud Storage Operation")
             return None
+
         return self

machineconfig/utils/path_helper.py

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