machineconfig 1.5__py3-none-any.whl → 1.8__py3-none-any.whl

machineconfig/scripts/python/devops_devapps_install.py

@@ -1,91 +1,120 @@
-
-
-from platform import system
-# import subprocess
-import crocodile.toolbox as tb
-from machineconfig.utils.utils import LIBRARY_ROOT, display_options
-
-
-if system() == "Windows": from machineconfig.jobs.python.python_windows_installers_all import get_cli_py_installers
-elif system() == "Linux": from machineconfig.jobs.python.python_linux_installers_all import get_cli_py_installers
-else: raise NotImplementedError(f"System {system()} not supported")
-
-
-def main(program_name=None):
-    installers = get_cli_py_installers()
-    default = tb.P("all")
-    installers.list.insert(0, default)
-    installers.list.insert(0, tb.P("System Installers"))
-    installers.list.insert(0, tb.P("Other dev apps"))
-    options = list(installers.apply(lambda x: x.stem + ((' -- ' + str(x.readit().__doc__)) if x.exists() else '')))
-    # options.sort()  # throws off sync between installers and options
-
-    if program_name is None:
-        program_names = display_options(msg="", options=options, header="CHOOSE DEV APP", default=str(default), fzf=True, multi=True)
-        total_program = ""
-        for program_name in program_names:
-            total_program += "\n" + get_program(program_name, options, installers)
-    else:
-        total_program = get_program(program_name, options, installers)
-    return total_program
-
-
-def get_program(program_name, options, installers):
-    if program_name == "all":
-        if system() == "Linux": from machineconfig.jobs.python.python_linux_installers_all import main
-        elif system() == "Windows": from machineconfig.jobs.python.python_windows_installers_all import main
-        else: raise NotImplementedError(f"System {system()} not supported")
-        main()
-        # program_linux = f"source {LIBRARY_ROOT}/setup_linux/devapps.sh"
-        # program_windows = f"{LIBRARY_ROOT}/setup_windows/devapps.ps1"
-        program = ""
-    elif program_name == "System Installers":
-        if system() == "Windows": options_more = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text())
-        elif system() == "Linux": options_more = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text())
-        else: raise NotImplementedError(f"System {system()} not supported")
-        program_names = display_options(msg="", options=sorted(list(options_more.keys())), header="CHOOSE DEV APP", fzf=True, multi=True)
-        program = ""
-        for name in program_names:
-            sub_program = options_more[name]
-            if sub_program.startswith("#winget"): sub_program = sub_program[1:]
-            program += "\n" + sub_program
-    elif program_name == "Other dev apps":
-        installers = get_cli_py_installers(dev=True)
-        options = list(installers.apply(lambda x: x.stem + ((' -- ' + str(x.readit().__doc__)) if x.exists() else '')))
-        program_names = display_options(msg="", options=sorted(options), header="CHOOSE DEV APP", fzf=True, multi=True)
-        program = ""
-        for name in program_names:
-            idx = options.index(name)
-            try:
-                sub_program = installers[idx].readit()['main']()  # finish the task
-            except KeyError:
-                print(f"KeyError: could not find 'main' in {installers[idx]}")
-                raise KeyError
-            if sub_program is None: sub_program = "echo 'Finished Installation'"  # write an empty program
-            program += "\n" + sub_program
-    else:
-        idx = options.index(program_name)
-        print(installers[idx])
-        program = installers[idx].readit()['main']()  # finish the task
-        if program is None: program = "echo 'Finished Installation'"  # write an empty program
-    return program
-
-
-def parse_apps_installer_linux(txt):
-    txt = txt.split("""yes '' | sed 3q; echo "----------------------------- installing """)
-    return tb.Struct.from_keys_values_pairs(tb.L(txt).apply(lambda tmp:  (tmp.split('----')[0].rstrip().lstrip(), "\n".join(tmp.split("\n")[1:])))[1:])
-
-
-def parse_apps_installer_windows(txt) -> dict:
-    progs = tb.L(txt.splitlines()).filter(lambda x: x.startswith("winget ") or x.startswith("#winget"))
-    res = {}
-    for line in progs:
-        try: res[line.split('--name ')[1].split(' --Id ')[0].strip('"').strip('"')] = line
-        except IndexError as e:
-            print(line)
-            raise e
-    return res
-
-
-if __name__ == '__main__':
-    pass
+
+"""Devops Devapps Install
+"""
+
+# import subprocess
+from crocodile.core import List as L
+from machineconfig.utils.utils import LIBRARY_ROOT, choose_multiple_options
+from machineconfig.utils.installer import get_installers, Installer, install_all
+from platform import system
+from typing import Any, Optional, Literal, TypeAlias
+
+
+WHICH: TypeAlias = Literal["AllEssentials", "EssentialsAndOthers", "SystemInstallers", "OtherDevApps", "PrecheckedCloudInstaller"]
+
+
+def main(which: Optional[str] = None):
+    sys = system()
+    installers = get_installers(dev=False, system=sys) + get_installers(dev=True, system=sys)
+    default = "AllEssentials"
+    options = ["SystemInstallers", "OtherDevApps", "EssentialsAndOthers", "PrecheckedCloudInstaller"]
+    options = [default] + options
+    options = [x.get_description() for x in installers] + options
+
+    if which is not None:
+        return get_program(program_name=which, options=options, installers=list(installers))
+
+    program_names = choose_multiple_options(msg="", options=options, header="CHOOSE DEV APP", default=str(default))
+    total_program = ""
+    for which in program_names:
+        assert isinstance(which, str), f"program_name is not a string: {which}"
+        total_program += "\n" + get_program(program_name=which, options=options, installers=list(installers))
+    return total_program
+
+
+def get_program(program_name: str, options: list[str], installers: list[Installer]):
+    if program_name == "AllEssentials" or program_name == "EssentialsAndOthers":
+        installers_ = get_installers(dev=False, system=system())
+        if program_name == "EssentialsAndOthers":
+            installers_ += get_installers(dev=True, system=system())
+        install_all(installers=L(installers))
+        program = ""
+    elif program_name == "SystemInstallers":
+        if system() == "Windows": options_system = parse_apps_installer_windows(LIBRARY_ROOT.joinpath("setup_windows/apps.ps1").read_text())
+        elif system() == "Linux": options_system = parse_apps_installer_linux(LIBRARY_ROOT.joinpath("setup_linux/apps.sh").read_text())
+        else: raise NotImplementedError(f"System {system()} not supported")
+        program_names = choose_multiple_options(msg="", options=sorted(list(options_system.keys())), header="CHOOSE DEV APP")
+        program = ""
+        for name in program_names:
+            sub_program = options_system[name]
+            if sub_program.startswith("#winget"): sub_program = sub_program[1:]
+            program += "\n" + sub_program
+    elif program_name == "OtherDevApps":
+        installers = get_installers(dev=True, system=system())
+        options__: list[str] = [x.get_description() for x in installers]
+        program_names = choose_multiple_options(msg="", options=sorted(options__) + ["all"], header="CHOOSE DEV APP")
+        if "all" in program_names: program_names = options__
+        program = ""
+        for name in program_names:
+            try:
+                idx = options__.index(name)
+            except ValueError as ve:
+                print(f"{name=}")
+                print(f"{options__=}")
+                raise ve
+            sub_program = installers[idx].install_robust(version=None)  # finish the task
+    elif program_name == "PrecheckedCloudInstaller":
+        from machineconfig.jobs.python.check_installations import PrecheckedCloudInstaller
+        ci = PrecheckedCloudInstaller()
+        ci.download_safe_apps(name="AllEssentials")
+        program = ""
+    else:
+        idx = options.index(program_name)
+        print(installers[idx])
+        program = installers[idx].install_robust(version=None)  # finish the task
+        program = "echo 'Finished Installation'"  # write an empty program
+    return program
+
+
+def parse_apps_installer_linux(txt: str) -> dict[str, Any]:
+    txts = txt.split("""yes '' | sed 3q; echo "----------------------------- installing """)
+    res = {}
+    for chunk in txts[1:]:
+        try:
+            k = chunk.split('----')[0].rstrip().lstrip()
+            v = "\n".join(chunk.split("\n")[1:])
+            res[k] = v
+        except IndexError as e:
+            print(chunk)
+            raise e
+    return res
+
+
+def parse_apps_installer_windows(txt: str) -> dict[str, Any]:
+    chunks: list[str] = []
+    for idx, item in enumerate(txt.split(sep="winget install")):
+        if idx == 0: continue
+        if idx == 1: chunks.append(item)
+        else: chunks.append("winget install" + item)
+    # progs = L(txt.splitlines()).filter(lambda x: x.startswith("winget ") or x.startswith("#winget"))
+    res: dict[str, str] = {}
+    for a_chunk in chunks:
+        try:
+            name = a_chunk.split('--name ')[1]
+            if "--Id" not in name:
+                print(f"Warning: {name} does not have an Id, skipping")
+                continue
+            name = name.split(' --Id ', maxsplit=1)[0].strip('"').strip('"')
+            res[name] = a_chunk
+        except IndexError as e:
+            print(a_chunk)
+            raise e
+    # Struct(res).print(as_config=True)
+    # L(chunks).print(sep="-----------------------------------------------------------------------\n\n")
+    # import time
+    # time.sleep(10)
+    return res
+
+
+if __name__ == '__main__':
+    pass

