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

machineconfig/scripts/python/pomodoro.py

@@ -1,4 +1,3 @@
-
 """Pomodoro
 """
 
@@ -6,36 +5,51 @@ from crocodile.toolbox import Log, install_n_import, Scheduler, P
 import time
 from datetime import datetime
 
-
 def pomodoro(work: int = 25, rest: int = 5, repeats: int = 4):
+    print("\n" + "=" * 50)
+    print("🍅 Welcome to the Pomodoro Timer")
+    print("=" * 50 + "\n")
+
     logger = Log(name="pomodoro", file=False, stream=True)
+
     def loop(sched: Scheduler):
-        speak("Alright, time to start working..."); start = datetime.now(); _ = sched
-        while (diff := work - ((datetime.now() - start).seconds / 60)) > 0: logger.debug(f"Keep working. Time Left: {round(diff)} minutes"); time.sleep(60 * 1)
-        speak("Now, its time to take a break."); start = datetime.now()
-        while (diff := rest - ((datetime.now() - start).seconds / 60)) > 0: logger.critical(f"Keep Resting. Time Left: {round(diff)} minutes"); time.sleep(60 * 1)
+        speak("Alright, time to start working...")
+        print("\n⏳ Work session started! Stay focused.")
+        start = datetime.now()
+        _ = sched
+        while (diff := work - ((datetime.now() - start).seconds / 60)) > 0:
+            logger.debug(f"💼 Keep working. Time Left: {round(diff)} minutes")
+            time.sleep(60 * 1)
+
+        speak("Now, it's time to take a break.")
+        print("\n☕ Break time! Relax and recharge.")
+        start = datetime.now()
+        while (diff := rest - ((datetime.now() - start).seconds / 60)) > 0:
+            logger.critical(f"🛋️ Keep resting. Time Left: {round(diff)} minutes")
+            time.sleep(60 * 1)
+
     def speak(txt: str):
-        install_n_import("gtts").gTTS(txt, lang='en', tld='com.au').save(tmp := P.tmpfile(suffix=".mp3")); time.sleep(0.5)
-        pyglet = install_n_import("pyglet"); pyglet.resource.path = [tmp.parent.to_str()]; pyglet.resource.reindex(); pyglet.resource.media(tmp.name).play()
-    def beep(duration: int = 1, frequency: int = 3000):
-        try: import winsound
-        except ImportError: __import__("os").system(f'beep -f {frequency} -l {1000 * duration}')
-        else: winsound.Beep(frequency, 1000 * duration)  # type: ignore
-    _ = beep
-    return Scheduler(routine=loop, max_cycles=repeats, logger=logger, wait="0.1m").run()
+        print(f"🔊 Speaking: {txt}")
+        install_n_import("gtts").gTTS(txt, lang='en', tld='com.au').save(tmp := P.tmpfile(suffix=".mp3"))
+        time.sleep(0.5)
+        pyglet = install_n_import("pyglet")
+        pyglet.resource.path = [tmp.parent.to_str()]
+        pyglet.resource.reindex()
+        pyglet.resource.media(tmp.name).play()
 
+    def beep(duration: int = 1, frequency: int = 3000):
+        print(f"🔔 Beeping with duration {duration}s and frequency {frequency}Hz")
+        try:
+            import winsound
+        except ImportError:
+            __import__("os").system(f'beep -f {frequency} -l {1000 * duration}')
+        else:
+            winsound.Beep(frequency, 1000 * duration)  # type: ignore
 
-# def main():
-#     parser = argparse.ArgumentParser(description='FTP client')
-#
-#     parser.add_argument("machine", help=f"machine ssh address", default="")
-#     parser.add_argument("file", help="file/folder path.", default="")
-#     # FLAGS
-#     parser.add_argument("--recursive", "-r", help="Send recursively.", action="store_true")  # default is False
-#     parser.add_argument("--zipFirst", "-z", help="Zip before sending.", action="store_true")  # default is False
-#
-#     args = parser.parse_args()
+    _ = beep
 
+    print("\n🎯 Starting the Pomodoro routine...")
+    return Scheduler(routine=loop, max_cycles=repeats, logger=logger, wait="0.1m").run()
 
 if __name__ == '__main__':
     pomodoro()

