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

machineconfig/jobs/python_custom_installers/vscode.py

@@ -0,0 +1,45 @@
+
+"""vs code installer as per https://code.visualstudio.com/docs/setup/linux
+"""
+
+from typing import Optional
+import platform
+
+
+config_dict = {
+        "repo_url": "CUSTOM",
+        "doc": "Visual Studio Code",
+        "filename_template_windows_amd_64": "VSCodeSetup-{}.exe",
+        "filename_template_linux_amd_64": "code_{}.deb",
+        "strip_v": True,
+        "exe_name": "code"
+    }
+
+
+def main(version: Optional[str] = None):
+
+    if platform.system() == 'Linux':
+        code = """
+
+sudo apt-get install wget gpg
+wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
+sudo install -D -o root -g root -m 644 packages.microsoft.gpg /etc/apt/keyrings/packages.microsoft.gpg
+sudo sh -c 'echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/keyrings/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'
+rm -f packages.microsoft.gpg
+
+sudo apt install apt-transport-https -y
+sudo apt update
+sudo apt install code -y # or code-insiders
+
+"""
+
+    elif platform.system() == 'Windows':
+        code = "winget install -e --id Microsoft.VisualStudioCode"
+    else:
+        raise NotImplementedError(f"Unsupported platform: {platform.system()}")
+    _ = version
+    return code
+
+
+if __name__ == '__main__':
+    pass

machineconfig/jobs/python_custom_installers/wezterm.py

@@ -0,0 +1,41 @@
+
+"""wezterm installer
+"""
+
+from machineconfig.utils.installer import Installer
+from typing import Optional
+import platform
+
+
+config_dict = {
+        "repo_url": "https://github.com/wez/wezterm",
+        "doc": "cross-platform terminal emulator",
+        "filename_template_windows_amd_64": "WezTerm-windows-{}.zip",
+        "filename_template_linux_amd_64": "wezterm-{}.Ubuntu22.04.deb",
+        "strip_v": False,
+        "exe_name": "wezterm"
+    }
+
+
+def main(version: Optional[str]):
+    if platform.system() == "Windows":
+        program = "winget install --Id wez.wezterm --source winget --accept-package-agreements --accept-source-agreements"
+    elif platform.system() == "Linux":
+        inst = Installer.from_dict(d=config_dict, name="wezterm")
+        program = ""
+        # as per https://wezfurlong.org/wezterm/install/linux.html#installing-on-ubuntu-and-debian-based-systems
+        downloaded, version_to_be_installed = inst.download(version=version)
+        _= version_to_be_installed
+
+        program = f"""
+sudo apt install -y {downloaded}
+rm {downloaded}
+"""
+    else:
+        raise NotImplementedError("unsupported platform")
+    return program
+
+
+if __name__ == "__main__":
+    # main(version=None)
+    pass

machineconfig/profile/create.py

