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

machineconfig/scripts/python/mount_nfs.py

@@ -1,12 +1,13 @@
-"""NFS mounting script
-"""
+"""NFS mounting script"""
 
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.ssh import SSH
 from machineconfig.utils.terminal import Terminal
-from machineconfig.utils.utils import display_options, PROGRAM_PATH, choose_ssh_host
+from machineconfig.utils.options import display_options, choose_ssh_host
+from machineconfig.utils.source_of_truth import PROGRAM_PATH
 import platform
 
+
 def main():
     print("\n" + "=" * 50)
     print("🚀 Starting NFS Mounting Process")
@@ -19,11 +20,7 @@ def main():
         assert isinstance(tmp, str)
         ssh = SSH(tmp)
         default = f"{ssh.hostname}:{ssh.run('echo $HOME').op}/data/share_nfs"
-        share_info = display_options(
-            "📂 Choose a share path:",
-            options=[f"{ssh.hostname}:{item.split(' ')[0]}" for item in ssh.run("cat /etc/exports").op.split("\n") if not item.startswith("#")] + [default],
-            default=default
-        )
+        share_info = display_options("📂 Choose a share path:", options=[f"{ssh.hostname}:{item.split(' ')[0]}" for item in ssh.run("cat /etc/exports").op.split("\n") if not item.startswith("#")] + [default], default=default)
         assert isinstance(share_info, str), f"❌ share_info must be a string. Got {type(share_info)}"
 
     remote_server = share_info.split(":")[0]
@@ -41,12 +38,7 @@ def main():
             mount_path_3 = mount_path_2
 
         print("🔧 Preparing mount paths...")
-        local_mount_point = display_options(
-            msg="📂 Choose mount path OR input custom one:",
-            options=[mount_path_1, mount_path_2, mount_path_3],
-            default=mount_path_2,
-            custom_input=True
-        )
+        local_mount_point = display_options(msg="📂 Choose mount path OR input custom one:", options=[mount_path_1, mount_path_2, mount_path_3], default=mount_path_2, custom_input=True)
         assert isinstance(local_mount_point, PathExtended), f"❌ local_mount_point must be a pathlib.Path. Got {type(local_mount_point)}"
         local_mount_point = PathExtended(local_mount_point).expanduser()
 
@@ -79,5 +71,6 @@ $driveLetter = "{driver_letter}"
 
     print("🎉 NFS Mounting Process Completed Successfully!\n")
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()

machineconfig/scripts/python/mount_nw_drive.py

@@ -1,7 +1,8 @@
-from machineconfig.utils.utils import PROGRAM_PATH
+from machineconfig.utils.source_of_truth import PROGRAM_PATH
 from pathlib import Path
 import platform
 
+
 def main():
     print("\n" + "=" * 50)
     print("🚀 Welcome to the Windows Network Drive Mounting Wizard")
@@ -12,7 +13,7 @@ def main():
 
     mount_point_input = input(f"📂 Enter the mount point directory (e.g., /mnt/network) [Default: ~/data/mount_nw/{machine_name}]: ")
     if mount_point_input == "":
-        mount_point = Path.home().joinpath(fr"data/mount_nw/{machine_name}")
+        mount_point = Path.home().joinpath(rf"data/mount_nw/{machine_name}")
     else:
         mount_point = Path(mount_point_input).expanduser()
 
@@ -24,13 +25,16 @@ def main():
 
     if platform.system() in ["Linux", "Darwin"]:
         print("\n🔧 Saving configuration for Linux...")
-        PROGRAM_PATH.write_text(f"""
+        PROGRAM_PATH.write_text(
+            f"""
 drive_location='{drive_location}'
 mount_point='{mount_point}'
 username='{username}'
 password='{password}'
 
-""", encoding="utf-8")
+""",
+            encoding="utf-8",
+        )
         print("✅ Configuration saved successfully!\n")
 
     elif platform.system() == "Windows":
