machineconfig 1.7__py3-none-any.whl → 1.9__py3-none-any.whl

machineconfig/utils/utils.py

@@ -13,7 +13,8 @@ from rich.panel import Panel
 from rich.console import Console
 from rich.syntax import Syntax
 import platform
-from typing import Optional, Union, TypeVar
+import subprocess
+from typing import Optional, Union, TypeVar, Iterable
 
 
 LIBRARY_ROOT = P(machineconfig.__file__).resolve().parent  # .replace(P.home().str.lower(), P.home().str)
@@ -35,21 +36,20 @@ def choose_cloud_interactively() -> str:
     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 = L(tmp.splitlines()).apply(lambda x: x.replace(":", ""))
+        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(f"You don't have remotes. Configure your rclone first to get cloud services access.")
-    cloud = display_options(msg="WHICH CLOUD?", options=list(remotes), default=remotes[0], fzf=True)
-    assert isinstance(cloud, str)
+    cloud: str = choose_one_option(msg="WHICH CLOUD?", options=list(remotes), default=remotes[0], fzf=True)
     return cloud
 
 
-def sanitize_path(a_path: P):
+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[2:])  # exlcude /home/username
+            path = P.home().joinpath(*path.parts[3:])  # exlcude /home/username
             assert path.exists(), f"File not found: {path}"
             print(f"\n{'--' * 50}\n🔗 Mapped `{a_path}` ➡️ `{path}`\n{'--' * 50}\n")
         elif platform.system() == "Linux" and P.home().as_posix() not in path.as_posix():  # copied from Linux to Linux with different username
@@ -69,24 +69,56 @@ def sanitize_path(a_path: P):
     return path.expanduser().absolute()
 
 
