machineconfig 3.99__py3-none-any.whl → 7.66__py3-none-any.whl

machineconfig/utils/installer_utils/{installer_abc.py → installer_locator_utils.py}

@@ -1,15 +1,14 @@
-
-from machineconfig.utils.path_extended import PathExtended as PathExtended
+from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH, INSTALL_VERSION_ROOT
 
 from pathlib import Path
-from typing import Any, Optional
+from typing import Optional
 import subprocess
 import platform
 
 
 def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optional[str] = None, delete: bool = True, rename_to: Optional[str] = None):
-    print(f"\n{'=' * 80}\n🔍 PROCESSING WINDOWS EXECUTABLE 🔍\n{'=' * 80}")
+    print("🔍 PROCESSING WINDOWS EXECUTABLE 🔍")
     if exe_name is not None and ".exe" in exe_name:
         exe_name = exe_name.replace(".exe", "")
     if downloaded_file_path.is_file():
@@ -54,7 +53,7 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, exe_name: Optio
 
 
 def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Optional[bool] = True, rename_to: Optional[str] = None):
-    print(f"\n{'=' * 80}\n🔍 PROCESSING LINUX EXECUTABLE 🔍\n{'=' * 80}")
+    print("🔍 PROCESSING LINUX EXECUTABLE 🔍")
     if downloaded.is_file():
         exe = downloaded
         print(f"📄 Found direct executable file: {exe}")
@@ -108,26 +107,52 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: str, delete: Opt
         print("✅ Temporary files removed")
 
     exe_new_location = PathExtended(LINUX_INSTALL_PATH).joinpath(exe.name)
-    print(f"✅ Executable installed at: {exe_new_location}\n{'=' * 80}")
+    print(f"✅ Executable installed at: {exe_new_location}")
     return exe_new_location
 
 
 def check_tool_exists(tool_name: str) -> bool:
     if platform.system() == "Windows":
-        tool_name = tool_name.replace(".exe", "") + ".exe"
-        res1 = any([Path(WINDOWS_INSTALL_PATH).joinpath(tool_name).is_file(), Path.home().joinpath("AppData/Roaming/npm").joinpath(tool_name).is_file()])
-        tool_name = tool_name.replace(".exe", "") + ".exe"
-        res2 = any([Path(WINDOWS_INSTALL_PATH).joinpath(tool_name).is_file(), Path.home().joinpath("AppData/Roaming/npm").joinpath(tool_name).is_file()])
-        return res1 or res2
+        tool_name_exe = tool_name.replace(".exe", "") + ".exe"
+        res1 = any([Path(WINDOWS_INSTALL_PATH).joinpath(tool_name_exe).is_file(), Path.home().joinpath("AppData/Roaming/npm").joinpath(tool_name_exe).is_file()])
+        if res1:
+            return True
+        tool_name_no_exe = tool_name.replace(".exe", "")
+        res2 = any([Path(WINDOWS_INSTALL_PATH).joinpath(tool_name_no_exe).is_file(), Path.home().joinpath("AppData/Roaming/npm").joinpath(tool_name_no_exe).is_file()])
+        return res2
     elif platform.system() in ["Linux", "Darwin"]:
         root_path = Path(LINUX_INSTALL_PATH)
-        return any([Path("/usr/local/bin").joinpath(tool_name).is_file(), Path("/usr/bin").joinpath(tool_name).is_file(), root_path.joinpath(tool_name).is_file()])
+        standard_checks = [
+            Path("/usr/local/bin").joinpath(tool_name).is_file(),
+            Path("/usr/bin").joinpath(tool_name).is_file(),
+            root_path.joinpath(tool_name).is_file()
+        ]
+        if any(standard_checks):
+            return True
+        # Check for npm packages via nvm
+        npm_check = False
+        try:
+            result = subprocess.run(["node", "--version"], capture_output=True, text=True, check=True)
+            version = result.stdout.strip().lstrip('v')
+            nvm_bin_path = Path.home() / ".nvm" / "versions" / "node" / f"v{version}" / "bin" / tool_name
+            npm_check = nvm_bin_path.is_file()
+        except subprocess.CalledProcessError:
+            pass
+        return npm_check
     else:
         raise NotImplementedError(f"platform {platform.system()} not implemented")
 