machineconfig/scripts/python/devops_update_repos.py

@@ -1,68 +1,82 @@
-
-from platform import system
-import crocodile.toolbox as tb
-# from machineconfig.utils.utils import write_shell_script
-
-sep = "\n"
-
-
-def main(verbose=True) -> str:
-    _ = verbose
-    repos = tb.P.home().joinpath("dotfiles/config/reposXXX.ini")
-    if repos.exists():
-        repos = repos.readit()
-        repo_package_list = repos.sections()
-    else:
-        repos = ["~/code/crocodile", "~/code/machineconfig", ]
-        repo_package_list = repos
-    repos_objs = []
-    for a_package_path in repo_package_list:
-        try:
-            repo = tb.install_n_import("git", "gitpython").Repo(str(tb.P(a_package_path).expanduser()), search_parent_directories=True)
-            repos_objs.append(repo)
-        except Exception as ex:
-            print(ex)
-    if system() == "Linux":
-        additions = []
-        for a_repo in repos_objs:
-            if "machineconfig" in a_repo.working_dir:  # special treatment because of executables.
-                an_addition = f"""
-echo ""
-echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
-cd "{a_repo.working_dir}"
-git reset --hard
-git pull origin
-chmod +x ~/scripts -R
-chmod +x ~/code/machineconfig/src/machineconfig/jobs/linux -R
-chmod +x ~/code/machineconfig/src/machineconfig/settings/lf/linux/exe -R
-"""
-                additions.append(an_addition)
-            else:
-                # if a_repo.is_dirty() and input(f"Repository {a_repo} is not clean, hard-reset it? y/[n]"): a_repo.git.reset('--hard')
-                additions.append(f"""
-echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
-cd "{a_repo.working_dir}"
-{sep.join([f'git pull {remote.name} {a_repo.active_branch.name}' for remote in a_repo.remotes])}
-""")
-        program = "\n".join(additions)
-
-    elif system() == "Windows":
-        program = "\n".join([f"""
-echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
-cd "{a_repo.working_dir}"
-{sep.join([f'git pull {remote.name} {a_repo.active_branch.name}' for remote in a_repo.remotes])}
-""" for a_repo in repos_objs])
-    else: raise NotImplementedError(f"System {system()} not supported")
-    # write_shell_script(program, desc="Script to update repos")
-    # return ""
-    return program
-
-
-# def get_pulls(remote):
-#     if len(remote.branches) == 0: return ""
-#     elif len(remote.branches) == 1: return f'git pull {remote.name} {remote.branches[0].name}'
-#     else: return f'git pull {remote.name} {remote.active_branch.name}'
-
-
-if __name__ == '__main__':
-    pass
+
+"""Update
+"""
+
+from crocodile.file_management import P, Read
+from crocodile.core import install_n_import
+from machineconfig.utils.utils import DEFAULTS_PATH
+from platform import system
+
+
+sep = "\n"
+
+
+def main(verbose: bool = True) -> str:
+    _ = verbose
+    repos: list[str] = ["~/code/crocodile", "~/code/machineconfig", ]
+    try:
+        tmp = Read.ini(DEFAULTS_PATH)['general']['repos'].split(",")
+        if tmp[-1] == "": tmp = tmp[:-1]
+        repos += tmp
+    except (FileNotFoundError, KeyError, IndexError):
+        print(f"Missing {DEFAULTS_PATH} or section [general] or key repos. Using default repos.")
+        print(f"""It should look like this:
+[general]
+repos = ~/code/repo1,~/code/repo2
+rclone_config_name = onedriveWork
+email_config_name = Yahoo3
+to_email = myemail@email.com
+""")
+
+    repos_objs = []
+    for a_package_path in repos:
+        try:
+            repo = install_n_import("git", "gitpython").Repo(str(P(a_package_path).expanduser()), search_parent_directories=True)
+            repos_objs.append(repo)
+        except Exception as ex:
+            print(ex)
+
+    if system() == "Linux":
+        additions = []
+        for a_repo in repos_objs:
+            if "machineconfig" in a_repo.working_dir:  # special treatment because of executables.
+                an_addition = f"""
+echo ""
+echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
+cd "{a_repo.working_dir}"
+# git reset --hard
+git pull origin
+chmod +x ~/scripts -R
+chmod +x ~/code/machineconfig/src/machineconfig/jobs/linux -R
+chmod +x ~/code/machineconfig/src/machineconfig/settings/lf/linux/exe -R
+"""
+                additions.append(an_addition)
+            else:
+                # if a_repo.is_dirty() and input(f"Repository {a_repo} is not clean, hard-reset it? y/[n]"): a_repo.git.reset('--hard')
+                additions.append(f"""
+echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
+cd "{a_repo.working_dir}"
+{sep.join([f'git pull {remote.name} {a_repo.active_branch.name}' for remote in a_repo.remotes])}
+""")
+        program = "\n".join(additions)
+
+    elif system() == "Windows":
+        program = "\n".join([f"""
+echo "{("Pulling " + str(a_repo.working_dir)).center(80, "-")}"
+cd "{a_repo.working_dir}"
+{sep.join([f'git pull {remote.name} {a_repo.active_branch.name}' for remote in a_repo.remotes])}
+""" for a_repo in repos_objs])
+    else: raise NotImplementedError(f"System {system()} not supported")
+    # write_shell_script(program, desc="Script to update repos")
+    # return ""
+    return program
+
+
+# def get_pulls(remote):
+#     if len(remote.branches) == 0: return ""
+#     elif len(remote.branches) == 1: return f'git pull {remote.name} {remote.branches[0].name}'
+#     else: return f'git pull {remote.name} {remote.active_branch.name}'
+
+
+if __name__ == '__main__':
+    pass