machineconfig/scripts/python/repos.py

@@ -1,4 +1,3 @@
-
 """Repos
 
 # TODO use gh api user --jq '.login' to get the username and use it to clone the repos.
@@ -7,14 +6,13 @@ in the event that username@github.com is not mentioned in the remote url.
 """
 
 from rich import print as pprint
-from machineconfig.utils.utils import write_shell_script, CONFIG_PATH, DEFAULTS_PATH
+from machineconfig.utils.utils import write_shell_script_to_default_program_path, CONFIG_PATH, DEFAULTS_PATH
 from crocodile.file_management import P, Read, Save
 from crocodile.core import randstr
 import argparse
 from dataclasses import dataclass
 from enum import Enum
 from typing import Optional, Any
-# tm = Terminal()
 
 
 class GitAction(Enum):
@@ -37,48 +35,51 @@ def git_action(path: P, action: GitAction, mess: Optional[str] = None, r: bool=F
     try:
         repo = Repo(str(path), search_parent_directories=False)
     except InvalidGitRepositoryError:
-        pprint(f"Skipping {path} because it is not a git repository.")
+        pprint(f"⚠️ Skipping {path} because it is not a git repository.")
         if r:
             prgs = [git_action(path=sub_path, action=action, mess=mess, r=r) for sub_path in path.search()]
             return "\n".join(prgs)
         else: return "\necho 'skipped because not a git repo'\n\n"
 
     program = f'''
-echo '>>>>>>>>> {action}'
+🔧 echo '>>>>>>>>> {action}'
 cd '{path}'
 '''
     if action == GitAction.commit:
         if mess is None: mess = "auto_commit_" + randstr()
         program += f'''
-git add .; git commit -am "{mess}"
+🔄 git add .; git commit -am "{mess}"
 '''
     if action == GitAction.push or action == GitAction.pull:
-        # remotes = tm.run(f"cd {path}; git remote", shell="powershell").op.split("\n")
         action_name = "pull" if action == GitAction.pull else "push"
-        cmds = [f'echo "pulling from {remote.url}" ; git {action_name} {remote.name} {repo.active_branch.name}' for remote in repo.remotes]
+        cmds = [f'echo "🔄 {action_name.capitalize()}ing from {remote.url}" ; git {action_name} {remote.name} {repo.active_branch.name}' for remote in repo.remotes]
         program += '\n' + '\n'.join(cmds) + '\n'
     program = program + '''
-echo ""; echo ""
+✅ echo ""; echo ""
 '''
     return program
 
 
 def main():
+    print("\n" + "=" * 50)
+    print("📂 Welcome to the Repository Manager")
+    print("=" * 50 + "\n")
+
     parser = argparse.ArgumentParser(description='REPO MANAGER')
     # POSITIONAL
-    parser.add_argument("directory", help="folder containing repos to record a json out of OR a specs json file to follow.", default="")
+    parser.add_argument("directory", help="📁 Folder containing repos to record or a specs JSON file to follow.", default="")
     # FLAGS
-    parser.add_argument("--push", help="push", action="store_true")
-    parser.add_argument("--pull", help="pull", action="store_true")
-    parser.add_argument("--commit", help="commit", action="store_true")
-    parser.add_argument("--all", help="pull, commit and push", action="store_true")
-    parser.add_argument("--record", help="record respos", action="store_true")
-    parser.add_argument("--clone", help="clone repos from record", action="store_true")
-    parser.add_argument("--checkout", help="Check out to versions prvided in this json file", action="store_true")
-    parser.add_argument("--checkout_to_branch", help="Checkout to the main branch", action="store_true")
-    parser.add_argument("--recursive", "-r", help="recursive flag", action="store_true")
+    parser.add_argument("--push", help="🚀 Push changes.", action="store_true")
+    parser.add_argument("--pull", help="⬇️ Pull changes.", action="store_true")
+    parser.add_argument("--commit", help="💾 Commit changes.", action="store_true")
+    parser.add_argument("--all", help="🔄 Pull, commit, and push changes.", action="store_true")
+    parser.add_argument("--record", help="📝 Record repositories.", action="store_true")
+    parser.add_argument("--clone", help="📥 Clone repositories from record.", action="store_true")
+    parser.add_argument("--checkout", help="🔀 Check out to versions provided in a JSON file.", action="store_true")
+    parser.add_argument("--checkout_to_branch", help="🔀 Check out to the main branch.", action="store_true")
+    parser.add_argument("--recursive", "-r", help="🔍 Recursive flag.", action="store_true")
     # OPTIONAL
-    parser.add_argument("--cloud", "-c", help="cloud", default=None)
+    parser.add_argument("--cloud", "-c", help="☁️ Cloud storage option.", default=None)
     args = parser.parse_args()
 
     if args.directory == "": repos_root = P.home().joinpath("code")  # it is a positional argument, can never be empty.
@@ -86,16 +87,16 @@ def main():
 
     program = ""
     if args.record:
+        print("\n📝 Recording repositories...")
         res = record_repos(repos_root=str(repos_root))
-        pprint("Recorded repositories:\n", res)
+        pprint("✅ Recorded repositories:\n", res)
         save_path = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
-        # Save.pickle(obj=res, path=save_path)
         Save.json(obj=res, path=save_path, indent=4)
-        pprint(f"Result pickled at {P(save_path)}")
+        pprint(f"📁 Result saved at {P(save_path)}")
         if args.cloud is not None: P(save_path).to_cloud(rel2home=True, cloud=args.cloud)
         program += """\necho '>>>>>>>>> Finished Recording'\n"""
     elif args.clone or args.checkout or args.checkout_to_branch:
-        # preferred_remote = input("Enter preferred remote to use (default: None): ") or ""
+        print("\n📥 Cloning or checking out repositories...")
         program += """\necho '>>>>>>>>> Cloning Repos'\n"""
         if not repos_root.exists() or repos_root.stem != 'repos.json':  # user didn't pass absolute path to pickle file, but rather expected it to be in the default save location
             repos_root = CONFIG_PATH.joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
@@ -109,16 +110,15 @@ def main():
                 repos_root.from_cloud(cloud=cloud, rel2home=True)
         assert (repos_root.exists() and repos_root.name == 'repos.json') or args.cloud is not None, f"Path {repos_root} does not exist and cloud was not passed. You can't clone without one of them."
         program += install_repos(specs_path=str(repos_root), clone=args.clone, checkout_to_recorded_commit=args.checkout, checkout_to_branch=args.checkout_to_branch)
-    # elif args.checkout is not None:
-
     elif args.all or args.commit or args.pull or args.push:
+        print("\n🔄 Performing Git actions on repositories...")
         for a_path in repos_root.search("*"):
             program += f"""echo "{("Handling " + str(a_path)).center(80, "-")}" """
             if args.pull or args.all: program += git_action(path=a_path, action=GitAction.pull, r=args.recursive)
             if args.commit or args.all: program += git_action(a_path, action=GitAction.commit, r=args.recursive)
             if args.push or args.all: program += git_action(a_path, action=GitAction.push, r=args.recursive)
-    else: program = "echo 'no action specified, try to pass --push, --pull, --commit or --all'"
-    write_shell_script(program=program, desc="Script to update repos", preserve_cwd=True)
+    else: program = "echo '❌ No action specified. Try passing --push, --pull, --commit, or --all.'"
+    write_shell_script_to_default_program_path(program=program, desc="Script to update repos", preserve_cwd=True, display=True, execute=False)
 
 
 def record_repos(repos_root: str, r: bool=True) -> list[dict[str, Any]]:
@@ -147,7 +147,6 @@ def record_a_repo(path: P, search_parent_directories: bool=False, preferred_remo
     try: commit = repo.head.commit.hexsha
     except ValueError:  # look at https://github.com/gitpython-developers/GitPython/issues/1016
         print(f"⚠️ Failed to get latest commit of {repo}")
-        # cmd = "git config --global -add safe.directory"
         commit = None
     try: current_branch = repo.head.reference.name  # same as repo.active_branch.name
     except TypeError:
@@ -174,16 +173,14 @@ def install_repos(specs_path: str, clone: bool=True, checkout_to_recorded_commit
                             remote_url = repo["remotes"][preferred_remote]
                         else:
                             print(f"⚠️ `{preferred_remote=}` not found in {repo['remotes']}.")
-                            # preferred_remote = None
                     program += f"\ncd {parent_dir.collapseuser().as_posix()}; git clone {remote_url} --origin {remote_name}"
                     program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git remote set-url {remote_name} {remote_url}"
-                    # the new url-setting to ensure that account name before `@` was not lost (git clone ignores it): https://thisismygitrepo@github.com/thisismygitrepo/crocodile.git
                 program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git remote add {remote_name} {remote_url}"
             if checkout_to_recorded_commit:
                 commit = repo['version']['commit']
                 if isinstance(commit, str): program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git checkout {commit}"
                 else: print(f"Skipping {repo['parent_dir']} because it doesn't have a commit recorded. Found {commit}")
-                break  # you need to checkout only once, no need to repeat for other remotes.
+                break
             if checkout_to_branch:
                 program += f"\ncd {parent_dir.collapseuser().as_posix()}/{repo['name']}; git checkout {repo['current_branch']}"
                 break

machineconfig/scripts/python/scheduler.py

@@ -1,52 +1,53 @@
-
 """cli for scheduler
 """
 
 from machineconfig.utils.scheduling import P, Report, DEFAULT_CONFIG, read_task_from_dir, main
 
-
 def main_parse():
     import argparse
+    print("\n" + "=" * 50)
+    print("📅 Welcome to the Scheduler CLI")
+    print("=" * 50 + "\n")
+
     parser = argparse.ArgumentParser(description='Run tasks.')
-    parser.add_argument('root', type=str, default=None, help='Root directory of tasks.')
-    parser.add_argument('--ignore_conditions', "-i", action='store_true', help='Ignore conditions for running tasks.', default=False)
-    parser.add_argument('--report', "-R", action='store_true', help='Print report.', default=False)
-    parser.add_argument('--create_task', "-c", action='store_true', help='Add default config.', default=False)
-    # print(parser)
+    parser.add_argument('root', type=str, default=None, help='📁 Root directory of tasks.')
+    parser.add_argument('--ignore_conditions', "-i", action='store_true', help='🚫 Ignore conditions for running tasks.', default=False)
+    parser.add_argument('--report', "-R", action='store_true', help='📊 Print report.', default=False)
+    parser.add_argument('--create_task', "-c", action='store_true', help='🆕 Add default config.', default=False)
     args = parser.parse_args()
 
     tmp = P(args.root).expanduser().absolute()
-    if P(args.root).joinpath(".scheduler").exists():  # .search(files=False, folders=True)[0].joinpath("task.py").exists():
+    if P(args.root).joinpath(".scheduler").exists():
         root = P(args.root).joinpath(".scheduler")
-    if tmp.name == ".scheduler":
+    elif tmp.name == ".scheduler":
         root = tmp
     else:
         root = tmp.joinpath(".scheduler").create()
-        # raise ValueError(f"Could not find a task.py in {args.root} or {P(args.root).joinpath('.scheduler')}")
-    print(f"✅ Running tasks in {root}")
+
+    print(f"\n✅ Running tasks in {root}\n")
 
     if args.report:
+        print("📊 Generating report...")
         reports: list[Report] = [Report.from_path(read_task_from_dir(x).report_path) for x in P(root).search("*").filter(lambda path: path.joinpath("task.py").exists())]
         import pandas as pd
         df_res = pd.DataFrame([r.__dict__ for r in reports])
-        # root.joinpath("task_report.md").write_text(df_res.to_markdown(), encoding="utf-8")
         print(df_res.to_markdown())
-        # df_res.to_
+        print("\n✅ Report generated successfully!\n")
         return None
 
     if args.create_task:
-        task_name = input("Enter task name: ")
+        task_name = input("📝 Enter task name: ")
         task_root = root.joinpath(task_name).create(exist_ok=False)
-        # assert not root.joinpath("config.ini").exists(), f"Config file already exists in {root}"
         task_root.joinpath("config.ini").write_text(DEFAULT_CONFIG, encoding="utf-8")
-        task_root.joinpath("task.py").write_text(f"""
+        task_root.joinpath("task.py").write_text("""
 # Scheduler Task.
 """)
-        print(f"✅ Task {task_name} created in {task_root}. Head there and edit the config.ini file & task.py file.")
+        print(f"\n✅ Task '{task_name}' created in {task_root}. Head there and edit the config.ini file & task.py file.\n")
         return None
 
+    print("🚀 Executing tasks...")
     main(root=root.to_str(), ignore_conditions=args.ignore_conditions)
-
+    print("🎉 All tasks executed successfully!\n")
 
 if __name__ == "__main__":
     main_parse()

machineconfig/scripts/python/snapshot.py

@@ -1,21 +1,29 @@
-
 from crocodile.msc.odds import capture_from_webcam
 from crocodile.meta import Terminal
 import argparse
 
-
 def main():
-    parser = argparse.ArgumentParser(description='FTP client')
-    parser.add_argument("--to_text", "-t", help="Send recursively.", action="store_true")  # default is False
+    print("\n" + "=" * 50)
+    print("📸 Welcome to the Snapshot Tool")
+    print("=" * 50 + "\n")
+
+    parser = argparse.ArgumentParser(description='📷 Capture snapshots using your webcam.')
+    parser.add_argument("--to_text", "-t", help="📝 Convert the snapshot to text using OCR.", action="store_true")
     args = parser.parse_args()
 
+    print("📷 Capturing image from webcam...")
     img_path = capture_from_webcam(show=False, wait=False, save=True)
+    print(f"✅ Image captured and saved at: {img_path}\n")
+
     if args.to_text:
+        print("🔍 Converting image to text using Tesseract OCR...")
         q = Terminal().run(f"cd ~/AppData/Local/Tesseract-OCR; pytesseract '{img_path}'", shell="pwsh").capture().op
+        print("📝 Extracted Text:")
+        print("-" * 50)
         print(q)
+        print("-" * 50 + "\n")
     else:
-        print(img_path)
-
+        print("📂 Image saved successfully. No text extraction requested.\n")
 
 if __name__ == '__main__':
     main()

machineconfig/scripts/python/start_slidev.py

@@ -1,26 +1,23 @@
-
 """
 slidev
 """
 
 from machineconfig.utils.utils import CONFIG_PATH, PROGRAM_PATH, print_code
 from crocodile.meta import Terminal, P
-# from crocodile.environment import get_network_addresses
 import subprocess
 import platform
 
-
 PORT_DEFAULT = 3030
 
-
 SLIDEV_REPO = CONFIG_PATH.joinpath(".cache/slidev")
 if not SLIDEV_REPO.joinpath("components").exists():
-    # assert slidev is installed first
+    print("📦 Initializing Slidev repository...")
     Terminal(stderr=subprocess.PIPE, stdin=subprocess.PIPE, stdout=subprocess.PIPE).run(f"cd {SLIDEV_REPO.parent};npm init slidev@latest")
-
+    print("✅ Slidev repository initialized successfully!\n")
 
 def jupyter_to_markdown(file: P):
     op_dir = file.parent.joinpath("presentation")
+    print("📝 Converting Jupyter notebook to markdown...")
 
     # https://nbconvert.readthedocs.io/en/latest/nbconvert_library.html
     # from nbconvert.exporters.markdown import MarkdownExporter
@@ -36,32 +33,32 @@ def jupyter_to_markdown(file: P):
     Terminal().run(cmd, shell="powershell").print()
     cmd = f"jupyter nbconvert --to html --no-prompt --no-input --output-dir {op_dir} {file}"
     Terminal().run(cmd, shell="powershell").print()
-    # cmd = f"jupyter nbconvert --to pdf --no-prompt --no-input --output-dir {op_dir} {file}"
-    # Terminal().run(cmd, shell="powershell").print()
-
 
     op_file = op_dir.joinpath("slides_raw.md")
-    slide_separator =  '\n\n---\n\n'
+    slide_separator = '\n\n---\n\n'
     md = op_file.read_text().replace('\n\n\n\n', slide_separator)
-    md = slide_separator.join([item for item in md.split(slide_separator) if bool(item.strip())])  # remove empty slides.
+    md = slide_separator.join([item for item in md.split(slide_separator) if bool(item.strip())])
     op_file.with_name("slides.md").write_text(md)
-    return op_dir
+    print(f"✅ Conversion completed! Check the results at: {op_dir}\n")
 
+    return op_dir
 
 def main() -> None:
     import argparse
 
+    print("\n" + "=" * 50)
+    print("🎥 Welcome to the Slidev Presentation Tool")
+    print("=" * 50 + "\n")
 
     parser = argparse.ArgumentParser()
-    parser.add_argument("-d", "--directory", default=None, help="Directory of the report")
-    parser.add_argument("-j", "--jupyter-file", default=None, help="Jupyter notebook file to convert to slides. If not provided, slides.md is used.")
-    # parser.add_argument("--port", default=PORT_DEFAULT, help=f"Port to serve the report, default to {PORT_DEFAULT}")
+    parser.add_argument("-d", "--directory", default=None, help="📁 Directory of the report.")
+    parser.add_argument("-j", "--jupyter-file", default=None, help="📓 Jupyter notebook file to convert to slides. If not provided, slides.md is used.")
     args = parser.parse_args()
 
-    # port = args.port
     port = PORT_DEFAULT
 
     if args.jupyter_file is not None:
+        print("📓 Jupyter file provided. Converting to markdown...")
         report_dir = jupyter_to_markdown(P(args.jupyter_file))
     else:
         if args.directory is None:
@@ -69,8 +66,8 @@ def main() -> None:
         else:
             report_dir = P(args.directory)
 
-    assert report_dir.exists(), f"{report_dir} does not exist"
-    assert report_dir.is_dir(), f"{report_dir} is not a directory"
+    assert report_dir.exists(), f"❌ Directory {report_dir} does not exist."
+    assert report_dir.is_dir(), f"❌ {report_dir} is not a directory."
 
     md_file = report_dir.joinpath("slides.md")
     if not md_file.exists():
@@ -78,33 +75,28 @@ def main() -> None:
         if len(res) == 1:
             md_file = res.list[0]
         else:
-            raise FileNotFoundError(f"slides.md not found in {report_dir}")
+            raise FileNotFoundError(f"❌ slides.md not found in {report_dir}")
 
+    print("📂 Copying files to Slidev repository...")
     report_dir.search().apply(lambda x: x.copy(folder=SLIDEV_REPO, overwrite=True))
     if md_file.name != "slides.md":
         SLIDEV_REPO.joinpath(md_file.name).with_name(name="slides.md", inplace=True, overwrite=True)
 
-    # from machineconfig.utils.utils import check_tool_exists
-    # check_tool_exists(tool_name="slidev", install_script="npm i -g @slidev/cli")
-
     import socket
-    try: local_ip_v4 = socket.gethostbyname(socket.gethostname() + ".local")  # without .local, in linux machines, '/etc/hosts' file content, you have an IP address mapping with '127.0.1.1' to your hostname
+    try:
+        local_ip_v4 = socket.gethostbyname(socket.gethostname() + ".local")
     except Exception:
-        print("Warning: Could not get local_ip_v4. This is probably because you are running a WSL instance")  # TODO find a way to get the local_ip_v4 in WSL
+        print("⚠️ Warning: Could not get local_ip_v4. This might be due to running in a WSL instance.")
         local_ip_v4 = socket.gethostbyname(socket.gethostname())
 
-    print(f"Presentation is served at http://{platform.node()}:{port}")
-    print(f"Presentation is served at http://localhost:{port}")
-    print(f"Presentation is served at http://{local_ip_v4}:{port}")
-    # This version requires a globally installed cli of slidev, which is not recommended.
-    # program: str=f"cd {SLIDEV_REPO}; slidev --port {port} --remote 0.0.0.0; cd {P.cwd()}"
+    print("🌐 Presentation will be served at:")
+    print(f"   - http://{platform.node()}:{port}")
+    print(f"   - http://localhost:{port}")
+    print(f"   - http://{local_ip_v4}:{port}\n")
 
-    # The recommended approach is do `npm init slidev@latest` in the directory where you want to create the presentation
-    # Then you can do the following:
     program = "npm run dev slides.md -- --remote"
     PROGRAM_PATH.write_text(program)
     print_code(code=program, lexer="bash", desc="Run the following command to start the presentation")
 
-
 if __name__ == '__main__':
     main()

machineconfig/scripts/python/start_terminals.py

@@ -1,4 +1,3 @@
-
 """Script to start terminals on windows and wsl
 """
 
@@ -23,6 +22,7 @@ THIS_MACHINE_HOSTNAME_WSL = f"{THIS_MACHINE_HOSTNAME}wsl"
 
 
 def main_windows_and_wsl(window: int, hosts: list[str], orientation: ORIENTATION_TYPE = "vertical", mprocs: bool=False):
+    print("\n🔧 Configuring terminal layout for Windows and WSL...")
     orientation_oposite = "horizontal" if orientation == "vertical" else "vertical"
     orientation_swap                = "up" if orientation         == "horizontal" else "left"
     orientation_opposite_move_focus = "up" if orientation_oposite == "horizontal" else "left"
@@ -34,6 +34,7 @@ def main_windows_and_wsl(window: int, hosts: list[str], orientation: ORIENTATION
     size = 0.3
     known_hosts = get_ssh_hosts()
     if len(hosts) == 1:
+        print("🖥️ Single host detected. Configuring layout...")
         if "wsl" in hosts[0] or f"{hosts[0]}wsl" in known_hosts:  # its a windows machine with wsl
             host_wind = hosts[0] if "wsl" not in hosts[0] else hosts[0].split("wsl")[0]
             host_linux = f"{host_wind}wsl"
@@ -44,6 +45,7 @@ wt --window {window} --title {hosts[0]} powershell -Command "ssh {host_linux} {s
             cmd = f"""wt --window {window} --title {hosts[0]} powershell -Command "ssh {hosts[0]} {ssh_cmd}" `; split-pane --{orientation} --title {hosts[0]}wsl --size 0.1 powershell """
 
     elif len(hosts) > 1:
+        print("🖥️ Multiple hosts detected. Configuring layout...")
         pane_cmd = f'powershell -Command "ssh {hosts[0]} {ssh_cmd}" ' if hosts[0] != THIS_MACHINE else ''
         cmd = f"""wt --window {window} --title {hosts[0]} {pane_cmd} """
         for a_host in hosts[1:]:
@@ -57,20 +59,26 @@ wt --window {window} --title {hosts[0]} powershell -Command "ssh {host_linux} {s
             else: tmp = f"move-focus {orientation_opposite_move_focus}" if idx % 2 == 1 else f"move-focus {orientation_opposite_move_focus_other}"
             cmd += f"""{sep} {tmp} split-pane --{orientation} --title {a_host}wsl --size {size} {pane_cmd} """
             cmd += f"""{sep} swap-pane {orientation_swap} """
-    else: raise NotImplementedError(f"len(hosts) = {len(hosts)}. Only 1 or 2 hosts are supported.")
+    else: raise NotImplementedError(f"❌ len(hosts) = {len(hosts)}. Only 1 or 2 hosts are supported.")
+    print("✅ Terminal layout configured successfully!\n")
     return cmd
 
 
 def main():
     import argparse
+    print("\n" + "=" * 50)
+    print("🖥️ Welcome to the Terminal Starter Tool")
+    print("=" * 50 + "\n")
+
     parser = argparse.ArgumentParser()
-    parser.add_argument("--panes", "-p", type=int, help="The number of panes to open", default=4)
-    parser.add_argument("--vertical", "-V", action="store_true", help="Switch orientation to vertical from default horizontal")
-    parser.add_argument("--window", "-w", type=int, help="The window id to use", default=0)  # 0 refers to this window.
-    parser.add_argument("--hosts", "-H", type=str, nargs="*", help="The hosts to connect to", default=None)
+    parser.add_argument("--panes", "-p", type=int, help="🔲 The number of panes to open.", default=4)
+    parser.add_argument("--vertical", "-V", action="store_true", help="↕️ Switch orientation to vertical from default horizontal.")
+    parser.add_argument("--window", "-w", type=int, help="🪟 The window ID to use.", default=0)  # 0 refers to this window.
+    parser.add_argument("--hosts", "-H", type=str, nargs="*", help="🌐 The hosts to connect to.", default=None)
     args = parser.parse_args()
 
     if args.panes:
+        print("🔲 Configuring panes...")
         cmd = f"wt --window {args.window} --colorScheme '{next(THEMES_ITER)}' pwsh -NoExit -Command '{next(INIT_COMMANDS_ITER)}' "
         cmd += f" `; new-tab --colorScheme '{next(THEMES_ITER)}' --profile pwsh --title 't2' --tabColor '#f59218' "
         cmd += f" `; new-tab --colorScheme '{next(THEMES_ITER)}' --profile pwsh --title 't3' --tabColor '#009999' "
@@ -81,17 +89,22 @@ def main():
                 cmd += f" `; move-focus up split-pane --vertical --size {next(SIZE_ITER)} --colorScheme '{next(THEMES_ITER)}' pwsh -NoExit -Command '{next(INIT_COMMANDS_ITER)}' "
 
     else:
-        if args.hosts is None: hosts = display_options(msg="", options=get_ssh_hosts() + [THIS_MACHINE], multi=True, fzf=True)
+        if args.hosts is None:
+            print("🌐 No hosts provided. Displaying options...")
+            hosts = display_options(msg="Select hosts:", options=get_ssh_hosts() + [THIS_MACHINE], multi=True, fzf=True)
         else:
-            print("Using provided hosts", args.hosts)
+            print("🌐 Using provided hosts:", args.hosts)
             hosts = args.hosts
         assert isinstance(hosts, list)
         cmd = main_windows_and_wsl(window=args.window, hosts=hosts, orientation="vertical" if args.vertical else "horizontal")
 
+    print("\n📋 Generated Command:")
+    print("-" * 50)
     print(cmd)
-    # import clipboard
-    # install_n_import("clipboard").copy(cmd)
+    print("-" * 50 + "\n")
+
     PROGRAM_PATH.write_text(cmd)
+    print("✅ Command saved successfully!\n")
 
 
 if __name__ == '__main__':

machineconfig/scripts/python/viewer.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+from crocodile.file_management import Save, P
+from plotly import graph_objects as go
+import plotly.express as px
+from typing import Callable, Iterable, Any, Optional
+
+def default_get_figure(data: Any) -> go.Figure:
+    print("📊 Generating default figure using Plotly...")
+    return px.line(data)
+
+default_streamlit_config = """
+
+[server]
+headless = true
+port = 4614
+
+"""
+
+def run(data: Optional[Iterable[Any]], data_path: Optional[str],
+        get_figure: Optional[Callable[[Any], go.Figure]]):
+    print("\n" + "=" * 50)
+    print("👁️  Welcome to the Data Viewer Tool")
+    print("=" * 50 + "\n")
+
+    print("📂 Preparing viewer application...")
+    code = P(__file__).parent.joinpath("viewer_template.py").read_text(encoding='utf-8')
+
+    code_dir = P.tmpdir(prefix="viewer")
+    code_dir.joinpath(".streamlit").mkdir(parents=True, exist_ok=False)
+    code_dir.joinpath(".streamlit/config.toml").write_text(default_streamlit_config, encoding='utf-8')
+
+    if data_path is None:
+        print("💾 Saving data to temporary path...")
+        data_path = Save.pickle(obj=data, path=code_dir.joinpath("data.pkl"))
+
+    code = code.replace("""data_path = \"get_figure_placeholder.pkl\" """, f"""data_path = r"{data_path}" """)
+
+    import inspect
+    if get_figure is None:
+        print("📊 Using default figure generation function.")
+        get_figure = default_get_figure
+
+    code_func = inspect.getsource(get_figure)
+    code_parts = code.split("# get_figure_placeholder")
+    code = code_parts[0] + code_func + f"""\nget_figure = {get_figure.__name__}""" + code_parts[-1]
+
+    code_path = code_dir.joinpath("viewer_app.py")
+    Path(code_path).write_text(code, encoding='utf-8')
+
+    print("✅ Viewer application prepared successfully!")
+    print(f"📂 Application files saved to: {code_dir}\n")
+
+    return code_path