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

machineconfig/scripts/python/fire_jobs.py

@@ -1,15 +1,16 @@
 
 """
 fire
-"""
-
 
-from machineconfig.utils.utils import display_options, choose_one_option, PROGRAM_PATH, choose_ssh_host, match_file_name, sanitize_path
-# from crocodile.run import *
 # https://github.com/pallets/click combine with fire. Consider
 # https://github.com/ceccopierangiolieugenio/pyTermTk for display_options build TUI
 # https://github.com/chriskiehl/Gooey build commandline interface
-from crocodile.file_management import P, install_n_import
+
+"""
+
+
+from machineconfig.utils.utils import display_options, choose_one_option, PROGRAM_PATH, choose_ssh_host, match_file_name, sanitize_path
+from crocodile.file_management import P, install_n_import, Read
 from crocodile.core import Display, randstr
 import inspect
 import platform
@@ -18,49 +19,64 @@ from typing import Callable, Any, Optional
 import argparse
 
 
+def search_for_files_of_interest(path_obj: P):
+    if path_obj.joinpath(".venv").exists():
+        path_objects = path_obj.search("*", not_in=[".venv"]).list
+        files: list[P] = []
+        for a_path_obj in path_objects:
+            files += search_for_files_of_interest(path_obj=a_path_obj)
+        return files
+    py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True).list
+    ps_files = path_obj.search(pattern="*.ps1", r=True).list
+    sh_files = path_obj.search(pattern="*.sh", r=True).list
+    files = py_files + ps_files + sh_files
+    return files
+
+
+str2obj = {"True": True, "False": False, "None": None}
+
+
 def main() -> None:
     parser = argparse.ArgumentParser()
-    parser.add_argument("path", nargs='?', type=str, help="The directory containing the jobs", default=".")
+    parser.add_argument("path",     nargs='?', type=str, help="The directory containing the jobs", default=".")
     parser.add_argument("function", nargs='?', type=str, help="Fuction to run", default=None)
     # parser.add_argument("--function", "-f", type=str, help="The function to run", default="")
-    parser.add_argument("--ve", "-v", type=str, help="virtual enviroment name", default="")
-    parser.add_argument("--cmd", "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
-    parser.add_argument("--interactive", "-i", action="store_true", help="Whether to run the job interactively using IPython")
-    parser.add_argument("--debug", "-d", action="store_true", help="debug")
+    parser.add_argument("--ve",              "-v", type=str, help="virtual enviroment name", default="")
+    parser.add_argument("--cmd",             "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
+    parser.add_argument("--interactive",     "-i", action="store_true", help="Whether to run the job interactively using IPython")
+    parser.add_argument("--debug",           "-d", action="store_true", help="debug")
     parser.add_argument("--choose_function", "-c", action="store_true", help="debug")
-    parser.add_argument("--loop", "-l", action="store_true", help="infinite recusion (runs again after completion)")
-    parser.add_argument("--jupyter", "-j", action="store_true", help="open in a jupyter notebook")
+    parser.add_argument("--loop",            "-l", action="store_true", help="infinite recusion (runs again after completion)")
+    parser.add_argument("--jupyter",         "-j", action="store_true", help="open in a jupyter notebook")
     parser.add_argument("--submit_to_cloud", "-C", action="store_true", help="submit to cloud compute")
-    parser.add_argument("--remote", "-r", action="store_true", help="launch on a remote machine")
-    parser.add_argument("--module", "-m", action="store_true", help="launch the main file")
-    parser.add_argument("--streamlit", "-S", action="store_true", help="run as streamlit app")
-    parser.add_argument("--history", "-H", action="store_true", help="choose from history")
+    parser.add_argument("--remote",          "-r", action="store_true", help="launch on a remote machine")
+    parser.add_argument("--module",          "-m", action="store_true", help="launch the main file")
+    parser.add_argument("--streamlit",       "-S", action="store_true", help="run as streamlit app")
+    parser.add_argument("--history",         "-H", action="store_true", help="choose from history")
+    # parser.add_argument("--git_pull",        "-g", action="store_true", help="Start by pulling the git repo")
+    parser.add_argument("--optimized", "-O", action="store_true", help="Run the optimized version of the function")
+    parser.add_argument("--Nprocess",        "-p", type=int, help="Number of processes to use", default=1)
     parser.add_argument("--kw", nargs="*", default=None, help="keyword arguments to pass to the function in the form of k1 v1 k2 v2 ...")
 
     args = parser.parse_args()
     if args.kw is not None:
         assert len(args.kw) % 2 == 0, f"args.kw must be a list of even length. Got {len(args.kw)}"
         kwargs = dict(zip(args.kw[::2], args.kw[1::2]))
+        for key, value in kwargs.items():
+            if value in str2obj:
+                kwargs[key] = str2obj[value]
         # print(f"kwargs = {kwargs}")
     else:
         kwargs = {}
 
     path_obj = sanitize_path(P(args.path))
     if not path_obj.exists():
-        print("This pathway")
-        path_obj = match_file_name(args.path)
-        print(path_obj)
-    else:
-        print("This directory")
-        print(path_obj)
+        path_obj = match_file_name(sub_string=args.path)
+    else: pass
 
     if path_obj.is_dir():
         print(f"Seaching recursively for all python file in directory `{path_obj}`")
-        py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True).list
-        ps_files = path_obj.search(pattern="*.ps1", r=True).list
-        sh_files = path_obj.search(pattern="*.sh", r=True).list
-        files = py_files + ps_files + sh_files
-
+        files = search_for_files_of_interest(path_obj)
         choice_file = choose_one_option(options=files, fzf=True)
         choice_file = P(choice_file)
     else:
@@ -68,10 +84,9 @@ def main() -> None:
 
     if choice_file.suffix in [".ps1", ".sh"]:
         PROGRAM_PATH.write_text(f". {choice_file}")
-        return
+        return None
 
     if args.choose_function or args.submit_to_cloud:
-
         options, func_args = parse_pyfile(file_path=str(choice_file))
         choice_function_tmp = display_options(msg="Choose a function to run", options=options, fzf=True, multi=False)
         assert isinstance(choice_function_tmp, str), f"choice_function must be a string. Got {type(choice_function_tmp)}"
@@ -83,13 +98,28 @@ def main() -> None:
         if len(choice_function_args) > 0 and len(kwargs) == 0:
             for item in choice_function_args:
                 kwargs[item.name] = input(f"Please enter a value for argument `{item.name}` (type = {item.type}) (default = {item.default}) : ") or item.default
-    else: choice_function = args.function
+    else:
+        choice_function = args.function
 
     if args.ve == "":
         from machineconfig.utils.ve import get_ve_profile  # if file name is passed explicitly, then, user probably launched it from cwd different to repo root, so activate_ve can't infer ve from .ve_path, so we attempt to do that manually here
         args.ve = get_ve_profile(choice_file)
 
-    if args.streamlit: exe = "streamlit run --server.address 0.0.0.0 "
+    if args.streamlit:
+        from crocodile.environment import get_network_addresses
+        local_ip_v4 = get_network_addresses()["local_ip_v4"]
+        computer_name = platform.node()
+        port = 8501
+        if choice_file.parent.joinpath(".streamlit/config.toml").exists():
+            config = Read.toml(choice_file.parent.joinpath(".streamlit/config.toml"))
+            if "server" in config:
+                if "port" in config["server"]:
+                    port = config["server"]["port"]
+        message = f"🚀 Streamlit app is running @:\n1- http://{local_ip_v4}:{port}\n2- http://{computer_name}:{port}\n3- http://localhost:{port}"
+        from rich.panel import Panel
+        from rich import print as rprint
+        rprint(Panel(message))
+        exe = "streamlit run --server.address 0.0.0.0 --server.headless true"
     elif args.interactive is False: exe = "python"
     elif args.jupyter: exe = "jupyter-lab"
     else:
@@ -97,12 +127,13 @@ def main() -> None:
         exe = f"ipython -i --no-banner --profile {get_ipython_profile(choice_file)} "
 
     if args.module or (args.debug and args.choose_function):  # because debugging tools do not support choosing functions and don't interplay with fire module. So the only way to have debugging and choose function options is to import the file as a module into a new script and run the function of interest there and debug the new script.
-        txt: str = f"""
+        import_line = get_import_module_code(str(choice_file))
+        txt: str=f"""
 try:
-    {get_import_module_code(str(choice_file))}
+    {import_line}
 except (ImportError, ModuleNotFoundError) as ex:
-    print(fr"Failed to import {choice_file} the proper way. {{ex}} ")
-    print(fr"The way below is rather hacky and can cause issues in pickling.")
+    print(fr"Failed to import `{choice_file}` the proper way. {{ex}} ")
+    print(fr"Importing with an ad-hoc `$PATH` manipulation. DO NOT pickle any files in this session as there is no gaurantee of correct deserialization.")
     import sys
     sys.path.append(r'{P(choice_file).parent}')
     from {P(choice_file).stem} import *
@@ -110,11 +141,17 @@ except (ImportError, ModuleNotFoundError) as ex:
 """
         if choice_function is not None:
             txt = txt + f"""
-{choice_function}({('**' + str(kwargs)) if kwargs else ''})
+res = {choice_function}({('**' + str(kwargs)) if kwargs else ''})
 """
         txt = f"""
-from machineconfig.utils.utils import print_code
-print_code(code=r'''{txt}''', lexer='python', desc='Import Script')
+try:
+    from rich.panel import Panel
+    from rich.console import Console
+    from rich.syntax import Syntax
+    console = Console()
+    console.print(Panel(Syntax(code=r'''{txt}''', lexer='python'), title='Import Script'), style="bold red")
+except ImportError as _ex:
+    print(r'''{txt}''')
 """ + txt
         choice_file = P.tmp().joinpath(f'tmp_scripts/python/{P(choice_file).parent.name}_{P(choice_file).stem}_{randstr()}.py').create(parents_only=True).write_text(txt)
 
