machineconfig 1.92__py3-none-any.whl → 1.94__py3-none-any.whl

machineconfig/utils/utils_options.py

@@ -0,0 +1,163 @@
+from crocodile.core import List as L
+from crocodile.meta import Terminal
+from crocodile.file_management import P
+
+# import crocodile.environment as env
+from rich.text import Text
+from rich.panel import Panel
+from rich.console import Console
+import platform
+import subprocess
+from typing import Optional, Union, TypeVar, Iterable
+
+T = TypeVar("T")
+
+
+
+def check_tool_exists(tool_name: str, install_script: Optional[str] = None) -> bool:
+    """This is the CLI equivalent of `install_n_import` function of crocodile. """
+    if platform.system() == "Windows":
+        tool_name = tool_name.replace(".exe", "") + ".exe"
+
+    if platform.system() == "Windows": cmd = "where.exe"
+    elif platform.system() == "Linux": cmd = "which"
+    else: raise NotImplementedError(f"platform {platform.system()} not implemented")
+
+    try:
+        _tmp = subprocess.check_output([cmd, tool_name], stderr=subprocess.DEVNULL)
+        res: bool=True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        res = False
+    if res is False and install_script is not None:
+        print(f"""
+{'=' * 60}
+📥 INSTALLING TOOL | Installing {tool_name}...
+{'=' * 60}
+""")
+        Terminal().run(install_script, shell="powershell").print()
+        return check_tool_exists(tool_name=tool_name, install_script=None)
+    return res
+
+
+def choose_one_option(options: Iterable[T], header: str="", tail: str="", prompt: str="", msg: str="",
+                      default: Optional[T] = None, fzf: bool=False, custom_input: bool=False) -> T:
+    choice_key = display_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt,
+                                 default=default, fzf=fzf, multi=False, custom_input=custom_input)
+    assert not isinstance(choice_key, list)
+    return choice_key
+
+
+def choose_multiple_options(options: Iterable[T], header: str="", tail: str="", prompt: str="", msg: str="",
+                            default: Optional[T] = None, custom_input: bool=False) -> list[T]:
+    choice_key = display_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt,
+                                 default=default, fzf=True, multi=True,
+                                 custom_input=custom_input)
+    if isinstance(choice_key, list): return choice_key
+    return [choice_key]
+
+
+def display_options(msg: str, options: Iterable[T], header: str="", tail: str="", prompt: str="",
+                    default: Optional[T] = None, fzf: bool=False, multi: bool=False, custom_input: bool=False) -> Union[T, list[T]]:
+    # TODO: replace with https://github.com/tmbo/questionary
+    # # also see https://github.com/charmbracelet/gum
+    tool_name = "fzf"
+    options_strings: list[str] = [str(x) for x in options]
+    default_string = str(default) if default is not None else None
+    if fzf and check_tool_exists(tool_name):
+        from pyfzf.pyfzf import FzfPrompt
+        fzf_prompt = FzfPrompt()
+        nl = "\n"
+        choice_string_multi: list[str] = fzf_prompt.prompt(choices=options_strings, fzf_options=("--multi" if multi else "") + f' --prompt "{prompt.replace(nl, " ")}" ')  # --border-label={msg.replace(nl, ' ')}")
+        # --border=rounded doens't work on older versions of fzf installed at Ubuntu 20.04
+        if not multi:
+            try:
+                choice_one_string = choice_string_multi[0]
+                choice_idx = options_strings.index(choice_one_string)
+                return list(options)[choice_idx]
+            except IndexError as ie:
+                print(f"❌ Error: {options=}, {choice_string_multi=}")
+                print(f"🔍 Available choices: {choice_string_multi}")
+                raise ie
+        choice_idx_s = [options_strings.index(x) for x in choice_string_multi]
+        return [list(options)[x] for x in choice_idx_s]
+    else:
+        console = Console()
+        if default is not None:
+            assert default in options, f"Default `{default}` option not in options `{list(options)}`"
+            default_msg = Text(" <<<<-------- DEFAULT", style="bold red")
+        else: default_msg = Text("")
+        txt = Text("\n" + msg + "\n")
+        for idx, key in enumerate(options):
+            txt = txt + Text(f"{idx:2d} ", style="bold blue") + str(key) + (default_msg if default is not None and default == key else "") + "\n"
+        txt_panel = Panel(txt, title=header, subtitle=tail, border_style="bold red")
+
+        console.print(txt_panel)
+        if default is not None:
+            choice_string = input(f"{prompt}\nEnter option number or hit enter for default choice: ")
+        else:
+            choice_string = input(f"{prompt}\nEnter option number: ")
+
+        if choice_string == "":
+            if default_string is None:
+                print("🧨 Default option not available!")
+                return display_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, fzf=fzf, multi=multi, custom_input=custom_input)
+            choice_idx = options_strings.index(default_string)
+            assert default is not None, "🧨 Default option not available!"
+            choice_one: T = default
+        else:
+            try:
+                choice_idx = int(choice_string, base=10)
+                choice_one = list(options)[choice_idx]
+            except IndexError as ie:  # i.e. converting to integer was successful but indexing failed.
+                if choice_string in options_strings:  # string input
+                    choice_idx = options_strings.index(choice_one)  # type: ignore
+                    choice_one = list(options)[choice_idx]
+                elif custom_input: return str(choice_string)  # type: ignore
+                else:
+                    _ = ie
+                    # raise ValueError(f"Unknown choice. {choice_string}") from ie
+                    print(f"❓ Unknown choice: '{choice_string}'")
+                    return display_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, fzf=fzf, multi=multi, custom_input=custom_input)
+            except TypeError as te:  # int(choice_string) failed due to # either the number is invalid, or the input is custom.
+                if choice_string in options_strings:  # string input
+                    choice_idx = options_strings.index(choice_one)  # type: ignore
+                    choice_one = list(options)[choice_idx]
+                elif custom_input:
+                    return choice_string  # type: ignore
+                else:
+                    _ = te
+                    # raise ValueError(f"Unknown choice. {choice_string}") from te
+                    print(f"❓ Unknown choice: '{choice_string}'")
+                    return display_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, fzf=fzf, multi=multi, custom_input=custom_input)
+        print(f"✅ Selected option {choice_idx}: {choice_one}")
+        if multi: return [choice_one]
+    return choice_one
+
+
+def choose_cloud_interactively() -> str:
+    print(f"""
+{'=' * 60}
+🔍 LISTING CLOUD REMOTES | Fetching available cloud remotes...
+{'=' * 60}
+""")
+    tmp = Terminal().run("rclone listremotes").op_if_successfull_or_default(strict_returcode=False)
+    # consider this: remotes = Read.ini(P.home().joinpath(".config/rclone/rclone.conf")).sections()
+    if isinstance(tmp, str):
+        remotes: list[str] = L(tmp.splitlines()).apply(lambda x: x.replace(":", "")).list
+
+    else: raise ValueError(f"Got {tmp} from rclone listremotes")
+    if len(remotes) == 0:
+        raise RuntimeError("You don't have remotes. Configure your rclone first to get cloud services access.")
+    cloud: str = choose_one_option(msg="WHICH CLOUD?", options=list(remotes), default=remotes[0], fzf=True)
+    print(f"""
+✅ SELECTED CLOUD | {cloud}
+{'=' * 60}
+""")
+    return cloud
+
+def get_ssh_hosts() -> list[str]:
+    from paramiko import SSHConfig
+    c = SSHConfig()
+    c.parse(open(P.home().joinpath(".ssh/config").to_str(), encoding="utf-8"))
+    return list(c.get_hostnames())
+def choose_ssh_host(multi: bool=True): return display_options(msg="", options=get_ssh_hosts(), multi=multi, fzf=True)