+def is_executable_in_path(name: str) -> bool:
+    import os
+    path_dirs = os.environ['PATH'].split(os.pathsep)
+    for path_dir in path_dirs:
+        path_to_executable = os.path.join(path_dir, name)
+        if os.path.isfile(path_to_executable) and os.access(path_to_executable, os.X_OK): return True
+    return False
+
 
 def check_if_installed_already(exe_name: str, version: Optional[str], use_cache: bool) -> tuple[str, str, str]:
-    print(f"\n{'=' * 80}\n🔍 CHECKING INSTALLATION STATUS: {exe_name} 🔍\n{'=' * 80}")
+    print(f"🔍 CHECKING INSTALLATION STATUS: {exe_name} 🔍")
     INSTALL_VERSION_ROOT.joinpath(exe_name).parent.mkdir(parents=True, exist_ok=True)
     tmp_path = INSTALL_VERSION_ROOT.joinpath(exe_name)
 
@@ -166,75 +191,3 @@ def check_if_installed_already(exe_name: str, version: Optional[str], use_cache:
     return ("⚠️ NotInstalled", "None", version or "unknown")
 
 
-def parse_apps_installer_linux(txt: str) -> dict[str, Any]:
-    """Parse Linux shell installation scripts into logical chunks.
-    
-    Supports two formats:
-    1. Legacy format with 'yes '' | sed 3q; echo "----------------------------- installing' delimiter
-    2. New format with # --BLOCK:<name>-- comment signatures
-    
-    Returns:
-        dict[str, str]: Dictionary mapping block/section names to their installation scripts
-    """
-    # Try new block format first
-    if "# --BLOCK:" in txt:
-        import re
-        # Split by block signatures: # --BLOCK:<name>--
-        blocks = re.split(r'# --BLOCK:([^-]+)--', txt)
-        res: dict[str, str] = {}
-        
-        # Process blocks in pairs (block_name, block_content)
-        for i in range(1, len(blocks), 2):
-            if i + 1 < len(blocks):
-                block_name = blocks[i].strip()
-                block_content = blocks[i + 1].strip()
-                if block_content:
-                    res[block_name] = block_content
-        
-        return res
-    
-    # Legacy format fallback
-    txts = txt.split("""yes '' | sed 3q; echo "----------------------------- installing """)
-    res = {}
-    for chunk in txts[1:]:
-        try:
-            k = chunk.split("----")[0].rstrip().lstrip()
-            v = "\n".join(chunk.split("\n")[1:])
-            res[k] = v
-        except IndexError as e:
-            print(f"""
-❌ Error parsing chunk:
-{"-" * 50}
-{chunk}
-{"-" * 50}""")
-            raise e
-    return res
-
-
-def parse_apps_installer_windows(txt: str) -> dict[str, Any]:
-    chunks: list[str] = []
-    for idx, item in enumerate(txt.split(sep="winget install")):
-        if idx == 0:
-            continue
-        if idx == 1:
-            chunks.append(item)
-        else:
-            chunks.append("winget install" + item)
-    # progs = L(txt.splitlines()).filter(lambda x: x.startswith("winget ") or x.startswith("#winget"))
-    res: dict[str, str] = {}
-    for a_chunk in chunks:
-        try:
-            name = a_chunk.split("--name ")[1]
-            if "--Id" not in name:
-                print(f"⚠️  Warning: {name} does not have an Id, skipping")
-                continue
-            name = name.split(" --Id ", maxsplit=1)[0].strip('"').strip('"')
-            res[name] = a_chunk
-        except IndexError as e:
-            print(f"""
-❌ Error parsing chunk:
-{"-" * 50}
-{a_chunk}
-{"-" * 50}""")
-            raise e
-    return res

machineconfig/utils/{installer.py → installer_utils/installer_runner.py}

@@ -1,16 +1,16 @@
 """package manager"""
 
-from machineconfig.utils.installer_utils.installer_abc import check_if_installed_already
+from machineconfig.utils.installer_utils.installer_locator_utils import check_if_installed_already
 from machineconfig.utils.installer_utils.installer_class import Installer
-from machineconfig.utils.schemas.installer.installer_types import APP_INSTALLER_CATEGORY, InstallerData, InstallerDataFiles, get_normalized_arch, get_os_name, OPERATING_SYSTEMS, CPU_ARCHITECTURES
-from rich.console import Console
-from rich.panel import Panel
-
-from machineconfig.utils.path_extended import PathExtended as PathExtended
+from machineconfig.utils.schemas.installer.installer_types import InstallerData, InstallerDataFiles, get_normalized_arch, get_os_name, OPERATING_SYSTEMS, CPU_ARCHITECTURES
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+from machineconfig.utils.path_extended import PathExtended
 from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT, LINUX_INSTALL_PATH
 from machineconfig.utils.io import read_json
 
-from typing import Any
+from rich.console import Console
+from rich.panel import Panel
+from typing import Any, Optional
 import platform
 from joblib import Parallel, delayed
 
@@ -18,11 +18,11 @@ from joblib import Parallel, delayed
 def check_latest():
     console = Console()  # Added console initialization
     console.print(Panel("🔍  CHECKING FOR LATEST VERSIONS", title="Status", expand=False))  # Replaced print with Panel
-    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL"])
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=["termabc"])
     installers_github = []
     for inst__ in installers:
