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

machineconfig/scripts/python/dotfile.py

@@ -1,8 +1,12 @@
 
-import argparse
-import crocodile.toolbox as tb
+"""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():
@@ -15,14 +19,14 @@ def main():
     parser.add_argument("-d", "--dest", help=f"destination folder", default="")
 
     args = parser.parse_args()
-    orig_path = tb.P(args.file).expanduser().absolute()
+    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 = tb.P(args.dest).expanduser().absolute().create().joinpath(orig_path.name)
+    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)
 

machineconfig/scripts/python/fire_jobs.py

@@ -1,14 +1,17 @@
 
 """
 fire
-"""
 
-import crocodile.toolbox as tb
-from machineconfig.utils.utils import display_options, 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 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
+from crocodile.core import Display, randstr
 import inspect
 import platform
 import os
@@ -16,22 +19,25 @@ from typing import Callable, Any, Optional
 import argparse
 
 
-def main():
+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("--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("--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()
@@ -42,8 +48,11 @@ def main():
     else:
         kwargs = {}
 
-    path_obj = sanitize_path(tb.P(args.path))
-    if not path_obj.exists(): path_obj = match_file_name(args.path)
+    path_obj = sanitize_path(P(args.path))
+    if not path_obj.exists():
+        path_obj = match_file_name(args.path)
+        print(path_obj)
+    else: pass
 
     if path_obj.is_dir():
         print(f"Seaching recursively for all python file in directory `{path_obj}`")
@@ -52,18 +61,16 @@ def main():
         sh_files = path_obj.search(pattern="*.sh", r=True).list
         files = py_files + ps_files + sh_files
 
-        choice_file = display_options(msg="Choose a file to run", options=files, fzf=True, multi=False)
-        assert not isinstance(choice_file, list), f"choice_file must be a string. Got {type(choice_file)}"
-        choice_file = tb.P(choice_file)
+        choice_file = choose_one_option(options=files, fzf=True)
+        choice_file = P(choice_file)
     else:
         choice_file = path_obj
 
     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)}"
@@ -75,39 +82,55 @@ def main():
         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"
+    if args.streamlit:
+        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
+        except Exception:
+            print(f"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
+            local_ip_v4 = socket.gethostbyname(socket.gethostname())
+        print(f"🚀 Streamlit app is running at: http://{local_ip_v4}:8501")
+        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:
         from machineconfig.utils.ve import get_ipython_profile
         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.
+        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'{tb.P(choice_file).parent}')
-    from {tb.P(choice_file).stem} import *
+    sys.path.append(r'{P(choice_file).parent}')
+    from {P(choice_file).stem} import *
 
 """
         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='Imported 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 = tb.P.tmp().joinpath(f'tmp_scripts/python/{tb.P(choice_file).parent.name}_{tb.P(choice_file).stem}_{tb.randstr()}.py').create(parents_only=True).write_text(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)
 
     # determining basic command structure: putting together exe & choice_file & choice_function & pdb
     if args.debug:
@@ -118,8 +141,24 @@ print_code(code=r'''{txt}''', lexer='python', desc='Imported Script')
         else: raise NotImplementedError(f"Platform {platform.system()} not supported.")
     elif choice_function is not None and not args.module:  # if args.module, then kwargs are handled in the impot script, no need to pass them in fire command.
         # https://google.github.io/python-fire/guide/
-        tmp = f"'{kwargs}'" if kwargs else ''
-        command = f"{exe} -m fire {choice_file} {choice_function} {tmp}"
+        # https://github.com/google/python-fire/blob/master/docs/guide.md#argument-parsing
+        if not kwargs:  # empty dict
+            kwargs_str = ''
+        else:
+            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=}")
         #     print(f"{choice_function_args=}")
@@ -131,16 +170,26 @@ print_code(code=r'''{txt}''', lexer='python', desc='Imported 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 {tb.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 {tb.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}\n\n{exe} {choice_file.name}\n\ncd {P.cwd()}"
 
-    if "ipdb" in command: tb.install_n_import("ipdb")
-    if "pudb" in command: tb.install_n_import("pudb")
+    # 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:
-        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". activate_ve {args.ve}\n\n{command}"
+        else:
+            command = f". ~/scripts/activate_ve {args.ve}\n\n{command}"
     else:
+        # CMD equivalent
+        if "ipdb" in command: command = f"pip install ipdb & {command}"
+        if "pudb" in command: command = f"pip install pudb & {command}"
         command = fr"""start cmd -Argument "/k %USERPROFILE%\venvs\{args.ve}\Scripts\activate.bat & {command} " """  # this works from powershell
         # this works from cmd  # command = fr""" start cmd /k "%USERPROFILE%\venvs\{args.ve}\Scripts\activate.bat & {command} " """ # because start in cmd is different from start in powershell (in powershell it is short for Start-Process)
 
@@ -149,13 +198,24 @@ print_code(code=r'''{txt}''', lexer='python', desc='Imported Script')
 . 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: tb.install_n_import("clipboard").copy(command)
+    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}"
 
