machineconfig 3.85__py3-none-any.whl → 3.88__py3-none-any.whl

machineconfig/scripts/python/fire_agents.py

@@ -151,10 +151,10 @@ manager.run_monitoring_routine()
 
 
 def split_too_many_tabs_to_run_in_sequential_sessions(layout_tabs: list[TabConfig], every: int):
-    from machineconfig.utils.accessories import split
+    from machineconfig.utils.accessories import split_list
     from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
 
-    for idx, layout_tabs_chunk in enumerate(split(layout_tabs, every=every)):
+    for idx, layout_tabs_chunk in enumerate(split_list(layout_tabs, every=every, to=None)):
         a_layout_file: LayoutConfig = {"layoutName": f"split_{idx}", "layoutTabs": layout_tabs_chunk}
         manager = ZellijLocalManager(session_layouts=[a_layout_file])
         manager.start_all_sessions(poll_interval=2, poll_seconds=2)
@@ -163,10 +163,9 @@ def split_too_many_tabs_to_run_in_sequential_sessions(layout_tabs: list[TabConfi
 
 
 def split_too_many_layouts_to_run_in_sequential_sessions(layouts: list[LayoutConfig], every: int):
-    from machineconfig.utils.accessories import split
+    from machineconfig.utils.accessories import split_list
     from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
-
-    for _idx, layout_chunk in enumerate(split(layouts, every=every)):
+    for _idx, layout_chunk in enumerate(split_list(layouts, every=every)):
         manager = ZellijLocalManager(session_layouts=layout_chunk)
         manager.start_all_sessions(poll_interval=2, poll_seconds=2)
         manager.run_monitoring_routine(wait_ms=2000)

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/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.")
 

machineconfig/scripts/python/repos_helper_action.py

@@ -0,0 +1,335 @@
+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 typing import Optional
+from dataclasses import dataclass
+from enum import Enum
+
+from rich import print as pprint
+
+
+class GitAction(Enum):
+    commit = "commit"
+    push = "push"
+    pull = "pull"
+
+
+@dataclass
+class GitOperationResult:
+    """Result of a git operation on a single repository."""
+    repo_path: PathExtended
+    action: str
+    success: bool
+    message: str
+    is_git_repo: bool = True
+    had_changes: bool = False
+    remote_count: int = 0
+
+
+@dataclass  
+class GitOperationSummary:
+    """Summary of all git operations performed."""
+    # Basic statistics
+    total_paths_processed: int = 0
+    git_repos_found: int = 0
+    non_git_paths: int = 0
+    
+    # Per-operation statistics
+    commits_attempted: int = 0
+    commits_successful: int = 0
+    commits_no_changes: int = 0
+    commits_failed: int = 0
+    
+    pulls_attempted: int = 0
+    pulls_successful: int = 0
+    pulls_failed: int = 0
+    
+    pushes_attempted: int = 0
+    pushes_successful: int = 0
+    pushes_failed: int = 0
+    
+    def __post_init__(self):
+        self.failed_operations: list[GitOperationResult] = []
+        self.repos_without_remotes: list[PathExtended] = []
+
+
+def git_action(path: PathExtended, action: GitAction, mess: Optional[str] = None, r: bool = False, auto_sync: bool = True) -> GitOperationResult:
+    """Perform git actions using Python instead of shell scripts. Returns detailed operation result."""
+    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()]
+            # For recursive calls, we need to aggregate results somehow
+            # For now, return success if all recursive operations succeeded
+            all_successful = all(result.success for result in results)
+            return GitOperationResult(
+                repo_path=path,
+                action=action.value,
+                success=all_successful,
+                message=f"Recursive operation: {len([r for r in results if r.success])}/{len(results)} succeeded",
+                is_git_repo=False
+            )
+        else:
+            return GitOperationResult(
+                repo_path=path,
+                action=action.value,
+                success=False,
+                message="Not a git repository",
+                is_git_repo=False
+            )
+
+    print(f">>>>>>>>> 🔧{action} - {path}")
+    remote_count = len(repo.remotes)
+
+    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 GitOperationResult(
+                    repo_path=path,
+                    action=action.value,
+                    success=True,
+                    message=f"Committed changes with message: {mess}",
+                    had_changes=True,
+                    remote_count=remote_count
+                )
+            else:
+                print("ℹ️  No changes to commit")
+                return GitOperationResult(
+                    repo_path=path,
+                    action=action.value,
+                    success=True,
+                    message="No changes to commit",
+                    had_changes=False,
+                    remote_count=remote_count
+                )
+
+        elif action == GitAction.push:
+            if not repo.remotes:
+                print("⚠️ No remotes configured for push")
+                return GitOperationResult(
+                    repo_path=path,
+                    action=action.value,
+                    success=False,
+                    message="No remotes configured",
+                    remote_count=0
+                )
+                
+            success = True
+            failed_remotes = []
+            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}")
+                    failed_remotes.append(f"{remote.name}: {str(e)}")
+                    success = False
+                    
+            message = "Push successful" if success else f"Push failed for: {', '.join(failed_remotes)}"
+            return GitOperationResult(
+                repo_path=path,
+                action=action.value,
+                success=success,
+                message=message,
+                remote_count=remote_count
+            )
+
+        elif action == GitAction.pull:
+            # Use the enhanced update function with uv sync support
+            try:
+                update_repository(repo, auto_sync=auto_sync, allow_password_prompt=False)
+                print("✅ Pull completed")
+                return GitOperationResult(
+                    repo_path=path,
+                    action=action.value,
+                    success=True,
+                    message="Pull completed successfully",
+                    remote_count=remote_count
+                )
+            except Exception as e:
+                print(f"❌ Pull failed: {e}")
+                return GitOperationResult(
+                    repo_path=path,
+                    action=action.value,
+                    success=False,
+                    message=f"Pull failed: {str(e)}",
+                    remote_count=remote_count
+                )
+
+    except Exception as e:
+        print(f"❌ Error performing {action} on {path}: {e}")
+        return GitOperationResult(
+            repo_path=path,
+            action=action.value,
+            success=False,
+            message=f"Error: {str(e)}",
+            remote_count=remote_count
+        )
+
+    # This should never be reached, but just in case
+    return GitOperationResult(
+        repo_path=path,
+        action=action.value,
+        success=False,
+        message="Unknown error",
+        remote_count=remote_count
+    )
+
+
+def print_git_operations_summary(summary: GitOperationSummary, operations_performed: list[str]) -> None:
+    """Print a detailed summary of git operations similar to repos_helper_record.py."""
+    print("\n📊 Git Operations Summary:")
+    print(f"   Total paths processed: {summary.total_paths_processed}")
+    print(f"   Git repositories found: {summary.git_repos_found}")
+    print(f"   Non-git paths skipped: {summary.non_git_paths}")
+    
+    # Show per-operation statistics
+    if "commit" in operations_performed:
+        print("\n💾 Commit Operations:")
+        print(f"   Attempted: {summary.commits_attempted}")
+        print(f"   Successful: {summary.commits_successful}")
+        print(f"   No changes: {summary.commits_no_changes}")
+        print(f"   Failed: {summary.commits_failed}")
+        
+    if "pull" in operations_performed:
+        print("\n⬇️ Pull Operations:")
+        print(f"   Attempted: {summary.pulls_attempted}")
+        print(f"   Successful: {summary.pulls_successful}")
+        print(f"   Failed: {summary.pulls_failed}")
+        
+    if "push" in operations_performed:
+        print("\n🚀 Push Operations:")
+        print(f"   Attempted: {summary.pushes_attempted}")
+        print(f"   Successful: {summary.pushes_successful}")
+        print(f"   Failed: {summary.pushes_failed}")
+
+    # Show repositories without remotes (important for push operations)
+    if summary.repos_without_remotes:
+        print(f"\n⚠️  WARNING: {len(summary.repos_without_remotes)} repositories have no remote configurations:")
+        for repo_path in summary.repos_without_remotes:
+            print(f"   • {repo_path.name} ({repo_path})")
+        print("   These repositories cannot be pushed to remote servers.")
+    else:
+        if "push" in operations_performed:
+            print("\n✅ All repositories have remote configurations.")
+
+    # Show failed operations
+    if summary.failed_operations:
+        print(f"\n❌ FAILED OPERATIONS ({len(summary.failed_operations)} total):")
+        
+        # Group failed operations by type
+        failed_by_action = {}
+        for failed_op in summary.failed_operations:
+            if failed_op.action not in failed_by_action:
+                failed_by_action[failed_op.action] = []
+            failed_by_action[failed_op.action].append(failed_op)
+            
+        for action, failures in failed_by_action.items():
+            print(f"\n   {action.upper()} failures ({len(failures)}):")
+            for failure in failures:
+                if not failure.is_git_repo:
+                    print(f"   • {failure.repo_path.name} ({failure.repo_path}) - Not a git repository")
+                else:
+                    print(f"   • {failure.repo_path.name} ({failure.repo_path}) - {failure.message}")
+    else:
+        print("\n✅ All git operations completed successfully!")
+
+    # Overall success assessment
+    total_failed = len(summary.failed_operations)
+    total_operations = (summary.commits_attempted + summary.pulls_attempted + 
+                       summary.pushes_attempted)
+    
+    if total_failed == 0 and total_operations > 0:
+        print(f"\n🎉 SUCCESS: All {total_operations} operations completed successfully!")
+    elif total_operations == 0:
+        print("\n📝 No git operations were performed.")
+    else:
+        success_rate = ((total_operations - total_failed) / total_operations * 100) if total_operations > 0 else 0
+        print(f"\n⚖️  SUMMARY: {total_operations - total_failed}/{total_operations} operations succeeded ({success_rate:.1f}% success rate)")
+        if total_failed > 0:
+            print("   Review the failed operations above for details on what needs attention.")
+
+
+def perform_git_operations(repos_root: PathExtended, pull: bool, commit: bool, push: bool, recursive: bool, auto_sync: bool) -> None:
+    """Perform git operations on all repositories and provide detailed summary."""
+    print(f"\n🔄 Performing Git actions on repositories @ `{repos_root}`...")
+    
+    # Initialize summary tracking
+    summary = GitOperationSummary()
+    operations_performed = []
+    
+    # Determine which operations to perform
+    if pull:
+        operations_performed.append("pull")
+    if commit:
+        operations_performed.append("commit")
+    if push:
+        operations_performed.append("push")
+        
+    for a_path in repos_root.search("*"):
+        print(f"{('Handling ' + str(a_path)).center(80, '-')}")
+        summary.total_paths_processed += 1
+        
+        # Check if this is a git repository first
+        from git.exc import InvalidGitRepositoryError
+        from git.repo import Repo
+        
+        try:
+            repo = Repo(str(a_path), search_parent_directories=False)
+            summary.git_repos_found += 1
+            
+            # Track repos without remotes
+            if len(repo.remotes) == 0:
+                summary.repos_without_remotes.append(a_path)
+                
+            # Now perform the actual operations
+            if pull:
+                result = git_action(path=a_path, action=GitAction.pull, r=recursive, auto_sync=auto_sync)
+                summary.pulls_attempted += 1
+                if result.success:
+                    summary.pulls_successful += 1
+                else:
+                    summary.pulls_failed += 1
+                    summary.failed_operations.append(result)
+                    
+            if commit:
+                result = git_action(a_path, action=GitAction.commit, r=recursive, auto_sync=auto_sync)
+                summary.commits_attempted += 1
+                if result.success:
+                    if result.had_changes:
+                        summary.commits_successful += 1
+                    else:
+                        summary.commits_no_changes += 1
+                else:
+                    summary.commits_failed += 1
+                    summary.failed_operations.append(result)
+                    
+            if push:
+                result = git_action(a_path, action=GitAction.push, r=recursive, auto_sync=auto_sync)
+                summary.pushes_attempted += 1
+                if result.success:
+                    summary.pushes_successful += 1
+                else:
+                    summary.pushes_failed += 1
+                    summary.failed_operations.append(result)
+                    
+        except InvalidGitRepositoryError:
+            summary.non_git_paths += 1
+            pprint(f"⚠️ Skipping {a_path} because it is not a git repository.")
+
+    # Print the detailed summary
+    print_git_operations_summary(summary, operations_performed)