-        app_name = inst__.installer_data.get("appName", "unknown")
-        repo_url = inst__.installer_data.get("repoURL", "")
+        app_name = inst__["appName"]
+        repo_url = inst__["repoURL"]
         if "ntop" in app_name:
             print(f"⏭️  Skipping {app_name} (ntop)")
             continue
@@ -63,16 +63,16 @@ def check_latest():
 
     # Print each group
     for status, items in grouped_data.items():
-        print(f"\n{status.upper()}:")
-        print("-" * 60)
+        console.print(f"\n[bold]{status.upper()}:[/bold]")
+        console.rule(style="dim")
         for item in items:
-            print(f"  {item['Tool']:<20} | Current: {item['Current Version']:<15} | New: {item['New Version']}")
-    print("-" * 60)
-    print(f"{'═' * 80}")
+            console.print(f"  {item['Tool']:<20} | Current: {item['Current Version']:<15} | New: {item['New Version']}")
+    console.rule(style="dim")
+    console.rule(style="bold blue")
 
 
 def get_installed_cli_apps():
-    print(f"\n{'=' * 80}\n🔍 LISTING INSTALLED CLI APPS 🔍\n{'=' * 80}")
+    print("🔍 LISTING INSTALLED CLI APPS 🔍")
     if platform.system() == "Windows":
         print("🪟 Searching for Windows executables...")
         apps = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").search("*.exe", not_in=["notepad"])
@@ -87,78 +87,59 @@ def get_installed_cli_apps():
         print(error_msg)
         raise NotImplementedError(error_msg)
     apps = [app for app in apps if app.size("kb") > 0.1 and not app.is_symlink()]  # no symlinks like paint and wsl and bash
-    print(f"✅ Found {len(apps)} installed applications\n{'=' * 80}")
+    print(f"✅ Found {len(apps)} installed applications")
     return apps
 
 
-def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: list[APP_INSTALLER_CATEGORY]) -> list[Installer]:
-    print(f"\n{'=' * 80}\n🔍 LOADING INSTALLER CONFIGURATIONS 🔍\n{'=' * 80}")
-    res_all = get_all_installer_data_files(which_cats=which_cats)
+def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: Optional[list[str]]) -> list[InstallerData]:
+    res_all = get_all_installer_data_files()
+    acceptable_apps_names: list[str] | None = None
+    if which_cats is not None:
+        acceptable_apps_names = []
+        for cat in which_cats:
+            acceptable_apps_names += PACKAGE_GROUP2NAMES[cat]
+    else:
+        acceptable_apps_names = None
     all_installers: list[InstallerData] = []
-    for _category, installer_data_files in res_all.items():
-        suitable_installers = []
-        for an_installer in installer_data_files["installers"]:
-            if an_installer["fileNamePattern"][arch][os] is None:
+    for installer_data in res_all:
+        if acceptable_apps_names is not None:
+            if installer_data["appName"] not in acceptable_apps_names:
                 continue