@@ -39,5 +43,6 @@ password='{password}'
 
     print("🎉 Windows Network Drive Mounting Process Completed!\n")
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()

machineconfig/scripts/python/mount_ssh.py

@@ -1,11 +1,12 @@
-"""Mount a remote SSHFS share on a local directory
-"""
+"""Mount a remote SSHFS share on a local directory"""
 
 from platform import system
 from machineconfig.utils.ssh import SSH
 from machineconfig.utils.terminal import Terminal
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
-from machineconfig.utils.utils import PROGRAM_PATH, choose_ssh_host
+from machineconfig.utils.source_of_truth import PROGRAM_PATH
+from machineconfig.utils.options import choose_ssh_host
+
 
 def main():
     print("\n" + "=" * 50)
@@ -33,7 +34,7 @@ def main():
 
     mount_point = input(f"📂 Enter the mount point directory (e.g., /mnt/network) [Default: ~/data/mount_ssh/{ssh.hostname}]: ")
     if mount_point == "":
-        mount_point = PathExtended.home().joinpath(fr"data/mount_ssh/{ssh.hostname}")
+        mount_point = PathExtended.home().joinpath(rf"data/mount_ssh/{ssh.hostname}")
 
     print(f"\n📁 Mount Point: {mount_point}")
 
@@ -43,7 +44,7 @@ sshfs alex@:/media/dbhdd /media/dbhdd\
 """
         print("\n🔧 Preparing SSHFS mount command for Linux...")
     elif system() == "Windows":
-        txt = fr"""
+        txt = rf"""
 net use {driver_letter} {share_info}
 fusermount -u /mnt/dbhdd
 """
@@ -56,5 +57,6 @@ fusermount -u /mnt/dbhdd
 
     print("🎉 SSHFS Mounting Process Completed!\n")
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()

machineconfig/scripts/python/repos.py