@@ -131,15 +168,19 @@ print_code(code=r'''{txt}''', lexer='python', desc='Import Script')
         if not kwargs:  # empty dict
             kwargs_str = ''
         else:
-            tmp_list: list[str] = []
-            for k, v in kwargs.items():
-                if v is not None:
-                    item = f'"{k}": "{v}"'
-                else:
-                    item = f'"{k}": None'
-                tmp_list.append(item)
-            tmp__ = ", ".join(tmp_list)
-            kwargs_str = "'{" + tmp__  + "}'"
+            if len(kwargs) == 1:
+                kwargs_str = f""" --{list(kwargs.keys())[0]} {list(kwargs.values())[0]} """
+            else:
+                # print(f"len(kwargs) = {len(kwargs)}")
+                tmp_list: list[str] = []
+                for k, v in kwargs.items():
+                    if v is not None:
+                        item = f'"{k}": "{v}"'
+                    else:
+                        item = f'"{k}": None'
+                    tmp_list.append(item)
+                tmp__ = ", ".join(tmp_list)
+                kwargs_str = "'{" + tmp__  + "}'"
         command = f"{exe} -m fire {choice_file} {choice_function} {kwargs_str}"
         # else:
         #     print(f"{kwargs=}")
@@ -152,19 +193,22 @@ print_code(code=r'''{txt}''', lexer='python', desc='Import Script')
         else:
             if not args.cmd:
                 # for .streamlit config to work, it needs to be in the current directory.