machineconfig/utils/utils_path.py

@@ -0,0 +1,151 @@
+from crocodile.core import List as L
+from crocodile.file_management import P
+import platform
+import subprocess
+from typing import Optional, TypeVar
+from machineconfig.utils.utils_options import check_tool_exists, choose_one_option
+
+T = TypeVar("T")
+
+def sanitize_path(a_path: P) -> P:
+    path = P(a_path)
+    if path.as_posix().startswith("/home"):
+        if platform.system() == "Windows":  # path copied from Linux to Windows
+            path = P.home().joinpath(*path.parts[3:])  # exclude /home/username
+            assert path.exists(), f"File not found: {path}"
+            print(f"""
+{'=' * 60}
+🔗 PATH MAPPING | Linux → Windows: `{a_path}` ➡️ `{path}`
+{'=' * 60}
+""")
+        elif platform.system() == "Linux" and P.home().as_posix() not in path.as_posix():  # copied from Linux to Linux with different username
+            path = P.home().joinpath(*path.parts[3:])  # exclude /home/username (three parts: /, home, username)
+            assert path.exists(), f"File not found: {path}"
+            print(f"""
+{'=' * 60}
+🔗 PATH MAPPING | Linux → Linux: `{a_path}` ➡️ `{path}`
+{'=' * 60}
+""")
+    elif path.as_posix().startswith("C:"):
+        if platform.system() == "Linux":  # path copied from Windows to Linux
+            xx = str(a_path).replace("\\", "/")
+            path = P.home().joinpath(*P(xx).parts[3:])  # exclude C:\Users\username
+            assert path.exists(), f"File not found: {path}"
+            print(f"""
+{'=' * 60}
+🔗 PATH MAPPING | Windows → Linux: `{a_path}` ➡️ `{path}`
+{'=' * 60}
+""")
+        elif platform.system() == "Windows" and P.home().as_posix() not in path.as_posix():  # copied from Windows to Windows with different username
+            path = P.home().joinpath(*path.parts[2:])
+            assert path.exists(), f"File not found: {path}"
+            print(f"""
+{'=' * 60}
+🔗 PATH MAPPING | Windows → Windows: `{a_path}` ➡️ `{path}`
+{'=' * 60}
+""")
+    return path.expanduser().absolute()
+
+def match_file_name(sub_string: str, search_root: Optional[P] = None) -> P:
+    """Look up current directory for file name that matches the passed substring."""
+    search_root_obj = search_root if search_root is not None else P.cwd()
+    search_root_obj = search_root_obj.absolute()
+    print(f"""
+{'=' * 60}
+🔍 SEARCH | Looking for '{sub_string}' in {search_root_obj}
+{'=' * 60}
+""")
+
+    search_root_objects = search_root_obj.search("*", not_in=["links", ".venv", ".git", ".idea", ".vscode", "node_modules", "__pycache__"])
+    search_results: L[P] = L([a_search_root_obj.search(f"*{sub_string}*", r=True) for a_search_root_obj in search_root_objects]).reduce(lambda x, y: x + y)  # type: ignore
+    search_results = search_results.filter(lambda x: x.suffix in (".py", ".sh", ".ps1"))
+
+    if len(search_results) == 1:
+        path_obj = search_results.list[0]
+    elif len(search_results) > 1:
+        msg = "Search results are ambiguous or non-existent, choose manually:"
+        print(f"""
+⚠️  WARNING | {msg}
+{'=' * 60}
+""")
+        choice = choose_one_option(msg=msg, options=search_results.list, fzf=True)
+        path_obj = P(choice)
+    else:
+        # let's do a final retry with sub_string.small()
+        sub_string_small = sub_string.lower()
+        if sub_string_small != sub_string:
+            print(f"""
+🔄 RETRY | Searching with lowercase letters
+{'=' * 60}
+""")
+            return match_file_name(sub_string=sub_string_small)
+        from git.repo import Repo
+        from git.exc import InvalidGitRepositoryError
+        try:
+            repo = Repo(search_root_obj, search_parent_directories=True)
+            repo_root_dir = P(repo.working_dir)
+            if repo_root_dir != search_root_obj:  # may be user is in a subdirectory of the repo root, try with root dir.
+                print(f"""
+🔄 RETRY | Searching from repository root instead of current directory
+{'=' * 60}
+""")
+                return match_file_name(sub_string=sub_string, search_root=repo_root_dir)
+            else:
+                search_root_obj = repo_root_dir
+        except InvalidGitRepositoryError:
+            pass
+
+        if check_tool_exists(tool_name="fzf"):
+            try:
+                print(f"""
+🔍 SEARCH STRATEGY | Using fd to search for '{sub_string}' in '{search_root_obj}' ...
+{'=' * 60}
+""")
+                fzf_cmd = f"cd '{search_root_obj}'; fd --type f --strip-cwd-prefix | fzf --filter={sub_string}"
+                search_res = subprocess.run(fzf_cmd, stdout=subprocess.PIPE, text=True, check=True, shell=True).stdout.split("\n")[:-1]
+            except subprocess.CalledProcessError as cpe:
+                print(f"""
+❌ ERROR | FZF search failed with '{sub_string}' in '{search_root_obj}'.
+{cpe}
+{'=' * 60}
+""")
+                msg = f"""
+{'=' * 60}
+💥 FILE NOT FOUND | Path {sub_string} does not exist. No search results
+{'=' * 60}
+"""
+                raise FileNotFoundError(msg) from cpe
+
+            if len(search_res) == 1: return search_root_obj.joinpath(search_res[0])
+            else:
+                print(f"""
+🔍 SEARCH STRATEGY | Trying with raw fzf search ...
+{'=' * 60}
+""")
+                try:
+                    res = subprocess.run(f"cd '{search_root_obj}'; fd | fzf --query={sub_string}", check=True, stdout=subprocess.PIPE, text=True, shell=True).stdout.strip()
+                except subprocess.CalledProcessError as cpe:
+                    print(f"""
+❌ ERROR | FZF search failed with '{sub_string}' in '{search_root_obj}'. {cpe}
+{'=' * 60}
+""")
+                    msg = f"""
+{'=' * 60}
+💥 FILE NOT FOUND | Path {sub_string} does not exist. No search results
+{'=' * 60}
+"""
+                    raise FileNotFoundError(msg) from cpe
+                return search_root_obj.joinpath(res)
+
+        msg = f"""
+{'=' * 60}
+💥 FILE NOT FOUND | Path {sub_string} does not exist. No search results
+{'=' * 60}
+"""
+        raise FileNotFoundError(msg)
+    print(f"""
+{'=' * 60}
+✅ MATCH FOUND | `{sub_string}` ➡️ `{path_obj}`
+{'=' * 60}
+""")
+    return path_obj