@@ -5,11 +5,13 @@ in the event that username@github.com is not mentioned in the remote url.
 
 """
 
+import subprocess
 from rich import print as pprint
-from machineconfig.utils.utils import write_shell_script_to_default_program_path, CONFIG_PATH, DEFAULTS_PATH
+from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.io_save import save_json
 from machineconfig.utils.utils2 import randstr, read_json, read_ini
+from machineconfig.scripts.python.devops_update_repos import run_uv_sync, update_repository
 import argparse
 from dataclasses import dataclass
 from enum import Enum
@@ -30,37 +32,61 @@ class RepoRecord:
     version: dict[str, str]
 
 
-def git_action(path: PathExtended, action: GitAction, mess: Optional[str] = None, r: bool = False, uv_sync: bool = False) -> str:
+def git_action(path: PathExtended, action: GitAction, mess: Optional[str] = None, r: bool = False, auto_sync: bool = True) -> bool:
+    """Perform git actions using Python instead of shell scripts. Returns True if successful."""
     from git.exc import InvalidGitRepositoryError
     from git.repo import Repo
+
     try:
         repo = Repo(str(path), search_parent_directories=False)
     except InvalidGitRepositoryError:
         pprint(f"⚠️ Skipping {path} because it is not a git repository.")
         if r:
-            prgs = [git_action(path=sub_path, action=action, mess=mess, r=r, uv_sync=uv_sync) for sub_path in path.search()]
-            return "\n".join(prgs)
-        else: return "\necho 'skipped because not a git repo'\n\n"
-
-    program = f'''
-echo '>>>>>>>>> 🔧{action}'
-cd '{path}'
-'''
-    if action == GitAction.commit:
-        if mess is None: mess = "auto_commit_" + randstr()
-        program += f'''
-git commit -am "{mess}"
-'''
-    if action == GitAction.push or action == GitAction.pull:
-        action_name = "pull" if action == GitAction.pull else "push"
-        cmds = [f'echo "🔄 {action_name.capitalize()}ing from {remote.url}" ; git {action_name} {remote.name} {repo.active_branch.name}' for remote in repo.remotes]
-        program += '\n' + '\n'.join(cmds) + '\n'
-    uv_sync_cmd = "uv sync" if uv_sync else ""
-    program = program + f'''
-{uv_sync_cmd}
-echo "✅"; echo ""
-'''
-    return program
+            results = [git_action(path=sub_path, action=action, mess=mess, r=r, auto_sync=auto_sync) for sub_path in path.search()]
+            return all(results)  # Return True only if all recursive operations succeeded
+        else:
+            return False
+
+    print(f">>>>>>>>> 🔧{action} - {path}")
+
+    try:
+        if action == GitAction.commit:
+            if mess is None:
+                mess = "auto_commit_" + randstr()
+
+            # Check if there are changes to commit
+            if repo.is_dirty() or repo.untracked_files:
+                repo.git.add(A=True)  # Stage all changes
+                repo.index.commit(mess)
+                print(f"✅ Committed changes with message: {mess}")
+                return True
+            else:
+                print("ℹ️  No changes to commit")
+                return True
+
+        elif action == GitAction.push:
+            success = True
+            for remote in repo.remotes:
+                try:
+                    print(f"🚀 Pushing to {remote.url}")
+                    remote.push(repo.active_branch.name)
+                    print(f"✅ Pushed to {remote.name}")
+                except Exception as e:
+                    print(f"❌ Failed to push to {remote.name}: {e}")
+                    success = False
+            return success
+
+        elif action == GitAction.pull:
+            # Use the enhanced update function with uv sync support
+            update_repository(repo, auto_sync=auto_sync)
+            print("✅ Pull completed")
+            return True
+
+    except Exception as e:
+        print(f"❌ Error performing {action} on {path}: {e}")
+        return False
+
+    return True
 
 
 def main():
@@ -68,12 +94,11 @@ def main():
     print("📂 Welcome to the Repository Manager")
     print("=" * 50 + "\n")
 
-    parser = argparse.ArgumentParser(description='REPO MANAGER')
+    parser = argparse.ArgumentParser(description="REPO MANAGER")
     # POSITIONAL
     parser.add_argument("directory", help="📁 Folder containing repos to record or a specs JSON file to follow.", default="")
     # FLAGS
     parser.add_argument("--push", help="🚀 Push changes.", action="store_true")
-    parser.add_argument("--uv_sync", help="🔄 Sync UV dependencies.", action="store_true")
     parser.add_argument("--pull", help="⬇️ Pull changes.", action="store_true")
     parser.add_argument("--commit", help="💾 Commit changes.", action="store_true")
     parser.add_argument("--all", help="🔄 Pull, commit, and push changes.", action="store_true")
@@ -82,14 +107,18 @@ def main():
     parser.add_argument("--checkout", help="🔀 Check out to versions provided in a JSON file.", action="store_true")
     parser.add_argument("--checkout_to_branch", help="🔀 Check out to the main branch.", action="store_true")
     parser.add_argument("--recursive", "-r", help="🔍 Recursive flag.", action="store_true")
+    parser.add_argument("--no-sync", help="🚫 Disable automatic uv sync after pulls.", action="store_true")
     # OPTIONAL
     parser.add_argument("--cloud", "-c", help="☁️ Cloud storage option.", default=None)
     args = parser.parse_args()
 
-    if args.directory == "": repos_root = PathExtended.home().joinpath("code")  # it is a positional argument, can never be empty.
-    else: repos_root = PathExtended(args.directory).expanduser().absolute()
+    if args.directory == "":
+        repos_root = PathExtended.home().joinpath("code")  # it is a positional argument, can never be empty.
+    else:
+        repos_root = PathExtended(args.directory).expanduser().absolute()
+
+    auto_sync = not args.no_sync  # Enable auto sync by default, disable with --no-sync
 
-    program = ""
     if args.record:
         print("\n📝 Recording repositories...")
         res = record_repos(repos_root=str(repos_root))
@@ -97,37 +126,56 @@ def main():
         save_path = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
         save_json(obj=res, path=save_path, indent=4)
         pprint(f"📁 Result saved at {PathExtended(save_path)}")
-        if args.cloud is not None: PathExtended(save_path).to_cloud(rel2home=True, cloud=args.cloud)
-        program += """\necho '>>>>>>>>> Finished Recording'\n"""
+        if args.cloud is not None:
+            PathExtended(save_path).to_cloud(rel2home=True, cloud=args.cloud)
+        print(">>>>>>>>> Finished Recording")
+
     elif args.clone or args.checkout or args.checkout_to_branch:
         print("\n📥 Cloning or checking out repositories...")
-        program += """\necho '>>>>>>>>> Cloning Repos'\n"""
-        if not repos_root.exists() or repos_root.name != 'repos.json':  # Fixed: use name instead of stem
-            repos_root = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
+        print(">>>>>>>>> Cloning Repos")
+        if not repos_root.exists() or repos_root.name != "repos.json":  # Fixed: use name instead of stem
+            repos_root = PathExtended(CONFIG_PATH).joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
             if not repos_root.exists():
                 if args.cloud is None:
-                    cloud: str=read_ini(DEFAULTS_PATH)['general']['rclone_config_name']
+                    cloud: str = read_ini(DEFAULTS_PATH)["general"]["rclone_config_name"]
                     print(f"⚠️ Using default cloud: {cloud}")
                 else:
                     cloud = args.cloud
                     assert cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
                 repos_root.from_cloud(cloud=cloud, rel2home=True)
-        assert (repos_root.exists() and repos_root.name == 'repos.json') or args.cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
-        program += install_repos(specs_path=str(repos_root), clone=args.clone, checkout_to_recorded_commit=args.checkout, checkout_to_branch=args.checkout_to_branch)
+        assert (repos_root.exists() and repos_root.name == "repos.json") or args.cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
+        success = install_repos_python(specs_path=str(repos_root), clone=args.clone, checkout_to_recorded_commit=args.checkout, checkout_to_branch=args.checkout_to_branch, auto_sync=auto_sync)
+        if success:
+            print("✅ Repository operations completed successfully")
+        else:
+            print("⚠️ Some repository operations encountered issues")
+
     elif args.all or args.commit or args.pull or args.push:
         print(f"\n🔄 Performing Git actions on repositories @ `{repos_root}`...")
+        overall_success = True
         for a_path in repos_root.search("*"):
-            program += f"""echo "{("Handling " + str(a_path)).center(80, "-")}" """
-            if args.pull or args.all: program += git_action(path=a_path, action=GitAction.pull, r=args.recursive, uv_sync=args.uv_sync)
-            if args.commit or args.all: program += git_action(a_path, action=GitAction.commit, r=args.recursive, uv_sync=args.uv_sync)
-            if args.push or args.all: program += git_action(a_path, action=GitAction.push, r=args.recursive, uv_sync=args.uv_sync)
-    else: program = "echo '❌ No action specified. Try passing --push, --pull, --commit, or --all.'"
-    write_shell_script_to_default_program_path(program=program, desc="Script to update repos", preserve_cwd=True, display=True, execute=False)
+            print(f"{('Handling ' + str(a_path)).center(80, '-')}")
+            path_success = True
+            if args.pull or args.all:
+                path_success = git_action(path=a_path, action=GitAction.pull, r=args.recursive, auto_sync=auto_sync) and path_success
+            if args.commit or args.all:
+                path_success = git_action(a_path, action=GitAction.commit, r=args.recursive, auto_sync=auto_sync) and path_success
+            if args.push or args.all:
+                path_success = git_action(a_path, action=GitAction.push, r=args.recursive, auto_sync=auto_sync) and path_success
+            overall_success = overall_success and path_success
+
+        if overall_success:
+            print("✅ All git operations completed successfully")
+        else:
+            print("⚠️ Some git operations encountered issues")
+    else:
+        print("❌ No action specified. Try passing --push, --pull, --commit, or --all.")
 
 
-def record_repos(repos_root: str, r: bool=True) -> list[dict[str, Any]]:
+def record_repos(repos_root: str, r: bool = True) -> list[dict[str, Any]]:
     path_obj = PathExtended(repos_root).expanduser().absolute()
-    if path_obj.is_file(): return []
+    if path_obj.is_file():
+        return []
     search_res = path_obj.search("*", files=False)
     res: list[dict[str, Any]] = []
     for a_search_res in search_res:
@@ -137,35 +185,145 @@ def record_repos(repos_root: str, r: bool=True) -> list[dict[str, Any]]:
             except Exception as e:
                 print(f"⚠️ Failed to record {a_search_res}: {e}")
         else:
-            if r: res += record_repos(str(a_search_res), r=r)
+            if r:
+                res += record_repos(str(a_search_res), r=r)
     return res
 
 
-def record_a_repo(path: PathExtended, search_parent_directories: bool=False, preferred_remote: Optional[str] = None):
+def record_a_repo(path: PathExtended, search_parent_directories: bool = False, preferred_remote: Optional[str] = None):
     from git.repo import Repo
+
     repo = Repo(path, search_parent_directories=search_parent_directories)  # get list of remotes using git python
     repo_root = PathExtended(repo.working_dir).absolute()
     remotes = {remote.name: remote.url for remote in repo.remotes}
     if preferred_remote is not None:
-        if preferred_remote in remotes: remotes = {preferred_remote: remotes[preferred_remote]}
+        if preferred_remote in remotes:
+            remotes = {preferred_remote: remotes[preferred_remote]}
         else:
             print(f"⚠️ `{preferred_remote=}` not found in {remotes}.")
             preferred_remote = None
-    try: commit = repo.head.commit.hexsha
+    try:
+        commit = repo.head.commit.hexsha
     except ValueError:  # look at https://github.com/gitpython-developers/GitPython/issues/1016
         print(f"⚠️ Failed to get latest commit of {repo}")
         commit = None
-    try: current_branch = repo.head.reference.name  # same as repo.active_branch.name
+    try:
+        current_branch = repo.head.reference.name  # same as repo.active_branch.name
     except TypeError:
         print(f"⁉️ Failed to get current branch of {repo}. It is probably in a detached state.")
         current_branch = None
-    res: dict[str, Any] = {"name": repo_root.name, "parent_dir": repo_root.parent.collapseuser().as_posix(),
-                            "current_branch": current_branch,
-                            "remotes": remotes, "version": {"branch": current_branch, "commit": commit}}
+    res: dict[str, Any] = {"name": repo_root.name, "parent_dir": repo_root.parent.collapseuser().as_posix(), "current_branch": current_branch, "remotes": remotes, "version": {"branch": current_branch, "commit": commit}}
     return res
 
 
-def install_repos(specs_path: str, clone: bool=True, checkout_to_recorded_commit: bool=False, checkout_to_branch: bool=False, editable_install: bool=False, preferred_remote: Optional[str] = None):
+def install_repos_python(specs_path: str, clone: bool = True, checkout_to_recorded_commit: bool = False, checkout_to_branch: bool = False, editable_install: bool = False, preferred_remote: Optional[str] = None, auto_sync: bool = True) -> bool:
+    """Python-based repository installation with uv sync support. Returns True if all operations succeeded."""
+    from git.repo import Repo
+    from git.exc import GitCommandError
+
+    path_obj = PathExtended(specs_path).expanduser().absolute()
+    repos: list[dict[str, Any]] = read_json(path_obj)
+    overall_success = True
+
+    for repo in repos:
+        repo_success = True
+        parent_dir = PathExtended(repo["parent_dir"]).expanduser().absolute()
+        parent_dir.mkdir(parents=True, exist_ok=True)
+        repo_path = parent_dir / repo["name"]
+
+        print(f"\n{'Processing ' + repo['name']:.^80}")
+
+        # Handle cloning and remote setup
+        if clone:
+            # Select the remote to use for cloning
+            if len(repo["remotes"]) == 0:
+                print(f"⚠️ No remotes found for {repo['name']}. Skipping clone.")
+                repo_success = False
+                continue
+
+            remote_name, remote_url = next(iter(repo["remotes"].items()))  # Get first remote by default
+            if preferred_remote is not None and preferred_remote in repo["remotes"]:
+                remote_name = preferred_remote
+                remote_url = repo["remotes"][preferred_remote]
+            elif preferred_remote is not None:
+                print(f"⚠️ `{preferred_remote=}` not found in {repo['remotes']}.")
+
+            try:
+                # Clone with the selected remote
+                print(f"📥 Cloning {remote_url} to {repo_path}")
+                cloned_repo = Repo.clone_from(remote_url, repo_path, origin=remote_name, depth=2)
+                print(f"✅ Successfully cloned {repo['name']}")
+
+                # Add any additional remotes
+                for other_remote_name, other_remote_url in repo["remotes"].items():
+                    if other_remote_name != remote_name:
+                        try:
+                            cloned_repo.create_remote(other_remote_name, other_remote_url)
+                            print(f"✅ Added remote {other_remote_name}")
+                        except Exception as e:
+                            print(f"⚠️ Failed to add remote {other_remote_name}: {e}")
+
+            except GitCommandError as e:
+                print(f"❌ Failed to clone {repo['name']}: {e}")
+                repo_success = False
+                continue
+            except Exception as e:
+                print(f"❌ Unexpected error cloning {repo['name']}: {e}")
+                repo_success = False
+                continue
+
+        # Handle checkout operations (after cloning/if repo exists)
+        if repo_path.exists():
+            try:
+                existing_repo = Repo(repo_path)
+
+                if checkout_to_recorded_commit:
+                    commit = repo["version"]["commit"]
+                    if isinstance(commit, str):
+                        print(f"🔀 Checking out to commit {commit[:8]}...")
+                        existing_repo.git.checkout(commit)
+                        print("✅ Checked out to recorded commit")
+                    else:
+                        print(f"⚠️ Skipping {repo['name']} because it doesn't have a commit recorded. Found {commit}")
+
+                elif checkout_to_branch:
+                    if repo.get("current_branch"):
+                        print(f"🔀 Checking out to branch {repo['current_branch']}...")
+                        existing_repo.git.checkout(repo["current_branch"])
+                        print("✅ Checked out to recorded branch")
+                    else:
+                        print(f"⚠️ No current branch recorded for {repo['name']}")
+
+                # Handle editable install
+                if editable_install:
+                    pyproject_path = repo_path / "pyproject.toml"
+                    if pyproject_path.exists():
+                        print(f"📦 Installing {repo['name']} in editable mode...")
+                        result = subprocess.run(["uv", "pip", "install", "-e", "."], cwd=repo_path, capture_output=True, text=True)
+                        if result.returncode == 0:
+                            print("✅ Editable install completed")
+                        else:
+                            print(f"❌ Editable install failed: {result.stderr}")
+                            repo_success = False
+                    else:
+                        print(f"⚠️ No pyproject.toml found in {repo['name']}, skipping editable install")
+
+                # Run uv sync if auto_sync is enabled and pyproject.toml exists
+                if auto_sync and (repo_path / "pyproject.toml").exists():
+                    sync_success = run_uv_sync(repo_path)
+                    if not sync_success:
+                        repo_success = False
+
+            except Exception as e:
+                print(f"❌ Error processing existing repository {repo['name']}: {e}")
+                repo_success = False
+
+        overall_success = overall_success and repo_success
+
+    return overall_success
+
+
+def install_repos(specs_path: str, clone: bool = True, checkout_to_recorded_commit: bool = False, checkout_to_branch: bool = False, editable_install: bool = False, preferred_remote: Optional[str] = None):
     program = ""
     path_obj = PathExtended(specs_path).expanduser().absolute()
     repos: list[dict[str, Any]] = read_json(path_obj)
@@ -197,7 +355,7 @@ def install_repos(specs_path: str, clone: bool=True, checkout_to_recorded_commit
 
         # Handle checkout operations (after all remotes are set up)
         if checkout_to_recorded_commit:
-            commit = repo['version']['commit']
+            commit = repo["version"]["commit"]
             if isinstance(commit, str):
                 program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git checkout {commit}"
             else:
@@ -214,5 +372,5 @@ def install_repos(specs_path: str, clone: bool=True, checkout_to_recorded_commit
     return program
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

machineconfig/scripts/python/snapshot.py

@@ -1,4 +1,3 @@
-
 # def main():
 #     print("\n" + "=" * 50)
 #     print("📸 Welcome to the Snapshot Tool")

machineconfig/scripts/python/start_slidev.py

@@ -2,7 +2,8 @@
 slidev
 """
 