-                command = f"cd {choice_file.parent}; {exe} {choice_file.name}; cd {P.cwd()}"
+                command = f"cd {choice_file.parent}\n\n{exe} {choice_file.name}\n\ncd {P.cwd()}"
             else:
                 command = rf""" cd /d {choice_file.parent} & {exe} {choice_file.name} """
-            # command = f"cd {choice_file.parent}; {exe} {choice_file.name}; cd {P.cwd()}"
+            # command = f"cd {choice_file.parent}\n\n{exe} {choice_file.name}\n\ncd {P.cwd()}"
 
     # this installs in ve env, which is not execution env
     # if "ipdb" in command: install_n_import("ipdb")
     # if "pudb" in command: install_n_import("pudb")
 
     if not args.cmd:
-        if "ipdb" in command: command = f"pip install ipdb; {command}"
-        if "pudb" in command: command = f"pip install pudb; {command}"
-        command = f". activate_ve {args.ve}; {command}"
+        if "ipdb" in command: command = f"pip install ipdb\n\n{command}"
+        if "pudb" in command: command = f"pip install pudb\n\n{command}"
+        if platform.system() == "Windows":
+            command = f". $HOME/scripts/activate_ve {args.ve}\n\n{command}"
+        else:
+            command = f". $HOME/scripts/activate_ve {args.ve}\n\n{command}"
     else:
         # CMD equivalent
         if "ipdb" in command: command = f"pip install ipdb & {command}"
