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

machineconfig/utils/installer_utils/installer_cli.py

@@ -0,0 +1,186 @@
+"""Devops Devapps Install"""
+
+import typer
+from typing import Annotated, Optional
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+from machineconfig.utils.installer_utils.installer_class import Installer
+
+
+
+def main_installer_cli(
+    which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program/groups names to install (if --group flag is set).")] = None,
+    group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,
+    interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
+) -> None:
+    if interactive:
+        return install_interactively()
+    if which is not None:
+        if group:
+            for a_group in [x.strip() for x in which.split(",") if x.strip() != ""]:
+                return install_group(package_group=a_group)
+        else:
+            return install_clis(clis_names=[x.strip() for x in which.split(",") if x.strip() != ""])
+    else:
+        if group:
+            from rich.console import Console
+            from rich.table import Table
+            console = Console()
+
+            typer.echo("❌ You must provide a group name when using the --group/-g option.")
+            res = get_group_name_to_repr()
+            console.print("[bold blue]Here are the available groups:[/bold blue]")
+            table = Table(show_header=True, header_style="bold magenta")
+            table.add_column("Group", style="cyan", no_wrap=True)
+            table.add_column("AppsBundled", style="green", overflow="fold")
+            for display, group_name in res.items():
+                # Parse display
+                if "   --   " in display:
+                    group_part, items_part = display.split("   --   ", 1)
+                    group_name_parsed = group_part.replace("📦 ", "").strip()
+                    items_str = items_part.strip()
+                else:
+                    group_name_parsed = display
+                    items_str = group_name
+                table.add_row(group_name_parsed, items_str)
+            console.print(table)
+            raise typer.Exit(1)
+    typer.echo("❌ You must provide either a program name/group name, or use --interactive/-ia option.")
+    import click
+    ctx = click.get_current_context()
+    typer.echo(ctx.get_help())
+    raise typer.Exit(1)
+
+
+def get_group_name_to_repr() -> dict[str, str]:
+    # Build category options and maintain a mapping from display text to actual category name
+    category_display_to_name: dict[str, str] = {}
+    for group_name, group_values in PACKAGE_GROUP2NAMES.items():
+        display = f"📦 {group_name:<20}" + "   --   " + f"{'|'.join(group_values):<60}"
+        category_display_to_name[display] = group_name
+    return category_display_to_name
+
+
+def install_interactively():
+    from machineconfig.utils.options import choose_from_options
+    from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+    from machineconfig.utils.installer_utils.installer_runner import get_installers
+    from machineconfig.utils.installer_utils.installer_class import Installer
+    from rich.console import Console
+    from rich.panel import Panel
+    # from rich.table import Table
+    installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
+    installer_options = [Installer(installer_data=x).get_description() for x in installers]
+    category_display_to_name = get_group_name_to_repr()
+    options = list(category_display_to_name.keys()) + installer_options
+    program_names = choose_from_options(multi=True, msg="Categories are prefixed with 📦", options=options, header="🚀 CHOOSE DEV APP OR CATEGORY", fzf=True)
+    installation_messages: list[str] = []
+    for _an_idx, a_program_name in enumerate(program_names):
+        if a_program_name.startswith("📦 "):
+            category_name = category_display_to_name.get(a_program_name)
+            if category_name:
+                install_group(package_group=category_name)
+        else:
+            installer_idx = installer_options.index(a_program_name)
+            an_installer_data = installers[installer_idx]
+            status_message = Installer(an_installer_data).install_robust(version=None)  # finish the task - this returns a status message, not a command
+            installation_messages.append(status_message)
+    if installation_messages:
+        console = Console()
+
+        panel = Panel("\n".join([f"[blue]• {message}[/blue]" for message in installation_messages]), title="[bold green]📊 Installation Summary[/bold green]", border_style="green", padding=(1, 2))
+        console.print(panel)
+
+
+def install_group(package_group: str):
+    from machineconfig.utils.installer_utils.installer_runner import get_installers, install_bulk
+    from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+    from rich.console import Console
+    from rich.panel import Panel
+    # from rich.table import Table
+    if package_group in PACKAGE_GROUP2NAMES:
+        panel = Panel(f"[bold yellow]Installing programs from category: [green]{package_group}[/green][/bold yellow]", title="[bold blue]📦 Category Installation[/bold blue]", border_style="blue", padding=(1, 2))
+        console = Console()
+        console.print(panel)
+        installers_ = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=[package_group])
+        install_bulk(installers_data=installers_)
+        return
+    console = Console()
+    console.print(f"❌ ERROR: Unknown package group: {package_group}. Available groups are: {list(PACKAGE_GROUP2NAMES.keys())}")
+def _handle_installer_not_found(search_term: str, all_names: list[str]) -> None:  # type: ignore
+    """Handle installer not found with friendly suggestions using fuzzy matching."""
+    from difflib import get_close_matches
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    close_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
+    console = Console()
+
+    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
+    if close_matches:
+        console.print("🤔 Did you mean one of these?", style="yellow")
+        table = Table(show_header=False, box=None, pad_edge=False)
+        for i, match in enumerate(close_matches, 1):
+            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{match}[/green]")
+        console.print(table)
+    else:
+        console.print("📋 Here are some available options:", style="blue")
+        # Show first 10 installers as examples
+        if len(all_names) > 10:
+            sample_names = all_names[:10]
+        else:
+            sample_names = all_names
+        table = Table(show_header=False, box=None, pad_edge=False)
+        for i, name in enumerate(sample_names, 1):
+            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{name}[/green]")
+        console.print(table)
+        if len(all_names) > 10:
+            console.print(f"   [dim]... and {len(all_names) - 10} more[/dim]")
+
+    panel = Panel(f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(PACKAGE_GROUP2NAMES.keys())}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow")
+    console.print(panel)
+
+def install_clis(clis_names: list[str]):
+    from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+    from machineconfig.utils.installer_utils.installer_runner import get_installers
+    from machineconfig.utils.installer_utils.installer_class import Installer
+    from rich.console import Console
+    all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
+    total_messages: list[str] = []
+    for a_cli_name in clis_names:
+        if "github.com" in a_cli_name.lower():
+            from machineconfig.utils.installer_utils.install_from_url import install_from_github_url
+            install_from_github_url(github_url=a_cli_name)
+            continue
+        selected_installer = None
+        for installer in all_installers:
+            app_name = installer["appName"]
+            if app_name.lower() == a_cli_name.lower():
+                selected_installer = installer
+                break
+        if selected_installer is None:
+            _handle_installer_not_found(a_cli_name, all_names=[inst["appName"] for inst in all_installers])
+            return None
+        message = Installer(selected_installer).install_robust(version=None)  # finish the task
+        total_messages.append(message)
+    if total_messages:
+        console = Console()
+        console.print("\n[bold green]📊 Installation Results:[/bold green]")
+        for a_message in total_messages:
+            console.print(f"[blue]• {a_message}[/blue]")
+    return None
+def install_if_missing(which: str):
+    from machineconfig.utils.installer_utils.installer_locator_utils import check_tool_exists
+    exists = check_tool_exists(which)
+    if exists:
+        print(f"✅ {which} is already installed.")
+        return
+    print(f"⏳ {which} not found. Installing...")
+    from machineconfig.utils.installer_utils.installer_cli import main_installer_cli
+    main_installer_cli(which=which, interactive=False)
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.schemas.installer.installer_types import InstallerData
+    from machineconfig.utils.installer_utils.installer_class import Installer
+    _ = InstallerData, Installer
+    pass

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

