machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/scripts/python/fire_jobs.py

@@ -1,220 +1,9 @@
-"""
-fire
+"""fire - Fire and manage jobs."""
 
-# https://github.com/pallets/click combine with fire. Consider
-# https://github.com/ceccopierangiolieugenio/pyTermTk for choose_from_options build TUI
-# https://github.com/chriskiehl/Gooey build commandline interface
-
-"""
-
-from machineconfig.utils.ve import get_ve_activate_line, get_ve_path_and_ipython_profile
-from machineconfig.utils.options import choose_from_options
-from machineconfig.utils.path_helper import match_file_name, sanitize_path
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.accessories import get_repo_root, randstr
-from machineconfig.scripts.python.helpers_fire_command.fire_jobs_args_helper import FireJobArgs, extract_kwargs, parse_fire_args_from_context
-
-import platform
 from typing import Optional, Annotated
-from pathlib import Path
 import typer
 
 
-def route(args: FireJobArgs, fire_args: str = "") -> None:
-    path_obj = sanitize_path(args.path)
-    if not path_obj.exists():
-        suffixes = {".py", ".sh", ".ps1"}
-        choice_file = match_file_name(sub_string=args.path, search_root=PathExtended.cwd(), suffixes=suffixes)
-    elif path_obj.is_dir():
-        from machineconfig.scripts.python.helpers_fire.helpers4 import search_for_files_of_interest
-        print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
-        files = search_for_files_of_interest(path_obj)
-        print(f"🔍 Got #{len(files)} results.")
-        choice_file = choose_from_options(multi=False, options=files, fzf=True, msg="Choose one option")
-        choice_file = PathExtended(choice_file)
-    else:
-        choice_file = path_obj
-
-
-    repo_root = get_repo_root(Path(choice_file))
-    print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
-    ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
-    if ipy_profile is None:
-        ipy_profile = "default"
-
-    if args.marimo:
-        tmp_dir = PathExtended.tmp().joinpath(f"tmp_scripts/marimo/{choice_file.stem}_{randstr()}")
-        tmp_dir.mkdir(parents=True, exist_ok=True)
-        script = f"""
-cd {tmp_dir}
-uv run --python 3.14 --with marimo marimo convert {choice_file} -o marimo_nb.py
-uv run --project {repo_root} --with marimo marimo edit --host 0.0.0.0 marimo_nb.py
-"""
-        from machineconfig.utils.code import exit_then_run_shell_script
-        print(f"🚀 Launching Marimo notebook for `{choice_file}`...")
-        exit_then_run_shell_script(script)
-        return
-
-    # =========================  preparing kwargs_dict
-    if choice_file.suffix == ".py":
-        kwargs_dict = extract_kwargs(args)  # This now returns empty dict, but kept for compatibility
-        ve_root = args.ve or ve_root_from_file
-        if ve_root is None:
-            raise ValueError(f"Could not determine virtual environment for file {choice_file}. Please ensure it is within a recognized project structure or specify the `--ve` option.")
-        activate_ve_line = get_ve_activate_line(ve_root=ve_root)
-    else:
-        activate_ve_line = ""
-        kwargs_dict = {}
-
-
-    # =========================  choosing function to run
-    choice_function: Optional[str] = None  # Initialize to avoid unbound variable
-    if args.choose_function:
-        from machineconfig.scripts.python.helpers_fire_command.fire_jobs_route_helper import choose_function_or_lines
-        choice_function, choice_file, kwargs_dict = choose_function_or_lines(choice_file, kwargs_dict)
-    else:
-        choice_function = args.function
-
-    if choice_file.suffix == ".py":
-        from machineconfig.scripts.python.helpers_fire_command.fire_jobs_route_helper import get_command_streamlit
-        if args.streamlit:  exe = get_command_streamlit(choice_file, args.environment, repo_root)
-        elif args.interactive is False: exe = "python"
-        elif args.jupyter: exe = "jupyter-lab"
-        else: exe = f"ipython -i --no-banner --profile {ipy_profile} "
-    elif choice_file.suffix == ".ps1" or choice_file.suffix == ".sh": exe = "."
-    elif choice_file.suffix == "": exe = ""
-    else: raise NotImplementedError(f"File type {choice_file.suffix} not supported, in the sense that I don't know how to fire it.")
-
-    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.
-        assert choice_file.suffix == ".py", f"File must be a python file to be imported as a module. Got {choice_file}"
-        from machineconfig.scripts.python.helpers_fire.helpers4 import get_import_module_code
-        import_line = get_import_module_code(str(choice_file))
-        if repo_root is not None:
-            repo_root_add = f"""sys.path.append(r'{repo_root}')"""
-        else:
-            repo_root_add = ""
-        txt: str = f"""
-try:
-    {import_line}
-except (ImportError, ModuleNotFoundError) as ex:
-    print(fr"❌ Failed to import `{choice_file}` as a module: {{ex}} ")
-    print(fr"⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
-    import sys
-    sys.path.append(r'{PathExtended(choice_file).parent}')
-    {repo_root_add}
-    from {PathExtended(choice_file).stem} import *
-    print(fr"✅ Successfully imported `{choice_file}`")
-"""
-        if choice_function is not None:
-            txt = (
-                txt
-                + f"""
-res = {choice_function}({("**" + str(kwargs_dict)) if kwargs_dict else ""})
-"""
-            )
-
-        txt = (
-            f"""
-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 = PathExtended.tmp().joinpath(f"tmp_scripts/python/{PathExtended(choice_file).parent.name}_{PathExtended(choice_file).stem}_{randstr()}.py")
-        choice_file.parent.mkdir(parents=True, exist_ok=True)
-        choice_file.write_text(txt, encoding="utf-8")
-
-    # =========================  determining basic command structure: putting together exe & choice_file & choice_function & pdb
-    if args.debug:
-        if platform.system() == "Windows":
-            command = f"{exe} -m ipdb {choice_file} "  # pudb is not available on windows machines, use poor man's debugger instead.
-        elif platform.system() in ["Linux", "Darwin"]:
-            command = f"{exe} -m pudb {choice_file} "  # TODO: functions not supported yet in debug mode.
-        else:
-            raise NotImplementedError(f"Platform {platform.system()} not supported.")
-    elif args.module:
-        # both selected function and kwargs are mentioned in the made up script, therefore no need for fire module.
-        command = f"{exe} {choice_file} "
-    elif choice_function is not None and choice_file.suffix == ".py":
-        command = f"{exe} -m fire {choice_file} {choice_function} {fire_args}"
-    elif args.streamlit:
-        # for .streamlit config to work, it needs to be in the current directory.
-        if args.holdDirectory:
-            command = f"{exe} {choice_file}"
-        else:
-            command = f"cd {choice_file.parent}\n{exe} {choice_file.name}\ncd {PathExtended.cwd()}"
-
-    elif args.cmd:
-        command = rf""" cd /d {choice_file.parent} & {exe} {choice_file.name} """
-    else:
-        if choice_file.suffix == "": command = f"{exe} {choice_file} {fire_args}"
-        else: command = f"{exe} {choice_file} "
-
-    if not args.cmd: command = f"{activate_ve_line}\n{command}"
-    else:
-        new_line = "\n"
-        command = rf"""start cmd -Argument "/k {activate_ve_line.replace(".ps1", ".bat").replace(". ", "")} & {command.replace(new_line, " & ")} " """  # this works from powershell
-    if args.submit_to_cloud:
-        command = f"""
-{activate_ve_line}
-python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
-        if choice_function is not None:
-            command += f"--function {choice_function} "
-
-    if args.optimized:
-        command = command.replace("python ", "python -OO ")
-    from rich.panel import Panel
-    from rich.console import Console
-    from rich.syntax import Syntax
-    console = Console()
-    if args.zellij_tab is not None:
-        comman_path__ = PathExtended.tmpfile(suffix=".sh")
-        comman_path__.parent.mkdir(parents=True, exist_ok=True)
-        comman_path__.write_text(command, encoding="utf-8")
-        console.print(Panel(Syntax(command, lexer="shell"), title=f"🔥 fire command @ {comman_path__}: "), style="bold red")
-        import subprocess
-        existing_tab_names = subprocess.run(["zellij", "action", "query-tab-names"], capture_output=True, text=True, check=True).stdout.splitlines()
-        if args.zellij_tab in existing_tab_names:
-            print(f"⚠️ Tab name `{args.zellij_tab}` already exists. Please choose a different name.")
-            args.zellij_tab += f"_{randstr(3)}"
-        from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
-        command = run_command_in_zellij_tab(command=str(comman_path__), tab_name=args.zellij_tab, cwd=None)
-    if args.watch:
-        command = "watchexec --restart --exts py,sh,ps1 " + command
-    if args.git_pull:
-        command = f"\ngit -C {choice_file.parent} pull\n" + command
-    if args.PathExport:
-        if platform.system() in ["Linux", "Darwin"]:
-            export_line = f"""export PYTHONPATH="{repo_root}""" + """:${PYTHONPATH}" """
-        elif platform.system() == "Windows":
-            export_line = f"""$env:PYTHONPATH="{repo_root}""" + """:$env:PYTHONPATH" """
-        else:
-            raise NotImplementedError(f"Platform {platform.system()} not supported.")
-        command = export_line + "\n" + command
-    if args.loop:
-        if platform.system() in ["Linux", "Darwin"]:
-            command = command + "\nsleep 0.5"
-        elif platform.system() == "Windows":
-            command = "$ErrorActionPreference = 'SilentlyContinue';\n" + command + "\nStart-Sleep -Seconds 0.5"
-        else:
-            raise NotImplementedError(f"Platform {platform.system()} not supported.")
-    import os
-    op_program_path = os.environ.get("OP_PROGRAM_PATH", None)
-    if op_program_path is not None:
-        op_program_path = PathExtended(op_program_path)
-        op_program_path.parent.mkdir(parents=True, exist_ok=True)
-        op_program_path.write_text(command, encoding="utf-8")
-    else:
-        from machineconfig.utils.code import run_shell_script
-        run_shell_script(command)
-
-
 def fire(
     ctx: typer.Context,
     path: Annotated[str, typer.Argument(help="Path to the Python file to run")] = ".",
@@ -228,23 +17,22 @@ def fire(
     jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="Open in a jupyter notebook")] = False,
     marimo: Annotated[bool, typer.Option("--marimo", "-M", help="Open in a marimo notebook")] = False,
     module: Annotated[bool, typer.Option("--module", "-m", help="Launch the main file")] = False,
+    script: Annotated[bool, typer.Option("--script", "-s", help="Launch as a script without fire")] = False,
     optimized: Annotated[bool, typer.Option("--optimized", "-O", help="Run the optimized version of the function")] = False,
     zellij_tab: Annotated[Optional[str], typer.Option("--zellij-tab", "-z", help="Open in a new zellij tab")] = None,
-    
     submit_to_cloud: Annotated[bool, typer.Option("--submit-to-cloud", "-C", help="Submit to cloud compute")] = False,
     remote: Annotated[bool, typer.Option("--remote", "-r", help="Launch on a remote machine")] = False,
-
     streamlit: Annotated[bool, typer.Option("--streamlit", "-S", help="Run as streamlit app")] = False,
     environment: Annotated[str, typer.Option("--environment", "-E", help="Choose ip, localhost, hostname or arbitrary url")] = "",
     holdDirectory: Annotated[bool, typer.Option("--holdDirectory", "-D", help="Hold current directory and avoid cd'ing to the script directory")] = False,
     PathExport: Annotated[bool, typer.Option("--PathExport", "-P", help="Augment the PYTHONPATH with repo root")] = False,
-
     git_pull: Annotated[bool, typer.Option("--git-pull", "-g", help="Start by pulling the git repo")] = False,
     watch: Annotated[bool, typer.Option("--watch", "-w", help="Watch the file for changes")] = False,
 ) -> None:
     """Main function to process fire jobs arguments."""