@@ -5,8 +5,10 @@ This script Takes away all config files from the computer, place them in one dir
 
 """
 
-import crocodile.toolbox as tb
+
 from crocodile.environment import system, UserName  # ProgramFiles, WindowsApps  # , exe
+from crocodile.meta import Terminal
+from crocodile.file_management import P
 from machineconfig.utils.utils import symlink, LIBRARY_ROOT, REPO_ROOT, display_options
 from machineconfig.profile.shell import create_default_shell_profile
 # import os
@@ -24,7 +26,7 @@ SYSTEM = system.lower()
 # =================== SYMLINKS ====================================
 
 
-def symlink_contents(source_dir: tb.P, target_dir: tb.P, overwrite: bool = True):
+def symlink_contents(source_dir: P, target_dir: P, overwrite: bool = True):
     for a_target in target_dir.expanduser().search("*"):
         symlink(this=source_dir.joinpath(a_target.name), to_this=a_target, prioritize_to_this=overwrite)
 
@@ -58,7 +60,7 @@ def main_symlinks(choice: Optional[str] = None):
     else: choice_selected = choice
 
     if isinstance(choice_selected, str):
-        if str(choice_selected) == "all" and system == "Windows" and not tb.Terminal.is_user_admin():
+        if str(choice_selected) == "all" and system == "Windows" and not Terminal.is_user_admin():
             print("*" * 200)
             raise RuntimeError(f"Run terminal as admin and try again, otherwise, there will be too many popups for admin requests and no chance to terminate the program.")
         elif choice_selected == "all":
@@ -69,8 +71,8 @@ def main_symlinks(choice: Optional[str] = None):
 
     for program_key in program_keys:
         for file_key, file_map in symlink_mapper[program_key].items():
-            this = tb.P(file_map['this'])
-            to_this = tb.P(file_map['to_this'].replace("REPO_ROOT", REPO_ROOT.as_posix()).replace("LIBRARY_ROOT", LIBRARY_ROOT.as_posix()))
+            this = P(file_map['this'])
+            to_this = P(file_map['to_this'].replace("REPO_ROOT", REPO_ROOT.as_posix()).replace("LIBRARY_ROOT", LIBRARY_ROOT.as_posix()))
             if "contents" in file_map:
                 try: symlink_contents(source_dir=this, target_dir=to_this, overwrite=overwrite)
                 except Exception as ex: print("Config error: ", program_key, file_key, "missing keys 'this ==> to_this'.", ex)
@@ -82,12 +84,15 @@ def main_symlinks(choice: Optional[str] = None):
                 try:
                     subprocess.run(f"chmod 700 ~/.ssh/", check=True)
                     subprocess.run(f"chmod 700 ~/dotfiles/creds/.ssh/", check=True)  # may require sudo
-                    subprocess.run(f"chmod 600 ~/dotfiles/creds/.ssh//*", check=True)
+                    subprocess.run(f"chmod 600 ~/dotfiles/creds/.ssh/*", check=True)
                 except Exception as e:
                     ERROR_LIST.append(e)
                     print("Caught error", e)
 
-    if system == "Linux": tb.Terminal().run(f'chmod +x {LIBRARY_ROOT.joinpath(f"scripts/{system.lower()}")} -R')
+    if system == "Linux": Terminal().run(f'chmod +x {LIBRARY_ROOT.joinpath(f"scripts/{system.lower()}")} -R')
+    print("\n\n", "*" * 200)
+    if len(ERROR_LIST) > 0:
+        print("Errors caught: ", ERROR_LIST)
 
 
 def main(choice: Optional[str] = None):

machineconfig/profile/shell.py

@@ -3,7 +3,9 @@
 """
 
 from crocodile.environment import PathVar
-import crocodile.toolbox as tb
+from crocodile.core import randstr
+from crocodile.file_management import P
+from crocodile.meta import Terminal
 from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT, display_options
 import platform
 from typing import Optional
@@ -27,7 +29,7 @@ def create_default_shell_profile():
     else:
         profile += "\n" + source + "\n"
         if system == "Linux":
-            res = tb.Terminal().run("cat /proc/version").op
+            res = Terminal().run("cat /proc/version").op
             if "microsoft" in res.lower() or "wsl" in res.lower():
                 profile += "\ncd ~"  # this is to make sure that the current dir is not in the windows file system, which is terribly slow and its a bad idea to be there anyway.
         profile_path.create(parents_only=True).write_text(profile)
@@ -35,10 +37,10 @@ def create_default_shell_profile():
 
 def get_shell_profile_path():
     if system == "Windows":
-        res = tb.Terminal().run("$profile", shell="pwsh").op2path()
-        if isinstance(res, tb.P): profile_path = res
+        res = Terminal().run("$profile", shell="pwsh").op2path()
+        if isinstance(res, P): profile_path = res
         else: raise ValueError(f"Could not get profile path for Windows. Got {res}")
-    elif system == "Linux": profile_path = tb.P("~/.bashrc").expanduser()
+    elif system == "Linux": profile_path = P("~/.bashrc").expanduser()
     else: raise ValueError(f"Not implemented for this system {system}")
     print(f"Working on shell profile `{profile_path}`")
     return profile_path