machineconfig/scripts/python/t4.py

@@ -1,11 +1,11 @@
 
 import typer
-
+from typing import Annotated
 
 def func(name: str):
     print(f"Hello, {name}! from func")
 
-def hello(name: str):
+def hello(*, name: Annotated[str, typer.Option(..., help="Name to greet")]):
     print(f"Hello, {name}!")
 
 def main():
@@ -13,4 +13,5 @@ def main():
 
 if __name__ == "__main__":
     # typer.run(hello)
+    main()
     pass

machineconfig/utils/accessories.py

@@ -1,6 +1,8 @@
 from pathlib import Path
 from typing import Optional, Any
 
+from datetime import datetime, timezone, timedelta
+
 
 def randstr(length: int = 10, lower: bool = True, upper: bool = True, digits: bool = True, punctuation: bool = False, safe: bool = False, noun: bool = False) -> str:
     if safe:
@@ -18,16 +20,52 @@ def randstr(length: int = 10, lower: bool = True, upper: bool = True, digits: bo
     return "".join(random.choices(population, k=length))
 
 
-def split[T](iterable: list[T], every: int = 1, to: Optional[int] = None) -> list[list[T]]:
+def split_timeframe(start_dt: str, end_dt: str, resolution_ms: int, to: Optional[int]=None, every_ms: Optional[int]=None) -> list[tuple[datetime, datetime]]:
+    if (to is None) == (every_ms is None):
+        raise ValueError("Exactly one of 'to' or 'every_ms' must be provided, not both or neither")    
+    start_dt_obj = datetime.fromisoformat(start_dt).replace(tzinfo=timezone.utc)
+    end_dt_obj = datetime.fromisoformat(end_dt).replace(tzinfo=timezone.utc)
+    delta = end_dt_obj - start_dt_obj
+    resolution = timedelta(milliseconds=resolution_ms)
+    res: list[tuple[datetime, datetime]] = []    
+    if to is not None:
+        split_size_seconds: float = delta.total_seconds() / to
+        split_size_rounded: float = round(split_size_seconds / 60) * 60
+        split_size = timedelta(seconds=split_size_rounded)
+        
+        for idx in range(to):
+            start = start_dt_obj + split_size * idx
+            assert start < end_dt_obj
+            if idx == to - 1:
+                end = end_dt_obj
+            else:
+                end = start_dt_obj + split_size * (idx + 1) - resolution
+            res.append((start, end))
+    else:
+        if every_ms is None:
+            raise ValueError("every_ms cannot be None when to is None")
+        split_size = timedelta(milliseconds=every_ms)
+        current_start = start_dt_obj
+        while current_start < end_dt_obj:
+            current_end = min(current_start + split_size - resolution, end_dt_obj)
+            res.append((current_start, current_end))
+            current_start += split_size
+    return res
+def split_list[T](sequence: list[T], every: Optional[int]=None, to: Optional[int]=None) -> list[list[T]]:
+    if (every is None) == (to is None):
+        raise ValueError("Exactly one of 'every' or 'to' must be provided, not both or neither")
+    if len(sequence) == 0:
+        return []
     import math
-
-    every = every if to is None else math.ceil(len(iterable) / to)
+    if to is not None:
+        every = math.ceil(len(sequence) / to)
+    assert every is not None
     res: list[list[T]] = []
-    for ix in range(0, len(iterable), every):
-        if ix + every < len(iterable):
-            tmp = iterable[ix : ix + every]
+    for ix in range(0, len(sequence), every):
+        if ix + every < len(sequence):
+            tmp = sequence[ix : ix + every]
         else:
-            tmp = iterable[ix : len(iterable)]
+            tmp = sequence[ix : len(sequence)]
         res.append(list(tmp))
     return list(res)
 

machineconfig/utils/schemas/layouts/layout_types.py

@@ -4,7 +4,7 @@ Type definitions for the standardized layout configuration schema.
 This module defines the data structures that match the layout.json schema.
 """
 
-from typing import TypedDict, List
+from typing import TypedDict, List, Literal
 
 
 class TabConfig(TypedDict):
@@ -27,3 +27,35 @@ class LayoutsFile(TypedDict):
 
     version: str
     layouts: List[LayoutConfig]
+
+
+def serialize_layouts_to_file(layouts: list[LayoutConfig], version: Literal["0.1"], path: str):
+    """Serialize a LayoutConfig to a JSON string."""
+    import json
+    layout_file: LayoutsFile = {
+        "version": version,
+        "layouts": layouts,
+    }
+    # add "$schema" key pointing to https://bit.ly/cfglayout
+    layout_dict = {
+        "$schema": "https://bit.ly/cfglayout",
+        **layout_file
+    }
+    json_string = json.dumps(layout_dict, indent=4)
+    from pathlib import Path
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    if not p.exists():
+        p.write_text(json_string, encoding="utf-8")
+        return None
+    existing_content_layout: LayoutsFile = json.loads(p.read_text(encoding="utf-8"))
+    # policy: if layout with same name exists, replace it. we don't lool at tabConfig differences.
+    for a_new_layout in layouts:
+        for i, existing_layout in enumerate(existing_content_layout["layouts"]):
+            if existing_layout["layoutName"] == a_new_layout["layoutName"]:
+                existing_content_layout["layouts"][i] = a_new_layout
+                break
+        else:
+            existing_content_layout["layouts"].append(a_new_layout)
+    p.write_text(json.dumps(existing_content_layout, indent=4), encoding="utf-8")
+    return None

{machineconfig-3.85.dist-info → machineconfig-3.88.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 3.85
+Version: 3.88
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{machineconfig-3.85.dist-info → machineconfig-3.88.dist-info}/RECORD

@@ -172,13 +172,13 @@ machineconfig/scripts/python/devops_backup_retrieve.py,sha256=jZe5Vki7E2GCMG8hvq
 machineconfig/scripts/python/devops_devapps_install.py,sha256=Q2suPkfwwdtIN3mjxH6tGZLYC7tZVxdxrGW7d9phiPA,9972
 machineconfig/scripts/python/devops_update_repos.py,sha256=c5qBc9cuTGDEqDHufkjDT4d_vvJsswv3tlqk9MAulYk,8063
 machineconfig/scripts/python/dotfile.py,sha256=SRcX-9Ak1jRvF-killBTTm2IWcsNxfiLucH6ZsytAFA,2202
-machineconfig/scripts/python/fire_agents.py,sha256=_k1CcPaAp3B7h72tSczFDbLsqTg6FmPDgxxU-GjRHWA,9179
+machineconfig/scripts/python/fire_agents.py,sha256=Hn27ZGWBRlu3mDyJPf_qg_m0i3AbWbWpA-Ce1VeZjUY,9207
 machineconfig/scripts/python/fire_agents_help_launch.py,sha256=sTdjNz2pDinDMMjUAMN7OqH-KAUeHh6Aihr_zUvtM6k,6128
 machineconfig/scripts/python/fire_agents_help_search.py,sha256=qIfSS_su2YJ1Gb0_lu4cbjlJlYMBw0v52NTGiSrGjk8,2991
 machineconfig/scripts/python/fire_agents_load_balancer.py,sha256=QPiCbQq9j5REHStPdYqQcGNkz_rp5CjotqOpMY3v5TM,2099
 machineconfig/scripts/python/fire_jobs.py,sha256=qD_9JtoNTjOjAyX0_QPysfHNQ-qq55t-Tv9ctEK17MI,20569
 machineconfig/scripts/python/fire_jobs_args_helper.py,sha256=VsyPgjWRByZgXz65vmmpyR-2mJo6KwNgwrWFYd3EYqc,2075
-machineconfig/scripts/python/fire_jobs_layout_helper.py,sha256=Hj77uKgmNKSEBtnW0oCdRBwdKEuhzPxX1p81mRTBibo,3314
+machineconfig/scripts/python/fire_jobs_layout_helper.py,sha256=LHLyp5HxKwut19x2OYKQq8gy4EKon6wNb-jlxx5DoVM,4134
 machineconfig/scripts/python/fire_jobs_streamlit_helper.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 machineconfig/scripts/python/ftpx.py,sha256=vqwhfkg3jVaAdjlWvrcPms2pUD7_c370jn2W6o5XArM,10269
 machineconfig/scripts/python/get_zellij_cmd.py,sha256=e35-18hoXM9N3PFbvbizfkNY_-63iMicieWE3TbGcCQ,576
@@ -188,7 +188,8 @@ machineconfig/scripts/python/mount_nw_drive.py,sha256=iru6AtnTyvyuk6WxlK5R4lDkul
 machineconfig/scripts/python/mount_ssh.py,sha256=rGY2pgtlnWMi0Rrge1aCdjtfbULrj2cyaStDoX-y2w4,2236
 machineconfig/scripts/python/onetimeshare.py,sha256=bmGsNnskym5OWfIhpOfZG5jq3m89FS0a6dF5Sb8LaZM,2539
 machineconfig/scripts/python/pomodoro.py,sha256=SPkfeoZGv8rylGiOyzQ7UK3aXZ3G2FIOuGkSuBUggOI,2019
-machineconfig/scripts/python/repos.py,sha256=gU1gmYmiGTGDlZyIj3b1bC78yV5XZSXEkDD95WRqUnM,7376
+machineconfig/scripts/python/repos.py,sha256=vFlRA9BHXJau5BcIvQXShML3G6Xgv6aVuMqECo9PtfE,4258
+machineconfig/scripts/python/repos_helper_action.py,sha256=f0vFjPj9WEA361961ux3SIEg9riVGHtyuf6BnO6lnvU,13336
 machineconfig/scripts/python/repos_helper_clone.py,sha256=xW5YZEoNt3k7h9NIULhUhOnh53-B63eiXF2FjOl1IKQ,5535
 machineconfig/scripts/python/repos_helper_record.py,sha256=YEEQORfEiLddOIIgePo5eEkyQUFruFg3kc8npMvRL-o,10927
 machineconfig/scripts/python/repos_helper_update.py,sha256=AYyKIB7eQ48yoYmFjydIhRI1lV39TBv_S4_LCa-oKuQ,11042
@@ -197,7 +198,7 @@ machineconfig/scripts/python/share_terminal.py,sha256=divO0lleaX1l90ta4muv_ogUB7
 machineconfig/scripts/python/snapshot.py,sha256=aDvKeoniZaeTSNv9zWBUajaj2yagAxVdfuvO1_tgq5Y,1026
 machineconfig/scripts/python/start_slidev.py,sha256=U5ujAL7R5Gd5CzFReTsnF2SThjY91aFBg0Qz_MMl6U4,4573
 machineconfig/scripts/python/start_terminals.py,sha256=DRWbMZumhPmL0DvvsCsbRNFL5AVQn1SgaziafTio3YQ,6149
-machineconfig/scripts/python/t4.py,sha256=7zxjqDjsv8T9tCPUj6_3qOMc80YO7GyXzUM5IP_7iqQ,222
+machineconfig/scripts/python/t4.py,sha256=cZ45iWzS254V5pmVvq8wCw7jAuDhzr8G2Arzay76saU,316
 machineconfig/scripts/python/viewer.py,sha256=heQNjB9fwn3xxbPgMofhv1Lp6Vtkl76YjjexWWBM0pM,2041
 machineconfig/scripts/python/viewer_template.py,sha256=ve3Q1-iKhCLc0VJijKvAeOYp2xaFOeIOC_XW956GWCc,3944
 machineconfig/scripts/python/wifi_conn.py,sha256=4GdLhgma9GRmZ6OFg3oxOX-qY3sr45njPckozlpM_A0,15566
@@ -393,7 +394,7 @@ machineconfig/setup_windows/wt_and_pwsh/install_fonts.ps1,sha256=JsQfGAMkvirhiUm
 machineconfig/setup_windows/wt_and_pwsh/install_nerd_fonts.py,sha256=o9K7QMIw1cBdMxLQsOk64MAy1YgNNhPRYura8cdTLXI,4707
 machineconfig/setup_windows/wt_and_pwsh/set_wt_settings.py,sha256=rZZJamy3YxAeJhdMIFR6IWtjgn1u1HUdbk1J24NtryE,6116
 machineconfig/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-machineconfig/utils/accessories.py,sha256=6vw2C8QEroNRjHDcLC7clKlIWjUX5cJXb_65KN8wZTg,2484
+machineconfig/utils/accessories.py,sha256=W_9dLzjwNTW5JQk_pe3B2ijQ1nA2-8Kdg2r7VBtzgQs,4340
 machineconfig/utils/code.py,sha256=pKPHInKgXJWeACVbxuE7sMdYeZCbNttaYCsfonGhFfc,4464
 machineconfig/utils/installer.py,sha256=_sjaIqqHN-7n3mYD-iOIli6Bn2792EjOwE-JC528Qfo,11936
 machineconfig/utils/io.py,sha256=6LuQMT7CG26atx5_0P30Ru0zHgLwuvpKHfZLUWIjS-U,2873
@@ -419,10 +420,10 @@ machineconfig/utils/installer_utils/installer_abc.py,sha256=iB1_PZLQGouCdEA8bixd
 machineconfig/utils/installer_utils/installer_class.py,sha256=P3ZKr92b0ofbQCJUyK3eU3FVgK1ZMRw36WH-rbR5pAw,20430
 machineconfig/utils/schemas/fire_agents/fire_agents_input.py,sha256=CCs5ebomW1acKWZRpv9dyDzM-W6pwvVplikcutE2D8I,2339
 machineconfig/utils/schemas/installer/installer_types.py,sha256=iAzcALc9z_FAQE9iuGHfX6Z0B1_n3Gt6eC0d6heYik0,599
-machineconfig/utils/schemas/layouts/layout_types.py,sha256=OmiOX9xtakPz4l6IobWnpFHpbn95fitEE9q0YL1WxjQ,617
+machineconfig/utils/schemas/layouts/layout_types.py,sha256=M1ZFCz_kjRZPhxM19rIYUDR5lDDpwa09odR_ihtIFq0,1932
 machineconfig/utils/schemas/repos/repos_types.py,sha256=ECVr-3IVIo8yjmYmVXX2mnDDN1SLSwvQIhx4KDDQHBQ,405
-machineconfig-3.85.dist-info/METADATA,sha256=3OnrbCTgB0CwtK85fP2bkhm8aIF0iGIS46ZXUYu87xk,6998
-machineconfig-3.85.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-machineconfig-3.85.dist-info/entry_points.txt,sha256=rSx_9gXd2stziS1OkNy__jF647hrRxRiF6zolLUELc4,1153
-machineconfig-3.85.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
-machineconfig-3.85.dist-info/RECORD,,
+machineconfig-3.88.dist-info/METADATA,sha256=9lxn7WjqHpXrQZf633ZzqR190I1ZPVSqK0arz77rq_E,6998
+machineconfig-3.88.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+machineconfig-3.88.dist-info/entry_points.txt,sha256=rSx_9gXd2stziS1OkNy__jF647hrRxRiF6zolLUELc4,1153
+machineconfig-3.88.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
+machineconfig-3.88.dist-info/RECORD,,