-def match_file_name(sub_string: str):
+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."""
-    print(f"Searching for {sub_string} in {P.cwd()}")
-    search_results = P.cwd().absolute().search(f"*{sub_string}*.py", r=True)
+    root = search_root if search_root is not None else P.cwd()
+    print(f"Searching for {sub_string} in {root}")
+    search_results = root.absolute().search(f"*{sub_string}*.py", r=True)
     if len(search_results) == 1:
         path_obj = search_results.list[0]
     elif len(search_results) > 1:
-        choice = display_options(msg=f"Search results are ambiguous or non-existent", options=search_results.list, fzf=True, multi=False)
-        assert not isinstance(choice, list)
+        choice = choose_one_option(msg=f"Search results are ambiguous or non-existent", 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:
+            return match_file_name(sub_string=sub_string_small)
+        from git.repo import Repo
+        from git.exc import InvalidGitRepositoryError
+        try:
+            repo = Repo(root, search_parent_directories=True)
+            repo_root_dir = P(repo.working_dir)
+            if repo_root_dir != root:  # may be user is in a subdirectory of the repo root, try with root dir.
+                return match_file_name(sub_string=sub_string, search_root=repo_root_dir)
+            else:
+                root = repo_root_dir
+        except InvalidGitRepositoryError:
+            pass
+
+        if check_tool_exists("fzf"):
+            try:
+                search_res = subprocess.run(f"cd '{root}'; fzf --filter={sub_string}", stdout=subprocess.PIPE, text=True, check=True, shell=True).stdout.split("\n")[:-1]
+            except subprocess.CalledProcessError as cpe:
+                print(f"Failed at fzf search with {sub_string} in {root}.\n{cpe}")
+                msg = f"\n{'--' * 50}\n💥 Path {sub_string} does not exist. No search results\n{'--' * 50}\n"
+                raise FileNotFoundError(msg) from cpe
+            if len(search_res) == 1: return root.joinpath(search_res[0])
+            else:
+                try:
+                    res = subprocess.run(f"cd '{root}'; fzf --query={sub_string}", check=True, stdout=subprocess.PIPE, text=True, shell=True).stdout.strip()
+                except subprocess.CalledProcessError as cpe:
+                    print(f"Failed at fzf search with {sub_string} in {root}. {cpe}")
+                    msg = f"\n{'--' * 50}\n💥 Path {sub_string} does not exist. No search results\n{'--' * 50}\n"
+                    raise FileNotFoundError(msg) from cpe
+                return root.joinpath(res)
         msg = f"\n{'--' * 50}\n💥 Path {sub_string} does not exist. No search results\n{'--' * 50}\n"
         raise FileNotFoundError(msg)
     print(f"\n{'--' * 50}\n🔗 Matched `{sub_string}` ➡️ `{path_obj}`\n{'--' * 50}\n")
     return path_obj
 
 
-def choose_one_option(options: list[T], header: str = "", tail: str = "", prompt: str = "", msg: str = "",
+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)
@@ -94,7 +126,7 @@ def choose_one_option(options: list[T], header: str = "", tail: str = "", prompt
     return choice_key
 
 
-def choose_multiple_options(options: list[T], header: str = "", tail: str = "", prompt: str = "", msg: str = "",
+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,
@@ -103,23 +135,30 @@ def choose_multiple_options(options: list[T], header: str = "", tail: str = "",
     return [choice_key]
 
 
-def display_options(msg: str, options: list[T], header: str = "", tail: str = "", prompt: str = "",
+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):
         install_n_import("pyfzf")
         from pyfzf.pyfzf import FzfPrompt
         fzf_prompt = FzfPrompt()
         nl = "\n"
-        choice_key = fzf_prompt.prompt(choices=options, fzf_options=("--multi" if multi else "") + f' --prompt "{prompt.replace(nl, " ")}" ')  # --border-label={msg.replace(nl, ' ')}")
+        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_key = choice_key[0]
+            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"{options=}, {choice_key=}")
-                print(choice_key)
+                print(f"{options=}, {choice_string_multi=}")
+                print(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:
@@ -134,29 +173,34 @@ def display_options(msg: str, options: list[T], header: str = "", tail: str = ""
         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 == "":
-            assert default is not None, f"Default option not available!"
-            choice_idx = options.index(default)
-            choice_key = default
+            if default_string is None:
+                print(f"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, f"🧨 Default option not available!"
+            choice_one: T = default
         else:
             try:
-                choice_idx = int(choice_string)
-                choice_key = options[choice_idx]
+                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:  # string input
-                    choice_idx = options.index(choice_key)  # type: ignore #TODO: fix this
-                    choice_key = options[choice_idx]
+                if choice_string in options_strings:  # string input
+                    choice_idx = options_strings.index(choice_one)  # type: ignore #TODO: fix this
+                    choice_one = list(options)[choice_idx]
                 elif custom_input: return str(choice_string)  # type: ignore #TODO: fix this
                 else: raise ValueError(f"Unknown choice. {choice_string}") from ie
             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:  # string input
-                    choice_idx = options.index(choice_key)  # type: ignore #TODO: fix this
-                    choice_key = options[choice_idx]
-                elif custom_input: return str(choice_string)  # type: ignore #TODO: fix this
+                if choice_string in options_strings:  # string input
+                    choice_idx = options_strings.index(choice_one)  # type: ignore #TODO: fix this
+                    choice_one = list(options)[choice_idx]
+                elif custom_input:
+                    return choice_string  # type: ignore #TODO: fix this
                 else: raise ValueError(f"Unknown choice. {choice_string}") from te
-        print(f"{choice_idx}: {choice_key}", f"<<<<-------- CHOICE MADE")
-        if multi: choice_key = [choice_key]
-    return choice_key
+        print(f"{choice_idx}: {choice_one}", f"<<<<-------- CHOICE MADE")
+        if multi: return [choice_one]
+    return choice_one
 
 
 def symlink(this: P, to_this: P, prioritize_to_this: bool = True):
@@ -180,7 +224,8 @@ def symlink(this: P, to_this: P, prioritize_to_this: bool = True):
         if not to_this.exists(): to_this.touch()  # we have to touch it (file) or create it (folder)
     if platform.system() == "Windows": _ = install_n_import("win32api", "pywin32")  # this is crucial for windows to pop up the concent window in case python was not run as admin.
     try:
-        P(this).symlink_to(to_this, verbose=True, overwrite=True)
+        # print(f"Linking {this} ➡️ {to_this}")
+        P(this).symlink_to(target=to_this, verbose=True, overwrite=True)
     except Exception as ex: print(f"Failed at linking {this} ➡️ {to_this}.\nReason: {ex}")
 
 
@@ -244,30 +289,39 @@ def print_code(code: str, lexer: str, desc: str = ""):
     console.print(Panel(Syntax(code=code, lexer=lexer), title=desc), style="bold red")
 
 
-def get_latest_version(url: str) -> None:
-    # not yet used, consider, using it.
-    import requests
-    import json
-    url = f"https://api.github.com/repos/{url.split('github.com/')[1]}/releases/latest"
-    # Replace {owner} and {repo} with the actual owner and repository name
-    response = requests.get(url, timeout=10)
-    if response.status_code == 200:
-        data = json.loads(response.text)
-        latest_version = data["tag_name"]
-        print("Latest release version:", latest_version)
-    else: print("Error:", response.status_code)
+# def get_latest_version(url: str) -> None:
+#     # not yet used, consider, using it.
+#     import requests
+#     import json
+#     url = f"https://api.github.com/repos/{url.split('github.com/')[1]}/releases/latest"
+#     # Replace {owner} and {repo} with the actual owner and repository name
+#     response = requests.get(url, timeout=10)
+#     if response.status_code == 200:
+#         data = json.loads(response.text)
+#         latest_version = data["tag_name"]
+#         print("Latest release version:", latest_version)
+#     else: print("Error:", response.status_code)
+
 
+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"
 
-def check_tool_exists(tool_name: str) -> bool:
-    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")
-    import subprocess
+
     try:
-        subprocess.check_output([cmd, tool_name])
-        return True
-    except (subprocess.CalledProcessError, FileNotFoundError): return False
+        _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"Installing {tool_name} ...")
+        Terminal().run(install_script, shell="powershell").print()
+        return check_tool_exists(tool_name=tool_name, install_script=None)
+    return res
 
 
 def get_ssh_hosts() -> list[str]:
@@ -285,8 +339,7 @@ def check_dotfiles_version_is_beyond(commit_dtm: str, update: bool = False):
     repo = Repo(path=dotfiles_path)
     last_commit = repo.head.commit
     dtm = last_commit.committed_datetime
-    # make it tz unaware
-    from datetime import datetime
+    from datetime import datetime  # make it tz unaware
     dtm = datetime(dtm.year, dtm.month, dtm.day, dtm.hour, dtm.minute, dtm.second)
     res =  dtm > datetime.fromisoformat(commit_dtm)
     if res is False and update is True:

machineconfig/utils/ve.py

@@ -2,13 +2,28 @@
 """python and ve installation related utils
 """
 
-from crocodile.file_management import P, Struct, modify_text, List
+from crocodile.file_management import P, Struct, modify_text, List, Read, Save
 from machineconfig.utils.utils import LIBRARY_ROOT
 import platform
+from dataclasses import dataclass
 from typing import Optional, Literal
 
 
+@dataclass
+class VE_Specs:
+    ve_name: str
+    py_version: str
+    ipy_profile: str
+    os: str
+
+
+@dataclass
+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)
@@ -25,6 +40,7 @@ def get_ipython_profile(init_path: P):
 
 
 def get_ve_profile(init_path: P, strict: bool = False):
+    """Relies on .ve_path"""
     ve = ""
     tmp = init_path
     for _ in init_path.parents:
@@ -37,6 +53,23 @@ def get_ve_profile(init_path: P, strict: bool = False):
     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'
@@ -47,12 +80,12 @@ def get_current_ve():
 def get_installed_interpreters() -> list[P]:
     system = platform.system()
     if system == "Windows":
-        tmp: list[P] = P.get_env().PATH.search("python.exe").reduce().list[1:]
-        List(tmp).print()
+        tmp: list[P] = P.get_env().PATH.search("python.exe").reduce(func=lambda x, y: x+y).list[1:]
     else:
-        tmp = list(set(List(P.get_env().PATH.search("python3*").reduce()).filter(lambda x: not x.is_symlink() and "-" not in x)))  # type: ignore
-        List(tmp).print()
-    return [P(x) for x in tmp]
+        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]:
@@ -67,7 +100,7 @@ def get_ve_specs(ve_path: P) -> dict[str, str]:
 
 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):
+                          system: Optional[Literal["Windows", "Linux"]] = None) -> str:
     from rich.console import Console
     if system is None:
         system_: str = platform.system()
@@ -114,26 +147,97 @@ def get_ve_install_script(ve_name: Optional[str] = None, py_version: Optional[st
         text = LIBRARY_ROOT.joinpath(f"setup_{system_.lower()}/repos.{'ps1' if system_ == 'Windows' else 'sh'}").read_text()
         text = modify_text(txt_raw=text, txt_search="ve_name=", txt_alt=f"{variable_prefix}ve_name='{ve_name}'", replace_line=True)
         scripts += text
+
+    # 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)
     return scripts
 
 
-def get_ps1_install_template(ve_name: str, req_root: str, py_version: str):
+def get_ve_install_script_from_specs(repo_root: str, system: Literal["Windows", "Linux"]):
+    ini_file = P(repo_root).joinpath(".ve.ini")
+    assert ini_file.exists(), f"File {ini_file} does not exist."
+    ini = Read.ini(ini_file)
+    ve_name = ini["specs"]["ve_name"]
+    py_version = ini["specs"]["py_version"]
+    ipy_profile = ini["specs"]["ipy_profile"]
+
+    # for backward compatibility:
+    ini_file.with_name(".ve_path").write_text(f"~/venvs/{ve_name}")
+    ini_file.with_name(".ipy_profile").write_text(ipy_profile)
+
+    vscode_settings = P(repo_root).joinpath(".vscode/settings.json")
+    if vscode_settings.exists():
+        settings = Read.json(vscode_settings)
+    else:
+        settings = {}
+    if system == "Windows":
+        settings["python.defaultInterpreterPath"] = f"~/venvs/{ve_name}/Scripts/python.exe"
+    elif system == "Linux":
+        settings["python.defaultInterpreterPath"] = f"~/venvs/{ve_name}/bin/python"
+        pass
+    else:
+        raise NotImplementedError(f"System {system} not supported.")
+    Save.json(obj=settings, path=vscode_settings, indent=4)
+
+    subpath = "versions/init"
+    base_path = P(repo_root).joinpath(subpath).create()
+    if system == "Windows":
+        script = get_ps1_install_template(ve_name=ve_name, py_version=py_version)
+        base_path.joinpath("install_ve.ps1").write_text(script)
+    elif system == "Linux":
+        script = get_bash_install_template(ve_name=ve_name, py_version=py_version)
+        base_path.joinpath("install_ve.sh").write_text(script)
+    else:
+        raise NotImplementedError(f"System {system} not supported.")
+
+    base_path.joinpath("install_requirements.ps1").write_text(get_install_requirements_template(repo_root=P(repo_root), requirements_subpath=subpath))
+    base_path.joinpath("install_requirements.sh").write_text(get_install_requirements_template(repo_root=P(repo_root), requirements_subpath=subpath))
+
+    # vscode:
+    if not system == "Windows":  # symlinks on windows require admin rights.
+        P(repo_root).joinpath(".venv").symlink_to(target=P.home().joinpath("venvs", ve_name), strict=False)
+        # set strict to False since ve doesn't exist yet.
+
+    return script
+
+
+def get_ps1_install_template(ve_name: str, py_version: str):
     template = f"""
 $ve_name = '{ve_name}'
 $py_version = '{py_version}'  # type: ignore