@@ -49,7 +51,7 @@ def main_env_path(choice: Optional[str] = None, profile_path: Optional[str] = No
     dirs = env_path[f'path_{system.lower()}']['extension']
 
     print(f"Current PATH: ", "\n============")
-    tb.P.get_env().PATH.print()
+    P.get_env().PATH.print()
 
     if choice is None:
         tmp = display_options(msg="Which directory to add?", options=dirs + ["all", "none(EXIT)"], default="none(EXIT)")
@@ -59,8 +61,8 @@ def main_env_path(choice: Optional[str] = None, profile_path: Optional[str] = No
     if choice == "none(EXIT)": return
 
     addition = PathVar.append_temporarily(dirs=dirs)
-    profile_path_obj = tb.P(profile_path) if isinstance(profile_path, str) else get_shell_profile_path()
-    profile_path_obj.copy(name=profile_path_obj.name + f".orig_" + tb.randstr())
+    profile_path_obj = P(profile_path) if isinstance(profile_path, str) else get_shell_profile_path()
+    profile_path_obj.copy(name=profile_path_obj.name + f".orig_" + randstr())
     profile_path_obj.modify_text(addition, addition, replace_line=False, notfound_append=True)
 
 
@@ -78,13 +80,13 @@ def main_add_sources_to_shell_profile(profile_path: Optional[str] = None, choice
     elif choice == "none(EXIT)": return
 
     if isinstance(profile_path, str):
-        profile_path_obj = tb.P(profile_path)
+        profile_path_obj = P(profile_path)
     else: profile_path_obj = get_shell_profile_path()
     profile = profile_path_obj.read_text()
 
     for a_file in sources:
         tmp = a_file.replace("REPO_ROOT", REPO_ROOT.as_posix()).replace("LIBRARY_ROOT", LIBRARY_ROOT.as_posix())
-        file = tb.P(tmp).collapseuser()  # this makes the shell profile interuseable across machines.
+        file = P(tmp).collapseuser()  # this makes the shell profile interuseable across machines.
         file = file.as_posix() if system == "Linux" else str(file)
         if file not in profile:
             if system == "Windows": profile += f"\n. {file}"
@@ -104,17 +106,17 @@ def main_add_patches_to_shell_profile(profile_path: Optional[str] = None, choice
     elif str(choice) == "all": pass  # i.e. patches = patches
     else: patches = [choice]
 
-    profile_path_obj = tb.P(profile_path) if isinstance(profile_path, str) else get_shell_profile_path()
+    profile_path_obj = P(profile_path) if isinstance(profile_path, str) else get_shell_profile_path()
     profile = profile_path_obj.read_text()
 
     for patch_path in patches:
-        patch_path_obj = tb.P(patch_path)
+        patch_path_obj = P(patch_path)
         patch = patch_path_obj.read_text()
         if patch in profile: print(f"Skipping `{patch_path_obj.name}`; patch already in profile")
         else: profile += "\n" + patch
 
     if system == "Linux":
-        res = tb.Terminal().run("cat /proc/version").op
+        res = Terminal().run("cat /proc/version").op
         if "microsoft" in res.lower() or "wsl" in res.lower():
             profile += "\ncd ~"  # this is to make sure that the current dir is not in the windows file system, which is terribly slow and its a bad idea to be there anyway.
 

machineconfig/scripts/python/choose_wezterm_theme.py

@@ -0,0 +1,96 @@
+
+"""
+Choose a theme for Wezterm
+"""
+
+from machineconfig.utils.utils import choose_one_option, P
+from typing import Any
+import time
+
+
+schemes_list = [
+    'Pro',
+    'Spiderman',
+    'shades-of-purple',
+    'synthwave',
+    'Symfonic',
+    'PaulMillr',
+    'Neon',
+    'LiquidCarbonTransparentInverse',
+    'Laser',
+    'IR_Black',
+    'Hurtado',
+    'Homebrew',
+    'Hipster Green',
+    'Firefly Traditional',
+    'Elementary',
+    'deep',
+    'Dark Pastel',
+    'Bright Lights',
+    'Adventure',
+    'Nancy (terminal.sexy)',
+    'Bim (Gogh)',
+    'BlueDolphin',
+    'Borland',
+    'Grass (Gogh)',
+    'Greenscreen (light) (terminal.sexy)',
+    'Grayscale (dark) (terminal.sexy)',
+]
+
+
+def main2():
+    option = choose_one_option(options=schemes_list, header="Choose a theme for Wezterm", fzf=True)
+    set_theme(option)
+
+
+def set_theme(theme: str):
+    txt_lines = P("~/.config/wezterm/wezterm.lua").expanduser().read_text().splitlines()
+    res_lines = []
+    for line in txt_lines:
+        if 'config.color_scheme = ' in line:
+            res_lines.append(f"config.color_scheme = '{theme}'")
+        else: res_lines.append(line)
+    P("~/.config/wezterm/wezterm.lua").expanduser().write_text('\n'.join(res_lines))
+    time.sleep(0.1)
+
+
+def main():
+    import curses  # not availble on windows: https://docs.python.org/3/howto/curses.html
+    # from curses import wrapper
+    curses.wrapper(accessory)
+
+def accessory(stdscr: Any):
+    import curses
+    options = schemes_list
+    current_option = 0
+    page_size = stdscr.getmaxyx()[0] - 1  # curses.LINES - 1  # Number of lines in the terminal, -1 for status line
+
+    while True:
+        stdscr.clear()
+
+        # Calculate start and end indices for options
+        start_index = (current_option // page_size) * page_size
+        end_index = start_index + page_size
+
+        # Display options
+        for i, option in enumerate(options[start_index:end_index]):
+            if start_index + i == current_option:
+                stdscr.addstr(i, 0, option, curses.A_REVERSE)  # Highlighted
+            else:
+                stdscr.addstr(i, 0, option)
+
+        # Display status line
+        status_line = f"Option {current_option+1} of {len(options)}. Use arrow keys to navigate, Enter to select."
+        stdscr.addstr(page_size, 0, status_line)
+
+        # Get key press
+        key = stdscr.getch()
+
+        # Handle key press
+        if key == curses.KEY_UP and current_option > 0:
+            current_option -= 1
+        elif key == curses.KEY_DOWN and current_option < len(options) - 1:
+            current_option += 1
+        elif key == ord('\n'):  # Enter key
+            break  # Exit the loop
+        set_theme(options[current_option])

machineconfig/scripts/python/cloud_copy.py

@@ -14,12 +14,13 @@ from typing import Optional
 
 
 @RepeatUntilNoException()
-def get_shared_file(url: Optional[str] = None, folder: Optional[str] = None):
+def get_securely_shared_file(url: Optional[str] = None, folder: Optional[str] = None) -> None:
+    folder_obj = P.cwd() if folder is None else P(folder)
 
     if os.environ.get("DECRYPTION_PASSWORD") is not None:
-        pwd = os.environ.get("DECRYPTION_PASSWORD")
+        pwd: str = str(os.environ.get("DECRYPTION_PASSWORD"))
     else:
-        pwd = getpass.getpass("Enter decryption password: ")
+        pwd = getpass.getpass(prompt="Enter decryption password: ")
 
     if url is None:
         if os.environ.get("SHARE_URL") is not None:
@@ -31,10 +32,12 @@ def get_shared_file(url: Optional[str] = None, folder: Optional[str] = None):
     from rich.progress import Progress
     with Progress(transient=True) as progress:
         _task = progress.add_task("Downloading ... ", total=None)
-        url_obj = P(url).download(folder=folder)
+        url_obj = P(url).download(folder=folder_obj)
     with Progress(transient=True) as progress:
         _task = progress.add_task("Decrypting ... ", total=None)
-        res = url_obj.decrypt(pwd=pwd, inplace=True).unzip(inplace=True, merge=True)
+        tmp_folder = P.tmpdir(prefix="tmp_unzip")
+        res = url_obj.decrypt(pwd=pwd, inplace=True).unzip(inplace=True, folder=tmp_folder)
+        res.search("*").apply(lambda x: x.move(folder=folder_obj, overwrite=True))
         print(f"Decrypted to {res}")
 
 
@@ -44,19 +47,17 @@ def arg_parser() -> None:
     # positional argument
     parser.add_argument("source", help="file/folder path to be taken from here.")
     parser.add_argument("target", help="file/folder path to be be sent to here.")
-    # FLAGS
-    # parser.add_argument("--recursive", "-r", help="Send recursively.", action="store_true")  # default is False
-    parser.add_argument("--encrypt", "-e", help="Decrypt after receiving.", action="store_true", default=ArgsDefaults.encrypt)
-    parser.add_argument("--zip", "-z", help="unzip after receiving.", action="store_true", default=ArgsDefaults.zip_)
+
     parser.add_argument("--overwrite", "-w", help="Overwrite existing file.", action="store_true", default=ArgsDefaults.overwrite)
     parser.add_argument("--share", "-s", help="Share file / directory", action="store_true", default=ArgsDefaults.share)
-    # optional argument
     parser.add_argument("--rel2home", "-r", help="Relative to `myhome` folder", action="store_true", default=ArgsDefaults.rel2home)
     parser.add_argument("--root", "-R", help="Remote root. None is the default, unless rel2home is raied, making the default `myhome`.", default=ArgsDefaults.root)
-    parser.add_argument("--os_specific", "-o", help="OS specific path (relevant only when relative flag is raised as well.", action="store_true", default=ArgsDefaults.os_specific)
 
     parser.add_argument("--key", "-k", help="Key for encryption", type=str, default=ArgsDefaults.key)
     parser.add_argument("--pwd", "-p", help="Password for encryption", type=str, default=ArgsDefaults.pwd)
+    parser.add_argument("--encrypt", "-e", help="Decrypt after receiving.", action="store_true", default=ArgsDefaults.encrypt)
+    parser.add_argument("--zip", "-z", help="unzip after receiving.", action="store_true", default=ArgsDefaults.zip_)
+    parser.add_argument("--os_specific", "-o", help="choose path specific for this OS.", action="store_true", default=ArgsDefaults.os_specific)
 
     parser.add_argument("--config", "-c",  help="path to cloud.json file.", default=None)
 
@@ -67,7 +68,7 @@ def arg_parser() -> None:
     args_obj = Args(**args_dict)
     Struct(args_obj.__dict__).print(as_config=True, title=f"CLI config")
 
-    if args_obj.config == "ss" and (source.startswith("http") or source.startswith("bit.ly")): return get_shared_file(url=source, folder=target)
+    if args_obj.config == "ss" and (source.startswith("http") or source.startswith("bit.ly")): return get_securely_shared_file(url=source, folder=target)
     if args_obj.rel2home is True and args_obj.root is None: args_obj.root = "myhome"
 
     cloud, source, target = parse_cloud_source_target(args=args_obj, source=source, target=target)
@@ -84,7 +85,11 @@ def arg_parser() -> None:
                                     zip=args_obj.zip, encrypt=args_obj.encrypt, pwd=args_obj.pwd,
                                     rel2home=args_obj.rel2home, root=args_obj.root, os_specific=args_obj.os_specific, strict=False,
                                     share=args_obj.share)
-        if args_obj.share: print(res.as_url_str())
+        if args_obj.share:
+            print(res.as_url_str())
+            if P(source).is_dir(): share_url_path = P(source).joinpath(".share_url")
+            else: share_url_path = P(source).with_suffix(".share_url")
+            share_url_path.write_text(res.as_url_str())
     else: raise ValueError(f"Cloud `{cloud}` not found in source or target.")
 
 

machineconfig/scripts/python/cloud_mount.py

@@ -2,8 +2,10 @@
 """Cloud mount script
 """
 
-import crocodile.toolbox as tb
-from machineconfig.utils.utils import PROGRAM_PATH, display_options
+
+from machineconfig.utils.utils import PROGRAM_PATH, choose_one_option
+from crocodile.file_management import P, Read
+
 import platform
 import argparse
 from typing import Optional
@@ -13,17 +15,17 @@ DEFAULT_MOUNT = "~/data/rclone"
 
 
 def get_rclone_config():
-    if platform.system() == "Windows": config = tb.Read.ini(tb.P.home().joinpath("AppData/Roaming/rclone/rclone.conf"))
-    elif platform.system() == "Linux": config = tb.Read.ini(tb.P.home().joinpath(".config/rclone/rclone.conf"))
+    if platform.system() == "Windows": config = Read.ini(P.home().joinpath("AppData/Roaming/rclone/rclone.conf"))
+    elif platform.system() == "Linux": config = Read.ini(P.home().joinpath(".config/rclone/rclone.conf"))
     else: raise ValueError("unsupported platform")
     return config
 
 
 def get_mprocs_mount_txt(cloud: str, rclone_cmd: str, cloud_brand: str):  # cloud_brand = config[cloud]["type"]
-    # config = tb.Read.ini(tb.P.home().joinpath(".config/rclone/rclone.conf"))
+    # config = Read.ini(P.home().joinpath(".config/rclone/rclone.conf"))
     header = f"{' ' + cloud + ' | ' + cloud_brand + ' '}".center(50, "=")
     if platform.system() == "Windows":
-        sub_text_path = tb.P.tmpfile(suffix=".ps1").write_text(f"""
+        sub_text_path = P.tmpfile(suffix=".ps1").write_text(f"""
 echo "{header}"
 iex 'rclone about {cloud}:'
 echo 'See {DEFAULT_MOUNT}/{cloud} for the mounted cloud'
@@ -40,29 +42,52 @@ mprocs "echo 'see {DEFAULT_MOUNT}/{cloud} for the mounted cloud'; rclone about {
     return txt
 
 
-def mount(cloud: Optional[str] = None, network: Optional[str] = None) -> None:
-
+def mount(cloud: Optional[str], network: Optional[str], destination: Optional[str]) -> None:
     config = get_rclone_config()
     if cloud is None:
-        res = display_options(msg="which cloud", options=config.sections(), header="CLOUD MOUNT", default=None)
+        res = choose_one_option(msg="which cloud", options=config.sections(), header="CLOUD MOUNT", default=None)
         if type(res) is str: cloud = res
         else: raise ValueError("no cloud selected")
-    # assert isinstance(cloud, str)
+
     if network is None:
-        mount_loc = tb.P(DEFAULT_MOUNT).expanduser().joinpath(cloud)
-        if platform.system() == "Windows": mount_loc.parent.create()
-        elif platform.system() == "Linux": mount_loc.create()
+        if destination is None:
+            mount_loc = P(DEFAULT_MOUNT).expanduser().joinpath(cloud)
+        else:
+            mount_loc = P(destination)
+
+        if platform.system() == "Windows":
+            mount_loc.parent.create()
+        elif platform.system() == "Linux":
+            try: mount_loc.create()
+            except (FileExistsError, OSError) as err:
+                # We need a umount command here.
+                print(err)
+                pass
         else: raise ValueError("unsupported platform")
+
     elif network and platform.system() == "Windows": mount_loc = "X: --network-mode"
     else: raise ValueError("network mount only supported on windows")
 
     mount_cmd = f"rclone mount {cloud}: {mount_loc} --vfs-cache-mode full --file-perms=0777"
 
     # txt = get_mprocs_mount_txt(cloud, mount_cmd)
-    if platform.system() == "Windows": txt = f"""
+    if platform.system() == "Windows":
+
+        txt = f"""
 wt --window 0 --profile "Windows PowerShell" --startingDirectory "$HOME/data/rclone" `; split-pane --horizontal  --profile "Command Prompt" --size 0.2 powershell -Command "{mount_cmd}" `; split-pane --vertical --profile "Windows PowerShell" --size 0.2 powershell -NoExit -Command "rclone about {cloud}:"  `; move-focus up
 """
     elif platform.system() == "Linux": txt = f"""
+
+ZJ_SESSIONS=$(zellij list-sessions)
+
+if [[ "${{ZJ_SESSIONS}}" != *"(current)"* ]]; then
+    echo "Not inside a zellij session ..."
+    echo '{mount_cmd} --daemon'
+    # exit 1
+
+    {mount_cmd} --daemon
+fi
+
 zellij run --direction down --name rclone -- {mount_cmd}
 sleep 1; zellij action resize decrease down
 sleep 0.2; zellij action resize decrease up
@@ -90,9 +115,10 @@ zellij action move-focus up
 def main():
     parser = argparse.ArgumentParser(description='mount cloud')
     parser.add_argument('cloud', nargs='?', type=str, default=None, help='cloud to mount')
+    parser.add_argument('destination', nargs='?', type=str, default=None, help='destination to mount')
     parser.add_argument('--network', type=str, default=None, help='mount network drive')
     args = parser.parse_args()
-    mount(cloud=args.cloud, network=args.network)
+    mount(cloud=args.cloud, network=args.network, destination=args.destination)
 
 
 if __name__ == '__main__':