@@ -174,19 +218,40 @@ print_code(code=r'''{txt}''', lexer='python', desc='Import Script')
 
     if args.submit_to_cloud:
         command = f"""
-. activate_ve {args.ve}
+. $HOME/scripts/activate_ve {args.ve}
 python -m crocodile.cluster.templates.cli_click --file {choice_file} """
         if choice_function is not None: command += f"--function {choice_function} "
     try: install_n_import("clipboard").copy(command)
     except Exception as ex: print(f"Failed to copy command to clipboard. {ex}")
 
     if args.loop:
-        command = command + f"\n" + f". {PROGRAM_PATH}"
+        command = command + "\n" + f". {PROGRAM_PATH}"
+
+    if args.Nprocess > 1:
+        lines = [f""" zellij action new-tab --name nProcess{randstr(2)}"""]
+        command = command.replace(". activate_ve", ". $HOME/scripts/activate_ve")
+        for an_arg in range(args.Nprocess):
+            sub_command = f"{command} --idx={an_arg} --idx_max={args.Nprocess}"
+            if args.optimized:
+                sub_command = sub_command.replace("python ", "python -OO ")
+            sub_command_path = P.tmpfile(suffix=".sh").write_text(sub_command)
+            lines.append(f"""zellij action new-pane -- bash {sub_command_path}  """)
+            lines.append("sleep 1")  # python tends to freeze if you launch instances within 1 microsecond of each other
+        command = "\n".join(lines)
 
     # TODO: send this command to terminal history. In powershell & bash there is no way to do it with a command other than goiing to history file. In Mcfly there is a way but its linux only tool. # if platform.system() == "Windows": command = f" ({command}) | Add-History  -PassThru "
-    print(f"🔥 command:\n{command}\n\n")
+    # mcfly add --exit 0 command
+    if args.optimized:
+        # note that in ipython, optimization is meaningless.
+        command = command.replace("python ", "python -OO ")
     # if platform.system() == "Linux":
     #     command = "timeout 1s aafire -driver slang\nclear\n" + command
+
+    from rich.panel import Panel
+    from rich.console import Console
+    from rich.syntax import Syntax
+    console = Console()
+    console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {PROGRAM_PATH}: "), style="bold red")
     PROGRAM_PATH.write_text(command)
 
 
@@ -235,11 +300,11 @@ def parse_pyfile(file_path: str):
     return options, func_args
 
 
-def get_attrs(obj: Any):
+def get_attrs_recursively(obj: Any):
     if hasattr(obj, '__dict__'):
         res = {}
         for k, v in obj.__dict__.items():
-            res[k] = get_attrs(v)
+            res[k] = get_attrs_recursively(v)
         return res
     return obj
 
@@ -258,7 +323,8 @@ def interactively_run_function(func: Callable[[Any], Any]):
             if value == "": value = default
         else: value = input(f"Please enter a value for argument `{param.name}` (type = {hint}) : ")
         try:
-            if param.annotation is not inspect.Parameter.empty: value = param.annotation(value)
+            if param.annotation is not inspect.Parameter.empty:
+                value = param.annotation
         except (TypeError, ValueError) as err:
             raise ValueError(f"Invalid input: {value} is not of type {param.annotation}") from err
         if param.kind == inspect.Parameter.KEYWORD_ONLY: kwargs[param.name] = value
@@ -281,25 +347,32 @@ def run_on_remote(func_file: str, args: argparse.Namespace):
     m.run()
 
 
-def find_root_path(start_path: str):
+def find_repo_root_path(start_path: str) -> Optional[str]:
     root_files = ['setup.py', 'pyproject.toml', '.git']
-    path = start_path
-    while path != '/':
+    path: str=start_path
+    trials = 0
+    root_path = os.path.abspath(os.sep)
+    while path != root_path and trials < 20:
         for root_file in root_files:
             if os.path.exists(os.path.join(path, root_file)):