@@ -1,11 +1,14 @@
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH
+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 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():
@@ -50,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}")
@@ -104,5 +107,87 @@ 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_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)
+        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"🔍 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)
+
+    if use_cache:
+        print("🗂️  Using cached version information...")
+        if tmp_path.exists():
+            existing_version = tmp_path.read_text(encoding="utf-8").rstrip()
+            print(f"📄 Found cached version: {existing_version}")
+        else:
+            existing_version = None
+            print("ℹ️  No cached version information found")
+    else:
+        print("🔍 Checking installed version directly...")
+        result = subprocess.run([exe_name, "--version"], check=False, capture_output=True, text=True)
+        if result.stdout.strip() == "":
+            existing_version = None
+            print("ℹ️  Could not detect installed version")
+        else:
+            existing_version = result.stdout.strip()
+            print(f"📄 Detected installed version: {existing_version}")
+
+    if existing_version is not None and version is not None:
+        if existing_version == version:
+            print(f"✅ {exe_name} is up to date (version {version})")
+            print(f"📂 Version information stored at: {INSTALL_VERSION_ROOT}")
+            return ("✅ Up to date", version.strip(), version.strip())
+        else:
+            print(f"🔄 {exe_name} needs update: {existing_version.rstrip()} → {version}")
+            tmp_path.write_text(version, encoding="utf-8")
+            return ("❌ Outdated", existing_version.strip(), version.strip())
+    else:
+        print(f"📦 {exe_name} is not installed. Will install version: {version}")
+        # tmp_path.write_text(version, encoding="utf-8")
+
+    print(f"{'=' * 80}")
+    return ("⚠️ NotInstalled", "None", version or "unknown")
+
+