+    if args.Nprocess > 1:
+        lines = [f""" zellij action new-tab --name nProcess{randstr(2)}"""]
+        command = command.replace(". activate_ve", ". ~/scripts/activate_ve")
+        for an_arg in range(args.Nprocess):
+            sub_command = f"{command} --idx={an_arg} --idx_max={args.Nprocess}"
+            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 "
+    # mcfly add --exit 0 command
     print(f"🔥 command:\n{command}\n\n")
     # if platform.system() == "Linux":
     #     command = "timeout 1s aafire -driver slang\nclear\n" + command
@@ -169,14 +229,14 @@ def parse_pyfile(file_path: str):
     func_args: list[list[args_spec]] = [[]]  # this firt prepopulated dict is for the option 'RUN AS MAIN' which has no args
 
     import ast
-    parsed_ast = ast.parse(tb.P(file_path).read_text(encoding='utf-8'))
+    parsed_ast = ast.parse(P(file_path).read_text(encoding='utf-8'))
     functions = [
         node
         for node in ast.walk(parsed_ast)
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
     ]
     module__doc__ = ast.get_docstring(parsed_ast)
-    main_option = f"RUN AS MAIN -- {tb.Display.get_repr(module__doc__, limit=150) if module__doc__ is not None else 'NoDocs'}"
+    main_option = f"RUN AS MAIN -- {Display.get_repr(module__doc__, limit=150) if module__doc__ is not None else 'NoDocs'}"
     options = [main_option]
     for function in functions:
         if function.name.startswith('__') and function.name.endswith('__'): continue
@@ -192,7 +252,7 @@ def parse_pyfile(file_path: str):
                 except KeyError as ke:
                     # type_ = arg.annotation.__name__
                     # print(f"Failed to get type for {arg.annotation}. {ke}")
-                    # tb.Struct(get_attrs(arg.annotation)).print(as_yaml=True)
+                    # Struct(get_attrs(arg.annotation)).print(as_yaml=True)
                     type_ = "Any"  # e.g. a callable object
                     _ = ke
                     # raise ke
@@ -207,11 +267,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
 
@@ -253,28 +313,78 @@ 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 *"
 
 
+def get_jupyter_notebook(python_code: str):
+    template = """
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7412902a-3074-475b-9820-71b82e670a2a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import math"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
+"""
+    template.replace('"import math"', python_code)
+    return template
+
+
 if __name__ == '__main__':
     # options, func_args = parse_pyfile(file_path="C:/Users/aalsaf01/code/crocodile/myresources/crocodile/core.py")
     main()

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,17 +67,24 @@ 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 isinstance(received_file, P):
+    if source_is_remote and isinstance(received_file, P):
         print(f"Received: {repr(received_file.parent), repr(received_file)}")
 
 

machineconfig/scripts/python/mount_nfs.py

@@ -2,7 +2,10 @@
 """NFS mounting script
 """
 
-import crocodile.toolbox as tb
+
+from crocodile.file_management import P
+from crocodile.meta import SSH, Terminal
+from crocodile.core import List as L
 from machineconfig.utils.utils import display_options, PROGRAM_PATH, choose_ssh_host
 import platform
 
@@ -13,22 +16,22 @@ def main():
     if share_info == "":
         tmp = choose_ssh_host(multi=False)
         assert isinstance(tmp, str)
-        ssh = tb.SSH(tmp)
+        ssh = SSH(tmp)
         default = f"{ssh.hostname}:{ssh.run('echo $HOME').op}/data/share_nfs"
-        share_info = display_options("Choose a share path: ", options=tb.L(ssh.run("cat /etc/exports").op.split("\n")).filter(lambda x: not x.startswith("#")).apply(lambda x: f"{ssh.hostname}:{x.split(' ')[0]}").list + [default], default=default)
+        share_info = display_options("Choose a share path: ", options=L(ssh.run("cat /etc/exports").op.split("\n")).filter(lambda x: not x.startswith("#")).apply(lambda x: f"{ssh.hostname}:{x.split(' ')[0]}").list + [default], default=default)
         assert isinstance(share_info, str), f"share_info must be a string. Got {type(share_info)}"
     remote_server = share_info.split(":")[0]
     share_path = share_info.split(":")[1]
 
     if platform.system() == "Linux":