machineconfig/utils/ve.py

@@ -1,15 +1,23 @@
-
 """python and ve installation related utils
 """
 
-from crocodile.core import Struct, Save, List
-from crocodile.file_management import P, Read
+from crocodile.core import Struct, List
+from crocodile.file_management import P
 
-from machineconfig.utils.utils import LIBRARY_ROOT
 import platform
-from dataclasses import dataclass, asdict
+from dataclasses import dataclass
 from typing import Optional, Literal
 
+from machineconfig.utils.ve_utils.ve1 import get_installed_interpreters
+from machineconfig.utils.ve_utils.ve1 import get_ve_specs
+from machineconfig.utils.ve_utils.ve2 import get_bash_repos_install_script
+from machineconfig.utils.ve_utils.ve2 import get_ps1_repos_install_script
+from machineconfig.utils.ve_utils.ve2 import get_bash_ve_install_script
+from machineconfig.utils.ve_utils.ve2 import get_ps1_ve_install_script
+from machineconfig.utils.ve_utils.ve2 import create_symlinks
+from machineconfig.utils.ve_utils.ve2 import make_installation_recipe
+
+
 
 @dataclass
 class VE_Specs:
@@ -24,124 +32,60 @@ class VE_INI:
     specs: VE_Specs
 
 
-def get_ipython_profile(init_path: P):
-    """Relies on .ipy_profile"""
-    a_path = init_path
-    ipy_profile: str="default"
-    idx = len(a_path.parts)
-    while idx >= 0:
-        if a_path.joinpath(".ipy_profile").exists():
-            ipy_profile = a_path.joinpath(".ipy_profile").read_text().rstrip()
-            print(f"✅ Using IPython profile: {ipy_profile}")
-            break
-        idx -= 1
-        a_path = a_path.parent
-    else:
-        print(f"⚠️ Using default IPython: {ipy_profile}")
-    return ipy_profile
-def get_ve_profile(init_path: P, strict: bool=False):
-    """Relies on .ve_path"""
-    ve = ""
-    tmp = init_path
-    for _ in init_path.parents:
-        if tmp.joinpath(".ve_path").exists():
-            ve = P(tmp.joinpath(".ve_path").read_text().rstrip().replace("\n", "")).name
-            print(f"✅ Using Virtual Environment: {ve}")
-            break
-        tmp = tmp.parent
-    if ve == "" and strict: raise ValueError("❌ No virtual environment found.")
-    return ve
-def get_ve_name_and_ipython_profile(init_path: P):
-    ve_name = "ve"
-    ipy_profile = "default"
-    tmp = init_path
-    for _ in init_path.parents:
-        if tmp.joinpath(".ve.ini").exists():
-            ini = Read.ini(tmp.joinpath(".ve.ini"))
-            ve_name = ini["specs"]["ve_name"]
-            # py_version = ini["specs"]["py_version"]
-            ipy_profile = ini["specs"]["ipy_profile"]
-            print(f"✅ Using Virtual Environment: {ve_name}")
-            print(f"✅ Using IPython profile: {ipy_profile}")
-            break
-        tmp = tmp.parent
-    return ve_name, ipy_profile
-def get_current_ve():
-    import sys
-    path = P(sys.executable)  # something like ~\\venvs\\ve\\Scripts\\python.exe'
-    if str(P.home().joinpath("venvs")) in str(path): return path.parent.parent.stem
-    else: raise NotImplementedError("Not a kind of virtual enviroment that I expected.")
-
-
-def get_installed_interpreters() -> list[P]:
-    system = platform.system()
-    if system == "Windows":
-        tmp: list[P] = P.get_env().PATH.search("python.exe").reduce(func=lambda x, y: x+y).list[1:]
-    else:
-        items: List[P] = P.get_env().PATH.search("python3*").reduce(lambda x, y: x+y)
-        tmp = list(set(items.filter(lambda x: not x.is_symlink() and "-" not in x)))
-    List(tmp).print()
-    return list(set([P(x) for x in tmp]))
-def get_ve_specs(ve_path: P) -> dict[str, str]:
-    ini = r"[mysection]\n" + ve_path.joinpath("pyvenv.cfg").read_text()
-    import configparser
-    config = configparser.ConfigParser()
-    config.read_string(ini)
-    res = dict(config['mysection'])
-    # try:
-    #     res['version_major_minor'] = ".".join(res['version'].split(".")[0:2])
-    # except KeyError:
-    #     # res['version_major_minor'] = ".".join(res['version_info'].split(".")[0:2])
-    return res
-
-
 def get_ve_install_script(ve_name: Optional[str] = None, py_version: Optional[str] = None,
                           install_crocodile_and_machineconfig: Optional[bool] = None,
                           delete_if_exists: bool=True,
-                        #   system: Optional[Literal["Windows", "Linux"]] = None
                           ) -> str:
     from rich.console import Console
     console = Console()
     if py_version is None:
-        print("\n\n")
-        console.rule("Existing Python versions", style="bold red")
+        print("""
+{'=' * 60}
+🔍 AVAILABLE PYTHON VERSIONS
+{'=' * 60}
+""")
         res = get_installed_interpreters()
         List(res).print()
-        print("\n\n")
-        dotted_py_version = input("Enter python version (3.11): ") or "3.11"
+        print("""
+{'=' * 60}
+""")
+        dotted_py_version = input("🔢 Enter python version (3.11): ") or "3.11"
     else:
         dotted_py_version = py_version
 
     if ve_name is None:
-        console.rule("Existing virtual environments")
+        console.rule("📦 Existing Virtual Environments")
         for ve_path in P.home().joinpath("venvs").search("*", files=False):
             try:
                 ve_specs = get_ve_specs(ve_path)
             except Exception as _e:
                 continue
             Struct(ve_specs).print(title=ve_path.stem, as_config=True)
-        ve_name = input("Enter virtual environment name (tst): ") or "tst"
+        default_ve_name = P.cwd().name
+        ve_name = input(f"📝 Enter virtual environment name ({default_ve_name}): ") or default_ve_name
 
     if install_crocodile_and_machineconfig is None:
-        essential_repos = input("Install essential repos? (y/[n]): ") == "y"
-        other_repos = input("Input space separated other packages: ")
+        essential_repos = input("🔄 Install essential repos? (y/[n]): ") == "y"
+        other_repos = input("📦 Input space separated other packages: ")
     else:
         essential_repos = install_crocodile_and_machineconfig
         other_repos = ""
 
     env_path = P.home().joinpath("venvs", ve_name)
     if delete_if_exists and env_path.exists():