-            suitable_installers.append(an_installer)
-        all_installers.extend(suitable_installers)
-    print(f"✅ Loaded {len(all_installers)} installer configurations\n{'=' * 80}")
-    return [Installer(installer_data=installer_data) for installer_data in all_installers]
+        try:
+            if installer_data["fileNamePattern"][arch][os] is None:
+                continue
+        except KeyError as ke:
+            print(f"❌ ERROR: Missing key in installer data: {ke}")
+            print(f"Installer data: {installer_data}")
+            raise KeyError(f"Missing key in installer data: {ke}")
+        all_installers.append(installer_data)
+    return all_installers
 
 
-def get_all_installer_data_files(which_cats: list[APP_INSTALLER_CATEGORY]) -> dict[APP_INSTALLER_CATEGORY, InstallerDataFiles]:
-    print(f"\n{'=' * 80}\n📂 LOADING CONFIGURATION FILES 📂\n{'=' * 80}")
+def get_all_installer_data_files() -> list[InstallerData]:
     import machineconfig.jobs.installer as module
     from pathlib import Path
-    print("📂 Loading configuration files...")
-    res_final: dict[APP_INSTALLER_CATEGORY, InstallerDataFiles] = {key: read_json(Path(module.__file__).parent.joinpath(f"packages_{key.lower()}.json")) for key in which_cats}
-    print(f"Loaded: {len(res_final)} installer categories")
-    for k, v in res_final.items():
-        print(f" - {k}: {len(v['installers'])} items")
+    res_raw: InstallerDataFiles = read_json(Path(module.__file__).parent.joinpath("installer_data.json"))
+    res_final: list[InstallerData] = res_raw["installers"]
     return res_final
 
 
-def install_all(installers: list[Installer], safe: bool = False, jobs: int = 10, fresh: bool = False):
-    print(f"\n{'=' * 80}\n🚀 BULK INSTALLATION PROCESS 🚀\n{'=' * 80}")
+def install_bulk(installers_data: list[InstallerData], safe: bool = False, jobs: int = 10, fresh: bool = False):
+    print("🚀 BULK INSTALLATION PROCESS 🚀")
     if fresh:
         print("🧹 Fresh install requested - clearing version cache...")
         PathExtended(INSTALL_VERSION_ROOT).delete(sure=True)
         print("✅ Version cache cleared")
-
     if safe:
         pass
-        # print("⚠️  Safe installation mode activated...")
-        # from machineconfig.jobs.python.check_installations import APP_SUMMARY_PATH
-        # if platform.system().lower() == "windows":
-        #     print("🪟 Moving applications to Windows Apps folder...")
-        #     # PathExtended.get_env().WindowsPaths().WindowsApps)
-        #     folder = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps")
-        #     apps_dir.search("*").apply(lambda app: app.move(folder=folder))
-        # elif platform.system().lower() in ["linux", "darwin"]:
-        #     system_name = "Linux" if platform.system().lower() == "linux" else "macOS"
-        #     print(f"🐧 Moving applications to {system_name} bin folder...")
-        #     if platform.system().lower() == "linux":
-        #         install_path = LINUX_INSTALL_PATH
-        #     else:  # Darwin/macOS
-        #         install_path = "/usr/local/bin"
-        #     Terminal().run(f"sudo mv {apps_dir.as_posix()}/* {install_path}/").capture().print_if_unsuccessful(desc=f"MOVING executable to {install_path}", strict_err=True, strict_returncode=True)
-        # else:
-        #     error_msg = f"❌ ERROR: System {platform.system()} not supported"
-        #     print(error_msg)
-        #     raise NotImplementedError(error_msg)
-
-        # apps_dir.delete(sure=True)
-        # print(f"✅ Safe installation completed\n{'='*80}")
-        # return None
-
-    print(f"🚀 Starting installation of {len(installers)} packages...")
-    print(f"\n{'=' * 80}\n📦 INSTALLING FIRST PACKAGE 📦\n{'=' * 80}")
-    installers[0].install(version=None)
-    installers_remaining = installers[1:]
-    print(f"\n{'=' * 80}\n📦 INSTALLING REMAINING PACKAGES 📦\n{'=' * 80}")
+    print(f"🚀 Starting installation of {len(installers_data)} packages...")
+    print("📦 INSTALLING FIRST PACKAGE 📦")
+    Installer(installers_data[0]).install(version=None)
+    installers_remaining = installers_data[1:]
+    print("📦 INSTALLING REMAINING PACKAGES 📦")
 
     # Use joblib for parallel processing of remaining installers