-        mount_path_1 = tb.P(share_path)
+        mount_path_1 = P(share_path)
         print(remote_server)
-        mount_path_2 = tb.P.home().joinpath(f"data/mount_nfs/{remote_server}")
-        if str(mount_path_1).startswith("/home"): mount_path_3 = tb.P.home().joinpath(*mount_path_1.parts[3:])
+        mount_path_2 = P.home().joinpath(f"data/mount_nfs/{remote_server}")
+        if str(mount_path_1).startswith("/home"): mount_path_3 = P.home().joinpath(*mount_path_1.parts[3:])
         else: mount_path_3 = mount_path_2
         local_mount_point = display_options(msg="choose mount path OR input custom one", options=[mount_path_1, mount_path_2, mount_path_3], default=mount_path_2, custom_input=True)
-        assert isinstance(local_mount_point, tb.P), f"local_mount_point must be a pathlib.Path. Got {type(local_mount_point)}"
-        local_mount_point = tb.P(local_mount_point).expanduser()
+        assert isinstance(local_mount_point, P), f"local_mount_point must be a pathlib.Path. Got {type(local_mount_point)}"
+        local_mount_point = P(local_mount_point).expanduser()
         PROGRAM_PATH.write_text(f"""
 share_info={share_info}
 remote_server={remote_server}
@@ -36,14 +39,14 @@ share_path={share_path}
 local_mount_point={local_mount_point}
     """)
     elif platform.system() == "Windows":
-        print(tb.Terminal().run("Get-PSDrive -PSProvider 'FileSystem'", shell="powershell").op)
+        print(Terminal().run("Get-PSDrive -PSProvider 'FileSystem'", shell="powershell").op)
         driver_letter = input(r"Choose driver letter (e.g. Z:\) (avoid the ones already used) : ") or "Z:\\"
         PROGRAM_PATH.write_text(f"""
 $server = "{remote_server}"
 $sharePath = "{share_path}"
 $driveLetter = "{driver_letter}"
 """)
-    # tb.P.home().joinpath(f"data/mount_nfs/{remote_server}").symlink_to(target="")  # can't be created until the mount is finished
+    # P.home().joinpath(f"data/mount_nfs/{remote_server}").symlink_to(target="")  # can't be created until the mount is finished
     print(PROGRAM_PATH.read_text())
 
 

machineconfig/scripts/python/mount_nw_drive.py

@@ -1,6 +1,7 @@
 
-import crocodile.toolbox as tb
+
 from machineconfig.utils.utils import PROGRAM_PATH
+from crocodile.file_management import P
 import platform
 
 
@@ -9,8 +10,8 @@ def main():
     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 = tb.P.home().joinpath(fr"data/mount_nw/{machine_name}")
-    else: mount_point = tb.P(mount_point).expanduser()
+    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: ")

machineconfig/scripts/python/mount_ssh.py

@@ -2,8 +2,11 @@
 """Mount a remote SSHFS share on a local directory
 """
 
-import crocodile.toolbox as tb
+
 from platform import system
+from crocodile.meta import SSH, Terminal
+from crocodile.file_management import P
+
 from machineconfig.utils.utils import PROGRAM_PATH, choose_ssh_host
 
 
@@ -14,15 +17,15 @@ def main():
     if share_info == "":
         tmp = choose_ssh_host(multi=False)
         assert isinstance(tmp, str)
-        ssh = tb.SSH(host=tmp)
+        ssh = SSH(host=tmp)
         share_info = f"{ssh.username}@{ssh.hostname}:{ssh.run('echo $HOME').op}/data/share_ssh"
     else:
-        ssh = tb.SSH(share_info.split(":")[0])
-    print(tb.Terminal().run("net use", shell="powershell").op)
+        ssh = SSH(share_info.split(":")[0])
+    print(Terminal().run("net use", shell="powershell").op)
     driver_letter = input(r"Choose driver letter (e.g. Z:\) (avoid the ones already used) : ") or "Z:\\"
 
     mount_point = input(f"Enter the mount point directory (ex: /mnt/network) [default: ~/data/mount_ssh/{ssh.hostname}]: ")
-    if mount_point == "": mount_point = tb.P.home().joinpath(fr"data/mount_ssh/{ssh.hostname}")
+    if mount_point == "": mount_point = P.home().joinpath(fr"data/mount_ssh/{ssh.hostname}")
 
     if system() == "Linux":
         txt = fr"""