+                print(f"Found repo root path: {path}")
                 return path
         path = os.path.dirname(path)
+        trials += 1
     return None
 
 
 def get_import_module_code(module_path: str):
-    root_path = find_root_path(module_path)
+    root_path = find_repo_root_path(module_path)
     if root_path is None:  # just make a desperate attempt to import it
         module_name = module_path.lstrip(os.sep).replace(os.sep, '.').replace('.py', '')
-        return f"from {module_path} import *"
-    relative_path = module_path.replace(root_path, '')
-    module_name = relative_path.lstrip(os.sep).replace(os.sep, '.').replace('.py', '')
-    module_name = module_name.replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("resources.", "").replace("source.", "")
+    else:
+        relative_path = module_path.replace(root_path, '')
+        module_name = relative_path.lstrip(os.sep).replace(os.sep, '.').replace('.py', '')
+        module_name = module_name.replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("myresources.", "").replace("resources.", "").replace("source.", "").replace("src.", "").replace("resources.", "").replace("source.", "")
+    if any(char in module_name for char in "- :/\\"):
+        module_name = "IncorrectModuleName"
+    # TODO: use py_compile to check if the statement is valid code to avoid syntax errors that can't be caught.
     return f"from {module_name} import *"
 
 

machineconfig/scripts/python/ftpx.py

@@ -3,6 +3,7 @@
 
 TODO: add support for cases in which source or target has non 22 default port number and is defineda as user@host:port:path which makes 2 colons in the string.
 Currently, the only way to work around this is to predifine the host in ~/.ssh/config and use the alias in the source or target which is inconvenient when dealing with newly setup machines.