-from machineconfig.utils.utils import CONFIG_PATH, PROGRAM_PATH, print_code
+from machineconfig.utils.source_of_truth import CONFIG_PATH, PROGRAM_PATH
+from machineconfig.utils.code import print_code
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.terminal import Terminal
 import subprocess
@@ -10,12 +11,13 @@ import platform
 
 PORT_DEFAULT = 3030
 
-SLIDEV_REPO = CONFIG_PATH.joinpath(".cache/slidev")
+SLIDEV_REPO = PathExtended(CONFIG_PATH).joinpath(".cache/slidev")
 if not SLIDEV_REPO.joinpath("components").exists():
     print("📦 Initializing Slidev repository...")
     Terminal(stderr=subprocess.PIPE, stdin=subprocess.PIPE, stdout=subprocess.PIPE).run(f"cd {SLIDEV_REPO.parent};npm init slidev@latest")
     print("✅ Slidev repository initialized successfully!\n")
 
+
 def jupyter_to_markdown(file: PathExtended):
     op_dir = file.parent.joinpath("presentation")
     print("📝 Converting Jupyter notebook to markdown...")
@@ -36,14 +38,15 @@ def jupyter_to_markdown(file: PathExtended):
     Terminal().run(cmd, shell="powershell").print()
 
     op_file = op_dir.joinpath("slides_raw.md")
-    slide_separator = '\n\n---\n\n'
-    md = op_file.read_text(encoding="utf-8").replace('\n\n\n\n', slide_separator)
+    slide_separator = "\n\n---\n\n"
+    md = op_file.read_text(encoding="utf-8").replace("\n\n\n\n", slide_separator)
     md = slide_separator.join([item for item in md.split(slide_separator) if bool(item.strip())])
     op_file.with_name("slides.md").write_text(md, encoding="utf-8")
     print(f"✅ Conversion completed! Check the results at: {op_dir}\n")
 
     return op_dir
 
+
 def main() -> None:
     import argparse
 
@@ -85,6 +88,7 @@ def main() -> None:
         SLIDEV_REPO.joinpath(md_file.name).with_name(name="slides.md", inplace=True, overwrite=True)
 
     import socket
+
     try:
         local_ip_v4 = socket.gethostbyname(socket.gethostname() + ".local")
     except Exception:
@@ -100,5 +104,6 @@ def main() -> None:
     PROGRAM_PATH.write_text(program, encoding="utf-8")
     print_code(code=program, lexer="bash", desc="Run the following command to start the presentation")
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     main()