machineconfig/utils/installer_utils/installer_runner.py

@@ -0,0 +1,191 @@
+"""package manager"""
+
+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 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 rich.console import Console
+from rich.panel import Panel
+from typing import Any, Optional
+import platform
+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=["termabc"])
+    installers_github = []
+    for inst__ in installers:
+        app_name = inst__["appName"]
+        repo_url = inst__["repoURL"]
+        if "ntop" in app_name:
+            print(f"⏭️  Skipping {app_name} (ntop)")
+            continue
+        if "github" not in repo_url:
+            print(f"⏭️  Skipping {app_name} (not a GitHub release)")
+            continue
+        installers_github.append(inst__)
+
+    print(f"\n🔍 Checking {len(installers_github)} GitHub-based installers...\n")
+
+    def func(inst: Installer):
+        exe_name = inst.installer_data.get("exeName", "unknown")
+        repo_url = inst.installer_data.get("repoURL", "")
+        print(f"🔎 Checking {exe_name}...")
+        _release_url, version_to_be_installed = inst.get_github_release(repo_url=repo_url, version=None)
+        verdict, current_ver, new_ver = check_if_installed_already(exe_name=exe_name, version=version_to_be_installed, use_cache=False)
+        return exe_name, verdict, current_ver, new_ver
+
+    print("\n⏳ Processing installers...\n")
+    res = [func(inst) for inst in installers_github]
+
+    print("\n📊 Generating results table...\n")
+
+    # Convert to list of dictionaries and group by status
+    result_data = []
+    for tool, status, current_ver, new_ver in res:
+        result_data.append({"Tool": tool, "Status": status, "Current Version": current_ver, "New Version": new_ver})
+
+    # Group by status
+    grouped_data: dict[str, list[dict[str, Any]]] = {}
+    for item in result_data:
+        status = item["Status"]
+        if status not in grouped_data:
+            grouped_data[status] = []
+        grouped_data[status].append(item)
+
+    console.print(Panel("📊  INSTALLATION STATUS SUMMARY", title="Status", expand=False))
+
+    # Print each group
+    for status, items in grouped_data.items():
+        console.print(f"\n[bold]{status.upper()}:[/bold]")
+        console.rule(style="dim")
+        for item in items:
+            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("🔍 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"])
+    elif platform.system() in ["Linux", "Darwin"]:
+        print(f"🐧 Searching for {platform.system()} executables...")
+        if platform.system() == "Linux":
+            apps = PathExtended(LINUX_INSTALL_PATH).search("*") + PathExtended("/usr/local/bin").search("*")
+        else:  # Darwin/macOS
+            apps = PathExtended("/usr/local/bin").search("*") + PathExtended("/opt/homebrew/bin").search("*")
+    else:
+        error_msg = f"❌ ERROR: System {platform.system()} not supported"
+        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")
+    return apps
+
+
+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 installer_data in res_all:
+        if acceptable_apps_names is not None:
+            if installer_data["appName"] not in acceptable_apps_names:
+                continue
+        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() -> list[InstallerData]:
+    import machineconfig.jobs.installer as module
+    from pathlib import Path
+    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_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(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: Installer(x).install_robust(version=None))(installer) for installer in installers_remaining)
+
+    console = Console()
+
+    print("\n")
+    console.rule("📊 INSTALLATION RESULTS SUMMARY 📊")
+
+    print("\n")
+    console.rule("✓ Same Version Apps")
+    same_version_results = [r for r in res if r and "same version" in str(r)]
+    for result in same_version_results:
+        print(f"  {result}")
+
+    print("\n")
+    console.rule("⬆️ Updated Apps")
+    updated_results = [r for r in res if r and "updated from" in str(r)]
+    for result in updated_results:
+        print(f"  {result}")
+
+    print("\n")
+    console.rule("❌ Failed Apps")
+    failed_results = [r for r in res if r and "Failed at" in str(r)]
+    for result in failed_results:
+        print(f"  {result}")
+
+    print("\n")
+    print("✨ INSTALLATION COMPLETE ✨".center(100, "="))
+    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
@@ -77,13 +57,17 @@ def read_ini(path: "Path", encoding: Optional[str] = None):
 
 def read_json(path: "Path", r: bool = False, **kwargs: Any) -> Any:  # return could be list or dict etc
     import json
-
     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
 
@@ -92,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)