+
 """
 
 import argparse
@@ -19,6 +20,7 @@ def main():
     # 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
+    parser.add_argument("--cloud", "-c", help="Transfer through the cloud.", action="store_true")  # default is False
 
     args = parser.parse_args()
 
@@ -54,6 +56,7 @@ def main():
         raise ValueError("Either source or target must be a remote path (i.e. machine:path)")
 
     Struct({"source": str(source), "target": str(target), "machine": machine}).print(as_config=True, title="CLI Resolution")
+
     from paramiko.ssh_exception import AuthenticationException  # type: ignore
     try:
         ssh = SSH(rf'{machine}')
@@ -64,14 +67,21 @@ def main():
         pwd = getpass.getpass()
         ssh = SSH(rf'{machine}', pwd=pwd)
 
-    if source_is_remote:
-        assert source is not None, "source must be a remote path (i.e. machine:path)"
-        print(f"Running: received_file = ssh.copy_to_here(source={source}, target={target}, z={args.zipFirst}, r={args.recursive})")
-        received_file = ssh.copy_to_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
+    if args.cloud:
+        print("Uploading from remote to cloud ...")
+        ssh.run(f"cloud_copy {source} :^", desc="Uploading from remote to the cloud.").print()
+        print("Downloading from cloud to local ...")
+        ssh.run_locally(f"cloud_copy :^ {target}").print()
+        received_file = P(target)  # type: ignore
     else:
-        assert source is not None, "target must be a remote path (i.e. machine:path)"
-        print(f"Running: received_file = ssh.copy_from_here(source={source}, target={target}, z={args.zipFirst}, r={args.recursive})")
-        received_file = ssh.copy_from_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
+        if source_is_remote:
+            assert source is not None, "source must be a remote path (i.e. machine:path)"
+            print(f"Running: received_file = ssh.copy_to_here(source=r'{source}', target=r'{target}', z={args.zipFirst}, r={args.recursive})")
+            received_file = ssh.copy_to_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
+        else:
+            assert source is not None, "target must be a remote path (i.e. machine:path)"
+            print(f"Running: received_file = ssh.copy_from_here(source=r'{source}', target=r'{target}', z={args.zipFirst}, r={args.recursive})")
+            received_file = ssh.copy_from_here(source=source, target=target, z=args.zipFirst, r=args.recursive)
     # ssh.print_summary()
     # if P(args.file).is_dir(): print(f"Use: cd {repr(P(args.file).expanduser())}")
     if source_is_remote and isinstance(received_file, P):

machineconfig/scripts/python/gh_models.py

@@ -0,0 +1,53 @@
+
+# as per https://github.com/marketplace/models/azure-openai/o1-preview
+from openai import OpenAI
+from crocodile.file_management import Read, P
+
+
+gh_token = Read.ini(P.home().joinpath("dotfiles/creds/git/git_host_tokens.ini"))['thisismygitrepo']['newLongterm']
+endpoint = "https://models.inference.ai.azure.com"
+model_name_preferences = ["o1-preview", "o1-mini", "GPT-4o", "GPT-4-o-mini"]
+client__ = OpenAI(
+    base_url=endpoint,
+    api_key=gh_token,
+)
+
+def get_response(client, model_name, messages):
+    try:
+        response = client.chat.completions.create(
+            messages=messages,
+            model=model_name
+        )
+        return response.choices
+    except Exception as e:
+        print(f"Error with model {model_name}: {e}")
+        return None
+
+
+def interactive_chat():
+    conversation_history = []
+    model_index = 0
+    model_name = model_name_preferences[model_index]
+    while True:
+        print(f"Using model {model_name}".center(80, "="))
+        while True:
+            user_input = input("You: ")
+            conversation_history.append({"role": "user", "content": user_input})
+
+            while True:
+                choices = get_response(client__, model_name, conversation_history)
+                if choices is None:
+                    model_index += 1
+                    model_name = model_name_preferences[model_index % len(model_name_preferences)]
+                    print(f"Switching to model {model_name}".center(80, "="))
+                    continue
+                else:
+                    break
+
+            for a_choice in choices:
+                response_content = a_choice.message.content
+                print("\n" * 5)
+                print(f"AI: {response_content}")
+                conversation_history.append({"role": "assistant", "content": response_content})
+
+interactive_chat()

machineconfig/scripts/python/mount_nfs.py

@@ -11,7 +11,7 @@ import platform
 
 
 def main():
-    print(f"Mounting NFS Share ... ")
+    print("Mounting NFS Share ... ")
     share_info = input("share path? (e.g. machine:~/data/share_nfs) [press enter for interactive choice] = ")
     if share_info == "":
         tmp = choose_ssh_host(multi=False)

machineconfig/scripts/python/mount_nw_drive.py

@@ -6,15 +6,15 @@ import platform
 
 
 def main():
-    print(f"Welcome to the WindowsNetworkDrive Mounting Wizard")
+    print("Welcome to the WindowsNetworkDrive Mounting Wizard")
     drive_location = input("Enter the network drive location (ex: //192.168.1.100/Share): ")
     machine_name = drive_location.split("//")[1].split("/")[0]
     mount_point = input(f"Enter the mount point directory (ex: /mnt/network) [default: ~/data/mount_nw/{machine_name}]: ")
     if mount_point == "": mount_point = P.home().joinpath(fr"data/mount_nw/{machine_name}")
     else: mount_point = P(mount_point).expanduser()
 
-    username = input(f"Enter the username: ")
-    password = input(f"Enter the password: ")
+    username = input("Enter the username: ")
+    password = input("Enter the password: ")
     if platform.system() == "Linux":
         PROGRAM_PATH.write_text(f"""
 drive_location='{drive_location}'

machineconfig/scripts/python/mount_ssh.py

@@ -11,8 +11,7 @@ from machineconfig.utils.utils import PROGRAM_PATH, choose_ssh_host
 
 
 def main():
-
-    print(f"Mounting SSHFS ... ")
+    print("Mounting SSHFS ... ")
     share_info = input("share path? (e.g. user@host:/path) [press enter for interactive choice] = ")
     if share_info == "":
         tmp = choose_ssh_host(multi=False)
@@ -28,7 +27,7 @@ def main():
     if mount_point == "": mount_point = P.home().joinpath(fr"data/mount_ssh/{ssh.hostname}")
 
     if system() == "Linux":
-        txt = fr"""
+        txt = """
 sshfs alex@:/media/dbhdd /media/dbhdd\
 """
     elif system() == "Windows":

machineconfig/scripts/python/pomodoro.py

@@ -16,7 +16,7 @@ def pomodoro(work: int = 25, rest: int = 5, repeats: int = 4):
         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.str]; pyglet.resource.reindex(); pyglet.resource.media(tmp.name).play()
+        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}')