+    from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_args_helper import FireJobArgs, parse_fire_args_from_context
+    from machineconfig.scripts.python.helpers.helpers_fire_command.fire_jobs_impl import route
 
-    # Get Fire arguments from context
     fire_args = parse_fire_args_from_context(ctx)
 
     args = FireJobArgs(
@@ -261,6 +49,7 @@ def fire(
         submit_to_cloud=submit_to_cloud,
         remote=remote,
         module=module,
+        script=script,
         streamlit=streamlit,
         environment=environment,
         holdDirectory=holdDirectory,
@@ -273,23 +62,20 @@ def fire(
     try:
         route(args, fire_args)
     except SystemExit:
-        # Re-raise SystemExit to preserve exit codes and allow clean exits
         raise
     except Exception as e:
-        # For other exceptions, print clean error message and exit
         import sys
         print(f"❌ Error: {e}", file=sys.stderr)
         sys.exit(1)
 
 
-def get_app():
-    from typer import Typer
-    app = Typer(add_completion=False)
+def get_app() -> typer.Typer:
+    app = typer.Typer(add_completion=False)
     app.command(context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(fire)
     return app
 
 
-def main():
+def main() -> None:
     app = get_app()
     app()
 

machineconfig/scripts/python/ftpx.py

@@ -1,22 +1,7 @@
-"""Sx & Rx
-
-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.
-
-"""
+"""ftpx - File transfer utility through SSH."""
 
 import typer
-from typing_extensions import Annotated
-from rich.console import Console
-from rich.panel import Panel
-
-from machineconfig.utils.ssh import SSH
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.scripts.python.helpers_cloud.helpers2 import ES
-from machineconfig.utils.accessories import pprint
-
-
-console = Console()
+from typing import Annotated
 
 
 def ftpx(
@@ -25,195 +10,17 @@ def ftpx(
     recursive: Annotated[bool, typer.Option("--recursive", "-r", help="Send recursively.")] = False,
     zipFirst: Annotated[bool, typer.Option("--zipFirst", "-z", help="Zip before sending.")] = False,
     cloud: Annotated[bool, typer.Option("--cloud", "-c", help="Transfer through the cloud.")] = False,
+    overwrite_existing: Annotated[bool, typer.Option("--overwrite-existing", "-o", help="Overwrite existing files on remote when sending from local to remote.")] = False,
 ) -> None:
-    console.print(
-        Panel(
-            "\n".join(
-                [
-                    "🚀 FTP File Transfer",
-                    "📋 Starting transfer process...",
-                ]
-            ),
-            title="Transfer Initialisation",
-            border_style="blue",
-            padding=(1, 2),
-        )
-    )
-    
-    # Initialize variables
-    resolved_source: str | None = None
-    resolved_target: str | None = None
-    machine: str = ""
-    
-    if ":" in source and (source[1] != ":" if len(source) > 1 else True):  # avoid the case of "C:/":
-        source_is_remote = True
-
-        # calculating source:
-        source_parts = source.split(":")
-        machine = source_parts[0]
-        if len(source_parts) > 1 and source_parts[1] == ES:  # the source path is to be inferred from target.
-            if target == ES:
-                raise ValueError(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ ❌ Configuration Error
-┃    Cannot use expand symbol `{ES}` in both source and target
-┃    This creates a cyclical inference dependency
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-            else:
-                target_path_obj = PathExtended(target).expanduser().absolute()
-            resolved_source = target_path_obj.collapseuser().as_posix()
-            resolved_target = target
-        else:
-            resolved_source = ":".join(source.split(":")[1:])
-            if target == ES:
-                resolved_target = None
-            else:
-                resolved_target = PathExtended(target).expanduser().absolute().as_posix()
-
-    elif ":" in target and (target[1] != ":" if len(target) > 1 else True):  # avoid the case of "C:/":
-        source_is_remote = False
-        target_parts = target.split(":")
-        machine = target_parts[0]
-        if len(target_parts) > 1 and target_parts[1] == ES:
-            if source == ES:
-                raise ValueError(f"""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ ❌ Configuration Error
-┃    Cannot use expand symbol `{ES}` in both source and target
-┃    This creates a cyclical inference dependency
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-            else:
-                resolved_source = source
-            resolved_target = None
-        else:
-            resolved_target = ":".join(target.split(":")[1:])
-            if source == ES:
-                resolved_source = None
-            else:
-                resolved_source = PathExtended(source).expanduser().absolute().as_posix()
-
-    else:
-        raise ValueError("""
-┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-┃ ❌ Path Error
-┃    Either source or target must be a remote path
-┃    Format should be: machine:path
-┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
-
-    pprint({"source": str(resolved_source), "target": str(resolved_target), "machine": machine}, "CLI Resolution")
-
-    from paramiko.ssh_exception import AuthenticationException  # type: ignore
-
-    try:
-        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=True)
-    except AuthenticationException:
-        console.print(
-            Panel(
-                "\n".join(
-                    [
-                        "🔑 Authentication failed. Trying manual authentication...",
-                        "⚠️  Ensure that the username is provided correctly; only password prompts are handled here.",
-                    ]
-                ),
-                title="Authentication Required",
-                border_style="yellow",
-                padding=(1, 2),
-            )
-        )
-        import getpass
-
-        pwd = getpass.getpass()
-        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=pwd, port=22, enable_compression=True)
-
-    if cloud:
-        console.print(
-            Panel.fit(
-                "☁️  Cloud transfer mode — uploading from remote to cloud...",
-                title="Cloud Upload",
-                border_style="cyan",
-            )
-        )
-        ssh.run_shell(command=f"cloud_copy {resolved_source} :^", verbose_output=True, description="Uploading from remote to the cloud.", strict_stderr=False, strict_return_code=False)
-        console.print(
-            Panel.fit(
-                "⬇️  Cloud transfer mode — downloading from cloud to local...",
-                title="Cloud Download",
-                border_style="cyan",
-            )
-        )
-        ssh.run_locally(command=f"cloud_copy :^ {resolved_target}")
-        received_file = PathExtended(resolved_target)  # type: ignore
-    else:
-        if source_is_remote:
-            assert resolved_source is not None, """
-❌ Path Error: Source must be a remote path (machine:path)"""
-            target_display = resolved_target or "<auto>"
-            console.print(
-                Panel(
-                    "\n".join(
-                        [
-                            "📥 Transfer Mode: Remote → Local",
-                            f"Source: [cyan]{resolved_source}[/cyan]",
-                            f"Target: [cyan]{target_display}[/cyan]",
-                            f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
-                        ]
-                    ),
-                    title="Transfer Details",
-                    border_style="cyan",
-                    padding=(1, 2),
-                )
-            )
-            received_file = ssh.copy_to_here(source=resolved_source, target=resolved_target, compress_with_zip=zipFirst, recursive=recursive)
-        else:
-            assert resolved_source is not None, """
-❌ Path Error: Target must be a remote path (machine:path)"""
-            target_display = resolved_target or "<auto>"
-            console.print(
-                Panel(
-                    "\n".join(
-                        [
-                            "📤 Transfer Mode: Local → Remote",
-                            f"Source: [cyan]{resolved_source}[/cyan]",
-                            f"Target: [cyan]{target_display}[/cyan]",
-                            f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
-                        ]
-                    ),
-                    title="Transfer Details",
-                    border_style="cyan",
-                    padding=(1, 2),
-                )
-            )
-            received_file = ssh.copy_from_here(source_path=resolved_source, target_rel2home=resolved_target, compress_with_zip=zipFirst, recursive=recursive, overwrite_existing=False)
-
-    if source_is_remote and isinstance(received_file, PathExtended):
-        console.print(
-            Panel(
-                "\n".join(
-                    [
-                        "📁 File Received",
-                        f"Parent: [cyan]{repr(received_file.parent)}[/cyan]",
-                        f"File: [cyan]{repr(received_file)}[/cyan]",
-                    ]
-                ),
-                title="Transfer Result",
-                border_style="green",
-                padding=(1, 2),
-            )
-        )
-    console.print(
-        Panel(
-            "File transfer process finished successfully",
-            title="✅ Transfer Complete",
-            border_style="green",
-            padding=(1, 2),
-        )
-    )
+    """File transfer utility through SSH."""
+    from machineconfig.scripts.python.helpers.helpers_network.ftpx_impl import ftpx as impl
+    impl(source=source, target=target, recursive=recursive, zipFirst=zipFirst, cloud=cloud, overwrite_existing=overwrite_existing)
 
 
 def main() -> None:
     """Entry point function that uses typer to parse arguments and call main."""
     app = typer.Typer()
-    app.command(no_args_is_help=True, help="File transfer utility though SSH.")(ftpx)
+    app.command(no_args_is_help=True, help=ftpx.__doc__, short_help="File transfer utility through SSH.")(ftpx)
     app()