-(Invoke-WebRequest bit.ly/cfgvewindows).Content | Invoke-Expression
+(Invoke-WebRequest https://bit.ly/cfgvewindows).Content | Invoke-Expression
 . $HOME/scripts/activate_ve $ve_name
-cd {req_root}
-pip install -r requirements_{platform.system().lower()}.txt
 """
     return template
-def get_bash_install_template(ve_name: str, req_root: str, py_version: str = "3.11"):
+def get_bash_install_template(ve_name: str, py_version: str):
     template = f"""
 export ve_name='{ve_name}'
 export py_version='{py_version}'  # type: ignore
-curl -L bit.ly/cfgvelinux | bash
-. activate_ve $ve_name
-cd {req_root}
-pip install -r requirements_{platform.system().lower()}.txt
+curl -L https://bit.ly/cfgvelinux | bash
+. $HOME/scripts/activate_ve $ve_name
 """
     return template
+
+
+def get_install_requirements_template(repo_root: P, requirements_subpath: str):
+    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.
+
+set -e  # exit on error, you don't want to install reqiurements in wrong environment.
+cd $HOME/{repo_root.rel2home().as_posix()}
+. $HOME/scripts/activate_ve
+pip install -r {requirements_subpath}/requirements.txt
+pip install -e .
+
+# cd ~/code; git clone https://github.com/thisismygitrepo/crocodile.git --origin origin
+# cd ~/code/crocodile; git remote set-url origin https://github.com/thisismygitrepo/crocodile.git
+# cd ~/code/crocodile; git remote add origin https://github.com/thisismygitrepo/crocodile.git
+# cd ~/code/crocodile; pip install -e .
+
+# cd ~/code; git clone https://github.com/thisismygitrepo/machineconfig --origin origin
+# cd ~/code/machineconfig; git remote set-url origin https://github.com/thisismygitrepo/machineconfig
+# cd ~/code/machineconfig; git remote add origin https://github.com/thisismygitrepo/machineconfig
+# cd ~/code/machineconfig; pip install -e .
+
+"""