-        sure = input(f"An existing environment found. Are you sure you want to delete {env_path} before making new one? (y/[n]): ") == "y"
-        console.rule("Deleting existing enviroment with similar name")
+        sure = input(f"⚠️ An existing environment found. Are you sure you want to delete {env_path} before making new one? (y/[n]): ") == "y"
+        console.rule("🗑️ Deleting existing environment with similar name")
         env_path.delete(sure=sure)
 
-    system = platform.system()
-    if system == "Windows":
+    system: Literal["Windows", "Linux"]
+    if platform.system() == "Windows":
+        system = "Windows"
         script = get_ps1_ve_install_script(ve_name=ve_name, py_version=dotted_py_version, use_web=False, system=system)
-    elif system == "Linux":
+    elif platform.system() == "Linux":
+        system = "Linux"
         script = get_bash_ve_install_script(ve_name=ve_name, py_version=dotted_py_version, use_web=False, system=system)
     else:
-        raise NotImplementedError(f"System {system} not supported.")
+        raise NotImplementedError(f"❌ System {platform.system()} not supported.")
 
     if essential_repos:
         if system == "Windows":
@@ -149,145 +93,13 @@ def get_ve_install_script(ve_name: Optional[str] = None, py_version: Optional[st
         elif system == "Linux":
             script += "\n" + get_bash_repos_install_script(ve_name=ve_name, use_web=False, system=system)
         else:
-            raise NotImplementedError(f"System {system} not supported.")
+            raise NotImplementedError(f"❌ System {system} not supported.")
 
     if other_repos != "":
-        # TODO: check the quivalent full path of uv on windows $HOME/.local/bin/
         script += "\nuv pip install " + other_repos
-    # target = repo_root.joinpath(".venv")
-    # source = P.home().joinpath("venvs", ve_name)
-    # if system == "Windows": cmd = f'New-Item -ItemType SymbolicLink -Path "{target}" -Target "{source}"'
-    # elif system == "Linux": cmd = f'ln -s "{source}" "{target}"'
-    # else: raise NotImplementedError(f"System {system} not supported.")
-    # script += f"\n{cmd}"
 
-    link_ve: str=input("Create symlinks? [y/[n]] ") == "y"
+    link_ve: bool = input("🔗 Create symlinks? [y/[n]] ") == "y"
     if link_ve: create_symlinks(repo_root=P.cwd(), ve_name=ve_name, dotted_py_version=dotted_py_version, system=system, ipy_profile="default")
     make_installation_recipe(repo_root=P.cwd(), ve_name=ve_name, py_version=dotted_py_version)
     return script
 
-
-def create_symlinks(repo_root: P, ve_name: str, dotted_py_version: str, system: Literal["Windows", "Linux"], ipy_profile: str):
-    from machineconfig.utils.utils import symlink_func
-    source = repo_root.joinpath(".venv")
-    target = P.home().joinpath("venvs", ve_name)
-    target.mkdir(exist_ok=True, parents=True)  # if ve not created yet, make up a folder at least, so that symlink can be created, then this folder is either populated or recreated by ve creation script.
-    symlink_func(this=source, to_this=target)
-
-    # for backward compatibility:
-    repo_root.joinpath(".ve_path").write_text(f"~/venvs/{ve_name}")
-    repo_root.joinpath(".ipy_profile").write_text(ipy_profile)
-
-    ve_ini_specs = VE_Specs(ve_name=ve_name, py_version=dotted_py_version, ipy_profile="default", os=system)
-    ve_ini = VE_INI(specs=ve_ini_specs)
-    Save.ini(obj=asdict(ve_ini), path=repo_root.joinpath(".ve.ini"))
-    vscode = repo_root.joinpath(".vscode/settings.json")
-    if vscode.exists():
-        settings = Read.json(vscode)
-    else:
-        settings = {}
-    if system == "Windows":
-        settings["python.defaultInterpreterPath"] = P.home().joinpath("venvs", ve_name, "Scripts", "python.exe").as_posix()
-    elif system == "Linux":
-        settings["python.defaultInterpreterPath"] = P.home().joinpath("venvs", ve_name, "bin", "python").as_posix()
-    else:
-        raise NotImplementedError(f"System {system} not supported.")
-    Save.json(obj=settings, path=vscode, indent=4)
-
-
-def make_installation_recipe(repo_root: str, ve_name: str, py_version: str):
-    subpath = "versions/init"
-    base_path = P(repo_root).joinpath(subpath).create()
-
-    system = "Windows"
-    path3 = base_path.joinpath("install_requirements.ps1")
-    if path3.exists(): print(f"❌ File already exists @ {path3}, skipping.")
-    else:
-        install_ve_script = get_ps1_ve_install_script(ve_name=ve_name, py_version=py_version, use_web=True, system=system)
-        install_req_script = get_install_requirements_template(repo_root=P(repo_root), requirements_subpath=subpath, ve_name=ve_name, system=system)
-        path3.write_text(install_ve_script + "\n" + install_req_script)
-
-    system= "Linux"
-    path4 = base_path.joinpath("install_requirements.sh")
-    if path4.exists(): print(f"❌ File already exists @ {path4}, skipping.")
-    else:
-        install_ve_script = get_bash_ve_install_script(ve_name=ve_name, py_version=py_version, use_web=True, system=system)
-        install_req_script = get_install_requirements_template(repo_root=P(repo_root), requirements_subpath=subpath, ve_name=ve_name, system=system)
-        path4.write_text(install_ve_script + "\n" + install_req_script)
-    return None
-
-
-def get_ps1_ve_install_script(ve_name: str, py_version: str, use_web: bool, system: Literal["Windows", "Linux"]):
-    if use_web:
-        install_line = """(Invoke-WebRequest https://bit.ly/cfgvewindows).Content | Invoke-Expression"""
-    else:
-        install_line = LIBRARY_ROOT.joinpath(f"setup_{system.lower()}/ve.{'ps1' if system == 'Windows' else 'sh'}").read_text()
-    template = f"""
-$ve_name = '{ve_name}'
-$py_version = '{py_version}'  # type: ignore
-{install_line}
-. $HOME/scripts/activate_ve $ve_name
-"""
-    return template
-def get_bash_ve_install_script(ve_name: str, py_version: str, use_web: bool, system: Literal["Windows", "Linux"]):
-    if use_web: install_line = """curl -L https://bit.ly/cfgvelinux | bash"""
-    else:
-        install_line = LIBRARY_ROOT.joinpath(f"setup_{system.lower()}/ve.{'ps1' if system == 'Windows' else 'sh'}").read_text()
-    template = f"""
-export ve_name='{ve_name}'
-export py_version='{py_version}'  # type: ignore
-{install_line}
-. $HOME/scripts/activate_ve $ve_name
-"""
-    return template
-def get_ps1_repos_install_script(ve_name: str, use_web: bool, system: Literal["Windows", "Linux"]):
-    if use_web: install_line = """(Invoke-WebRequest https://bit.ly/cfgreposwindows).Content | Invoke-Expression"""
-    else:
-        install_line = LIBRARY_ROOT.joinpath(f"setup_{system.lower()}/repos.{'ps1' if system == 'Windows' else 'sh'}").read_text()
-    template = f"""
-$ve_name = '{ve_name}'
-. $HOME/scripts/activate_ve $ve_name
-{install_line}
-"""
-    return template
-
-def get_bash_repos_install_script(ve_name: str, use_web: bool, system: Literal["Windows", "Linux"]):
-    if use_web: install_line = """curl -L https://bit.ly/cfgreposlinux | bash"""
-    else:
-        install_line = LIBRARY_ROOT.joinpath(f"setup_{system.lower()}/repos.{'ps1' if system == 'Windows' else 'sh'}").read_text()
-    template = f"""
-export ve_name='{ve_name}'
-. $HOME/scripts/activate_ve $ve_name
-{install_line}
-"""
-    return template
-def get_install_requirements_template(repo_root: P, requirements_subpath: str, ve_name: str, system: Literal["Windows", "Linux"]):
-    if system == 'Windows':
-        set_e_equivalent = 'Set-StrictMode -Version Latest'  # PowerShell equivalent
-        install_line = """(Invoke-WebRequest https://bit.ly/cfgreposwindows).Content | Invoke-Expression"""
-        activate_ve = fr"""$HOME\venvs\{ve_name}\Scripts\Activate.ps1 -ErrorAction Stop """
-    elif system == 'Linux':
-        set_e_equivalent = 'set -e'  # Bash equivalent
-        install_line = """curl -L https://bit.ly/cfgreposlinux | bash"""
-        activate_ve = fr""". $HOME/venvs/{ve_name}/bin/activate """
-    else: raise NotImplementedError(f"System {system} not supported.")
-    return f"""
-    
-# This is a template that is meant to be modified manually to install requirements.txt and editable packages.
-# one can dispense with this and install libraries manually and on adhoc-basis and then use version_checkout utility.
-
-# mkdir -p $HOME/{repo_root.rel2home().as_posix()}
-# cd $HOME/{repo_root.rel2home().as_posix()}
-# git clone URL --depth 2
-
-{set_e_equivalent}
-
-cd $HOME/{repo_root.rel2home().as_posix()}
-
-{activate_ve}
-
-# {install_line}
-pip install -r {requirements_subpath}/requirements.txt
-# pip install -e .
-
-"""