machineconfig 3.83__py3-none-any.whl → 3.86__py3-none-any.whl

machineconfig/scripts/python/fire_jobs.py

@@ -8,7 +8,6 @@ fire
 """
 
 from machineconfig.scripts.python.helpers.helpers4 import search_for_files_of_interest
-from machineconfig.scripts.python.helpers.helpers4 import convert_kwargs_to_fire_kwargs_str
 from machineconfig.scripts.python.helpers.helpers4 import parse_pyfile
 from machineconfig.scripts.python.helpers.helpers4 import get_import_module_code
 from machineconfig.utils.ve import get_ve_activate_line, get_ve_path_and_ipython_profile
@@ -17,7 +16,7 @@ from machineconfig.utils.path_helper import match_file_name, sanitize_path
 
 from machineconfig.utils.path_extended import PathExtended as PathExtended
 from machineconfig.utils.accessories import get_repo_root, randstr
-from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs, extract_kwargs
+from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs, extract_kwargs, parse_fire_args_from_context
 import platform
 from typing import Optional, Annotated
 from pathlib import Path
@@ -26,7 +25,7 @@ import typer
 # import os
 
 
-def route(args: FireJobArgs) -> None:
+def route(args: FireJobArgs, fire_args: str = "") -> None:
     if args.layout:
         from machineconfig.scripts.python.fire_jobs_layout_helper import handle_layout_args
 
@@ -51,7 +50,7 @@ def route(args: FireJobArgs) -> None:
         ipy_profile = "default"
 
     if choice_file.suffix == ".py":
-        kwargs = extract_kwargs(args)
+        kwargs = extract_kwargs(args)  # This now returns empty dict, but kept for compatibility
         activate_ve_line = get_ve_activate_line(ve_root=args.ve or ve_root_from_file or "$HOME/code/machineconfig/.venv")
     else:
         activate_ve_line = ""
@@ -217,8 +216,7 @@ except ImportError as _ex:
         # 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:
-        kwargs_str = convert_kwargs_to_fire_kwargs_str(kwargs)
-        command = f"{exe} -m fire {choice_file} {choice_function} {kwargs_str}"
+        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:
@@ -230,8 +228,7 @@ except ImportError as _ex:
         command = rf""" cd /d {choice_file.parent} & {exe} {choice_file.name} """
     else:
         if choice_file.suffix == "":
-            kwargs_raw = " ".join(args.kw) if args.kw is not None else ""
-            command = f"{exe} {choice_file} {kwargs_raw}"
+            command = f"{exe} {choice_file} {fire_args}"
         else:
             # command = f"cd {choice_file.parent}\n{exe} {choice_file.name}\ncd {PathExtended.cwd()}"
             command = f"{exe} {choice_file} "
@@ -330,7 +327,8 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
 
 
 def main(
-    path: Annotated[str, typer.Argument(help="The directory containing the jobs")] = ".",
+    ctx: typer.Context,
+    path: Annotated[str, typer.Argument(help="Path to the Python file to run")] = ".",
     function: Annotated[Optional[str], typer.Argument(help="Function to run")] = None,
     ve: Annotated[str, typer.Option("--ve", "-v", help="Virtual environment name")] = "",
     cmd: Annotated[bool, typer.Option("--cmd", "-B", help="Create a cmd fire command to launch the job asynchronously")] = False,
@@ -351,10 +349,13 @@ def main(
     Nprocess: Annotated[int, typer.Option("--Nprocess", "-p", help="Number of processes to use")] = 1,
     zellij_tab: Annotated[Optional[str], typer.Option("--zellij_tab", "-z", help="Open in a new zellij tab")] = None,
     watch: Annotated[bool, typer.Option("--watch", "-w", help="Watch the file for changes")] = False,
-    kw: Annotated[Optional[list[str]], typer.Option("--kw", help="Keyword arguments to pass to the function in the form of k1 v1 k2 v2 ... (meaning k1=v1, k2=v2, etc)")] = None,
     layout: Annotated[bool, typer.Option("--layout", "-L", help="Use layout configuration (Zellij Or WindowsTerminal)")] = False,
 ) -> None:
     """Main function to process fire jobs arguments."""
+    
+    # Get Fire arguments from context
+    fire_args = parse_fire_args_from_context(ctx)
+    
     args = FireJobArgs(
         path=path,
         function=function,
@@ -377,16 +378,31 @@ def main(
         Nprocess=Nprocess,
         zellij_tab=zellij_tab,
         watch=watch,
-        kw=kw,
         layout=layout,
     )
-    route(args)
+    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 main_from_parser():
-    typer.run(main)
+    # from trogon.typer import init_tui
+    # from trogon.typer import init_tui
+    from typer import Typer
+    app = Typer(add_completion=False)
+    app.command(context_settings={"allow_extra_args": True, "allow_interspersed_args": False})(main)
+    # typer.run(main)
+    # init_tui(app)
+    app()
 
 
 if __name__ == "__main__":
     # options, func_args = parse_pyfile(file_path="C:/Users/aalsaf01/code/machineconfig/myresources/crocodile/core.py")
-    pass
+    main_from_parser()

machineconfig/scripts/python/fire_jobs_args_helper.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, Any
 
 
 @dataclass
@@ -27,21 +27,49 @@ class FireJobArgs:
     Nprocess: int = 1
     zellij_tab: Optional[str] = None
     watch: bool = False
-    kw: Optional[list[str]] = None
     layout: bool = False
 
 
 def extract_kwargs(args: FireJobArgs) -> dict[str, object]:
-    str2obj = {"True": True, "False": False, "None": None}
-    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]))
-        kwargs: dict[str, object]
-        for key, value in kwargs.items():
-            if value in str2obj:
-                kwargs[key] = str2obj[str(value)]
-        if args.function is None:  # if user passed arguments and forgot to pass function, then assume they want to run the main function.
-            args.choose_function = True
-    else:
-        kwargs = {}
-    return kwargs
+    """Extract kwargs from command line using -- separator.
+    
+    Returns empty dict since kwargs are now parsed directly from sys.argv
+    using the -- separator pattern in the main function.
+    """
+    return {}
+
+
+def parse_fire_args_from_argv() -> str:
+    """Parse arguments after -- separator for Fire compatibility.
+    
+    Returns:
+        String of Fire-compatible arguments to append to command
+    """
+    import sys
+    
+    if '--' in sys.argv:
+        separator_index = sys.argv.index('--')
+        fire_args = sys.argv[separator_index + 1:]
+        # Join all Fire arguments - they should already be in Fire format
+        return ' '.join(fire_args) if fire_args else ''
+    
+    return ''
+
+
+def parse_fire_args_from_context(ctx: Any) -> str:
+    """Parse Fire arguments from typer context.
+    
+    Args:
+        ctx: Typer context containing raw arguments
+        
+    Returns:
+        String of Fire-compatible arguments to append to command
+    """
+    # Get remaining args that weren't consumed by typer
+    if hasattr(ctx, 'args') and ctx.args:
+        args = ctx.args
+        # Filter out the -- separator if present
+        if args and args[0] == '--':
+            args = args[1:]
+        return ' '.join(args)
+    return ''

machineconfig/scripts/python/fire_jobs_layout_helper.py

@@ -10,34 +10,39 @@ if TYPE_CHECKING:
     from machineconfig.scripts.python.fire_jobs_args_helper import FireJobArgs
 
 
-def select_layout(layouts_json_file: Path, layout_name: Optional[str]):
+def select_layout(layouts_json_file: Path, layouts_name: Optional[list[str]]) -> list[LayoutConfig]:
     import json
-
     layout_file: LayoutsFile = json.loads(layouts_json_file.read_text(encoding="utf-8"))
     if len(layout_file["layouts"]) == 0:
         raise ValueError(f"No layouts found in {layouts_json_file}")
-    if layout_name is None:
+    if layouts_name is None:
         options = [layout["layoutName"] for layout in layout_file["layouts"]]
         from machineconfig.utils.options import choose_from_options
-
-        layout_name = choose_from_options(multi=False, options=options, prompt="Choose a layout configuration:", fzf=True, msg="Choose one option")
-    print(f"Selected layout: {layout_name}")
-    layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == layout_name), None)
-    if layout_chosen is None:
-        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == layout_name.lower()), None)
-    if layout_chosen is None:
-        available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
-        raise ValueError(f"Layout '{layout_name}' not found. Available layouts: {available_layouts}")
-    return layout_chosen
+        layouts_name = choose_from_options(multi=True, options=options, prompt="Choose a layout configuration:", fzf=True, msg="Choose one option")
+    print(f"Selected layout(s): {layouts_name}")
+    # layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == layouts_name), None)
+    # if layout_chosen is None:
+        # layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == layouts_name.lower()), None)
+    # if layout_chosen is None:
+        # available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+        # raise ValueError(f"Layout '{layouts_name}' not found. Available layouts: {available_layouts}")
+    layouts_chosen: list[LayoutConfig] = []
+    for name in layouts_name:
+        layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"] == name), None)
+        if layout_chosen is None:
+            layout_chosen = next((layout for layout in layout_file["layouts"] if layout["layoutName"].lower() == name.lower()), None)
+        if layout_chosen is None:
+            available_layouts = [layout["layoutName"] for layout in layout_file["layouts"]]
+            raise ValueError(f"Layout '{name}' not found. Available layouts: {available_layouts}")
+        layouts_chosen.append(layout_chosen)
+    return layouts_chosen
 
 
 def launch_layout(layout_config: LayoutConfig) -> Optional[Exception]:
     import platform
-
     if platform.system() == "Linux" or platform.system() == "Darwin":
         print("🧑‍💻 Launching layout using Zellij terminal multiplexer...")
         from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
-
         run_zellij_layout(layout_config=layout_config)
     elif platform.system() == "Windows":
         print("🧑‍💻 Launching layout using Windows Terminal...")
@@ -63,4 +68,7 @@ def handle_layout_args(args: "FireJobArgs") -> None:
         choice_file = PathExtended(choice_file)
     else:
         choice_file = path_obj
-    launch_layout(layout_config=select_layout(layouts_json_file=choice_file, layout_name=args.function))
+    if args.function is None: layouts_name = None
+    else: layouts_name = args.function.split(",")
+    for a_layout_config in select_layout(layouts_json_file=choice_file, layouts_name=layouts_name):
+        launch_layout(layout_config=a_layout_config)

machineconfig/scripts/python/helpers/helpers4.py

@@ -2,9 +2,7 @@ from typing import Any, Callable, Optional
 import inspect
 import os
 
-# import argparse
 from machineconfig.utils.path_extended import PathExtended as PathExtended
-# from machineconfig.utils.utils import choose_ssh_host
 
 
 def search_for_files_of_interest(path_obj: PathExtended):

machineconfig/scripts/python/repos.py

@@ -8,80 +8,13 @@ in the event that username@github.com is not mentioned in the remote url.
 from machineconfig.utils.io import read_ini
 from machineconfig.utils.source_of_truth import CONFIG_PATH, DEFAULTS_PATH
 from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.accessories import randstr
-from machineconfig.scripts.python.repos_helper_update import update_repository
 from machineconfig.scripts.python.repos_helper_record import main as record_repos
 from machineconfig.scripts.python.repos_helper_clone import clone_repos
+from machineconfig.scripts.python.repos_helper_action import perform_git_operations
 
 import typer
-from enum import Enum
 from typing import Annotated, Optional
 
-from rich import print as pprint
-
-
-class GitAction(Enum):
-    commit = "commit"
-    push = "push"
-    pull = "pull"
-
-
-def git_action(path: PathExtended, action: GitAction, mess: Optional[str] = None, r: bool = False, auto_sync: bool = True) -> bool:
-    """Perform git actions using Python instead of shell scripts. Returns True if successful."""
-    from git.exc import InvalidGitRepositoryError
-    from git.repo import Repo
-
-    try:
-        repo = Repo(str(path), search_parent_directories=False)
-    except InvalidGitRepositoryError:
-        pprint(f"⚠️ Skipping {path} because it is not a git repository.")
-        if r:
-            results = [git_action(path=sub_path, action=action, mess=mess, r=r, auto_sync=auto_sync) for sub_path in path.search()]
-            return all(results)  # Return True only if all recursive operations succeeded
-        else:
-            return False
-
-    print(f">>>>>>>>> 🔧{action} - {path}")
-
-    try:
-        if action == GitAction.commit:
-            if mess is None:
-                mess = "auto_commit_" + randstr()
-
-            # Check if there are changes to commit
-            if repo.is_dirty() or repo.untracked_files:
-                repo.git.add(A=True)  # Stage all changes
-                repo.index.commit(mess)
-                print(f"✅ Committed changes with message: {mess}")
-                return True
-            else:
-                print("ℹ️  No changes to commit")
-                return True
-
-        elif action == GitAction.push:
-            success = True
-            for remote in repo.remotes:
-                try:
-                    print(f"🚀 Pushing to {remote.url}")
-                    remote.push(repo.active_branch.name)
-                    print(f"✅ Pushed to {remote.name}")
-                except Exception as e:
-                    print(f"❌ Failed to push to {remote.name}: {e}")
-                    success = False
-            return success
-
-        elif action == GitAction.pull:
-            # Use the enhanced update function with uv sync support
-            update_repository(repo, auto_sync=auto_sync, allow_password_prompt=False)
-            print("✅ Pull completed")
-            return True
-
-    except Exception as e:
-        print(f"❌ Error performing {action} on {path}: {e}")
-        return False
-
-    return True
-
 
 def main(
     directory: Annotated[str, typer.Argument(help="📁 Folder containing repos to record or a specs JSON file to follow.")] = "",
@@ -105,9 +38,7 @@ def main(
         repos_root = PathExtended.home().joinpath("code")  # it is a positional argument, can never be empty.
     else:
         repos_root = PathExtended(directory).expanduser().absolute()
-
     auto_sync = not no_sync  # Enable auto sync by default, disable with --no-sync
-
     if record:
         save_path = record_repos(repos_root=repos_root)
         if cloud is not None:
@@ -115,7 +46,6 @@ def main(
 
     elif clone or checkout or checkout_to_branch:
         print("\n📥 Cloning or checking out repositories...")
-        print(">>>>>>>>> Cloning Repos")
         if not repos_root.exists() or repos_root.name != "repos.json":
             repos_root = PathExtended(CONFIG_PATH).joinpath("repos").joinpath(repos_root.rel2home()).joinpath("repos.json")
             if not repos_root.exists():
@@ -130,23 +60,15 @@ def main(
         clone_repos(spec_path=repos_root, preferred_remote=None, checkout_branch_flag=checkout_to_branch, checkout_commit_flag=checkout)
 
     elif all or commit or pull or push:
-        print(f"\n🔄 Performing Git actions on repositories @ `{repos_root}`...")
-        overall_success = True
-        for a_path in repos_root.search("*"):
-            print(f"{('Handling ' + str(a_path)).center(80, '-')}")
-            path_success = True
-            if pull or all:
-                path_success = git_action(path=a_path, action=GitAction.pull, r=recursive, auto_sync=auto_sync) and path_success
-            if commit or all:
-                path_success = git_action(a_path, action=GitAction.commit, r=recursive, auto_sync=auto_sync) and path_success
-            if push or all:
-                path_success = git_action(a_path, action=GitAction.push, r=recursive, auto_sync=auto_sync) and path_success
-            overall_success = overall_success and path_success
-
-        if overall_success:
-            print("✅ All git operations completed successfully")
-        else:
-            print("⚠️ Some git operations encountered issues")
+        # Use the new helper function for git operations
+        perform_git_operations(
+            repos_root=repos_root,
+            pull=pull or all,
+            commit=commit or all,
+            push=push or all,
+            recursive=recursive,
+            auto_sync=auto_sync
+        )
     else:
         print("❌ No action specified. Try passing --push, --pull, --commit, or --all.")