-    res = Parallel(n_jobs=jobs)(delayed(lambda x: x.install_robust(version=None))(installer) for installer in installers_remaining)
+    res = Parallel(n_jobs=jobs)(delayed(lambda x: Installer(x).install_robust(version=None))(installer) for installer in installers_remaining)
 
     console = Console()
 
@@ -188,4 +169,23 @@ def install_all(installers: list[Installer], safe: bool = False, jobs: int = 10,
     print("\n" * 2)
 
 
-
+def get_machineconfig_version() -> str:
+    from importlib.metadata import PackageNotFoundError, version as _pkg_version
+    from pathlib import Path
+    import tomllib
+    name: str = "machineconfig"
+    try:
+        return _pkg_version(name)
+    except PackageNotFoundError:
+        pass
+    root: Path = Path(__file__).resolve().parents[2]
+    pyproject: Path = root / "pyproject.toml"
+    if pyproject.is_file():
+        with pyproject.open("rb") as f:
+            data: dict[str, object] = tomllib.load(f)
+        project = data.get("project")
+        if isinstance(project, dict):
+            version = project.get("version")
+            if isinstance(version, str) and version:
+                return version
+    return "0.0.0"

machineconfig/utils/io.py

@@ -1,4 +1,3 @@
-from __future__ import annotations
 
 from typing import Any, Union, Optional, Mapping
 from pathlib import Path
@@ -35,24 +34,6 @@ def save_json(obj: Any, path: PathLike, indent: Optional[int] = None, verbose: b
     return Path(path_obj)
 
 
-# def save_toml(obj: Mapping[str, Any], path: PathLike, verbose: bool = False) -> Path:
-#     path_obj = _ensure_parent(path)
-#     with open(path_obj, "w", encoding="utf-8") as fh:
-#         toml.dump(obj, fh)
-#     if verbose:
-#         print(f"Saved toml -> {path_obj}")
-#     return Path(path_obj)
-
-
-# def save_yaml(obj: Any, path: PathLike, verbose: bool = False) -> Path:
-#     path_obj = _ensure_parent(path)
-#     with open(path_obj, "w", encoding="utf-8") as fh:
-#         yaml.safe_dump(obj, fh, sort_keys=False)
-#     if verbose:
-#         print(f"Saved yaml -> {path_obj}")
-#     return Path(path_obj)
-
-
 def save_ini(path: PathLike, obj: Mapping[str, Mapping[str, Any]], verbose: bool = False) -> Path:
     cp = configparser.ConfigParser()
     for section, values in obj.items():
@@ -69,7 +50,6 @@ def read_ini(path: "Path", encoding: Optional[str] = None):
     if not Path(path).exists() or Path(path).is_dir():
         raise FileNotFoundError(f"File not found or is a directory: {path}")
     import configparser
-
     res = configparser.ConfigParser()
     res.read(filenames=[str(path)], encoding=encoding)
     return res
@@ -80,9 +60,14 @@ def read_json(path: "Path", r: bool = False, **kwargs: Any) -> Any:  # return co
     try:
         mydict = json.loads(Path(path).read_text(encoding="utf-8"), **kwargs)
     except Exception:
-        import pyjson5
-
-        mydict = pyjson5.loads(Path(path).read_text(encoding="utf-8"), **kwargs)  # file has C-style comments.
+        import re
+        def remove_comments(text: str) -> str:
+            # remove all // single-line comments
+            text = re.sub(r'//.*', '', text)
+            # remove all /* … */ block comments (non-greedy)
+            text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)
+            return text
+        mydict = json.loads(remove_comments(Path(path).read_text(encoding="utf-8")), **kwargs)
     _ = r
     return mydict
 
@@ -91,3 +76,72 @@ def from_pickle(path: Path) -> Any:
     import pickle
 
     return pickle.loads(path.read_bytes())
+
+
+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, 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)