machineconfig/scripts/python/dotfile.py

@@ -1,38 +1,42 @@
-
-import argparse
-import crocodile.toolbox as tb
-from machineconfig.profile.create import symlink
-from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT
-
-
-def main():
-    parser = argparse.ArgumentParser(description='FTP client')
-
-    parser.add_argument("file", help="file/folder path.", default="")
-    # FLAGS
-    parser.add_argument("--overwrite", "-o", help="Overwrite.", action="store_true")  # default is False
-    # optional
-    parser.add_argument("-d", "--dest", help=f"destination folder", default="")
-
-    args = parser.parse_args()
-    orig_path = tb.P(args.file).expanduser().absolute()
-    if args.dest == "":
-        if "Local" in orig_path: junction = orig_path.split(at="Local", sep=-1)[1]
-        elif "Roaming" in orig_path: junction = orig_path.split(at="Roaming", sep=-1)[1]
-        elif ".config" in orig_path: junction = orig_path.split(at=".config", sep=-1)[1]
-        else: junction = orig_path.rel2home()
-        new_path = REPO_ROOT.joinpath(junction)
-    else: new_path = tb.P(args.dest).expanduser().absolute().create().joinpath(orig_path.name)
-
-    symlink(this=orig_path, to_this=new_path, prioritize_to_this=args.overwrite)
-
-    print(f"Map completed. To enshrine this mapping, add the following line to the mapper.toml file:")
-    print(f"nano {LIBRARY_ROOT}/symlinks/mapper.toml")
-    print(f"""
-[{new_path.parent.name}]
-{orig_path.trunk} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
-""")
-
-
-if __name__ == '__main__':
-    main()
+
+"""Like yadm and dotter.
+"""
+
+
+from crocodile.file_management import P
+from machineconfig.profile.create import symlink
+from machineconfig.utils.utils import LIBRARY_ROOT, REPO_ROOT
+import argparse
+
+
+def main():
+    parser = argparse.ArgumentParser(description='FTP client')
+
+    parser.add_argument("file", help="file/folder path.", default="")
+    # FLAGS
+    parser.add_argument("--overwrite", "-o", help="Overwrite.", action="store_true")  # default is False
+    # optional
+    parser.add_argument("-d", "--dest", help=f"destination folder", default="")
+
+    args = parser.parse_args()
+    orig_path = P(args.file).expanduser().absolute()
+    if args.dest == "":
+        if "Local" in orig_path: junction = orig_path.split(at="Local", sep=-1)[1]
+        elif "Roaming" in orig_path: junction = orig_path.split(at="Roaming", sep=-1)[1]
+        elif ".config" in orig_path: junction = orig_path.split(at=".config", sep=-1)[1]
+        else: junction = orig_path.rel2home()
+        new_path = REPO_ROOT.joinpath(junction)
+    else: new_path = P(args.dest).expanduser().absolute().create().joinpath(orig_path.name)
+
+    symlink(this=orig_path, to_this=new_path, prioritize_to_this=args.overwrite)
+
+    print(f"Map completed. To enshrine this mapping, add the following line to the mapper.toml file:")
+    print(f"nano {LIBRARY_ROOT}/symlinks/mapper.toml")
+    print(f"""
+[{new_path.parent.name}]
+{orig_path.trunk} = {{ this = '{orig_path.collapseuser().as_posix()}', to_this = '{new_path.collapseuser().as_posix()}' }}
+""")
+
+
+if __name__ == '__main__':
+    main()