machineconfig 3.0__tar.gz → 3.1__tar.gz

{machineconfig-3.0/src/machineconfig.egg-info → machineconfig-3.1}/PKG-INFO

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

{machineconfig-3.0 → machineconfig-3.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "3.0"
+version = "3.01"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}
@@ -68,6 +68,7 @@ mount_nw_drive = "machineconfig.scripts.python.mount_nw_drive:main"
 repos = "machineconfig.scripts.python.repos:main"
 start_slidev = "machineconfig.scripts.python.start_slidev:main"
 wifi_conn = "machineconfig.scripts.python.wifi_conn:main"
+kill_process = "machineconfig.utils.procs:main"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

machineconfig-3.1/src/machineconfig/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+from pathlib import Path
+import tomllib
+
+
+def _get_version() -> str:
+    name: str = "machineconfig"
+    try:
+        return _pkg_version(name)
+    except PackageNotFoundError:
+        pass
+
+    root: Path = Path(__file__).resolve().parents[2]
+    pyproject: Path = root / "pyproject.toml"
+    if pyproject.is_file():
+        with pyproject.open("rb") as f:
+            data: dict[str, object] = tomllib.load(f)
+        project = data.get("project")
+        if isinstance(project, dict):
+            version = project.get("version")
+            if isinstance(version, str) and version:
+                return version
+    return "0.0.0"
+
+
+__version__: str = _get_version()
+__all__: list[str] = ["__version__"]

{machineconfig-3.0 → machineconfig-3.1}/src/machineconfig/cluster/sessions_managers/enhanced_command_runner.py

@@ -14,7 +14,7 @@ from rich import box
 console = Console()
 
 
-def run_enhanced_command(command: str, description: Optional[str] = None, show_progress: bool = True, timeout: Optional[int] = None) -> Dict[str, Any]:
+def run_enhanced_command(command: str, description: Optional[str], show_progress: bool, timeout: Optional[int]) -> Dict[str, Any]:
     """
     Run a command with enhanced Rich formatting and user feedback.
 
@@ -89,16 +89,16 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
     run_enhanced_command(
         delete_cmd,
         f"Cleaning up existing session '{session_name}'",
-        show_progress=False,
-        timeout=5,  # Quick timeout for cleanup
+        False,
+        5,  # Quick timeout for cleanup
     )
     # Start new session (use -b for background to avoid hanging)
     start_cmd = f"zellij --layout {layout_path} a -b {session_name}"
     start_result = run_enhanced_command(
         start_cmd,
         f"Starting session '{session_name}' with layout",
-        show_progress=False,
-        timeout=10,  # Add timeout to prevent hanging
+        False,
+        10,  # Add timeout to prevent hanging
     )
 
     if start_result["success"]:
@@ -114,5 +114,5 @@ if __name__ == "__main__":
     console.print(Panel.fit("🎨 Enhanced Command Execution Demo", style="bold cyan"))
 
     # Test with a simple command
-    result = run_enhanced_command("echo 'Hello, Rich world!'", "Testing enhanced output")
+    result = run_enhanced_command("echo 'Hello, Rich world!'", "Testing enhanced output", True, None)
     console.print(f"Result: {result}")

{machineconfig-3.0 → machineconfig-3.1}/src/machineconfig/cluster/sessions_managers/wt_local.py

@@ -27,7 +27,7 @@ class WTLayoutGenerator:
         self.script_path: Optional[str] = None  # Store the full path to the PowerShell script
 
     @staticmethod
-    def _generate_random_suffix(length: int = 8) -> str:
+    def _generate_random_suffix(length: int) -> str:
         """Generate a random string suffix for unique PowerShell script names."""
         return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
 
@@ -53,7 +53,7 @@ class WTLayoutGenerator:
         return text
 
     @staticmethod
-    def _create_tab_command(tab_config: TabConfig, is_first_tab: bool = False) -> str:
+    def _create_tab_command(tab_config: TabConfig, is_first_tab: bool) -> str:
         """Create a Windows Terminal tab command string from tab config."""
         tab_name = tab_config["tabName"]
         cwd = tab_config["startDir"]
@@ -95,7 +95,7 @@ class WTLayoutGenerator:
             if not tab["startDir"].strip():
                 raise ValueError(f"Invalid startDir for tab '{tab['tabName']}': {tab['startDir']}")
 
-    def create_wt_layout(self, layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
+    def create_wt_layout(self, layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
         WTLayoutGenerator._validate_layout_config(layout_config)
         logger.info(f"Creating Windows Terminal layout '{layout_config['layoutName']}' with {len(layout_config['layoutTabs'])} tabs")
 
@@ -107,7 +107,7 @@ class WTLayoutGenerator:
         wt_command = self._generate_wt_command_string(layout_config, self.session_name)
 
         try:
-            random_suffix = WTLayoutGenerator._generate_random_suffix()
+            random_suffix = WTLayoutGenerator._generate_random_suffix(8)
             if output_dir:
                 output_path = Path(output_dir)
                 output_path.mkdir(parents=True, exist_ok=True)
@@ -367,7 +367,7 @@ Get-Process | ForEach-Object {{
         print("=" * 80)
 
 
-def create_wt_layout(layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
+def create_wt_layout(layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
     generator = WTLayoutGenerator()
     return generator.create_wt_layout(layout_config, output_dir)
 
@@ -375,7 +375,7 @@ def create_wt_layout(layout_config: LayoutConfig, output_dir: Optional[str] = No
 def run_wt_layout(layout_config: LayoutConfig) -> str:
     """Create and run a Windows Terminal layout."""
     generator = WTLayoutGenerator()
-    script_path = generator.create_wt_layout(layout_config)
+    script_path = generator.create_wt_layout(layout_config, None)
 
     # Execute the script
     cmd = f'powershell -ExecutionPolicy Bypass -File "{script_path}"'
@@ -406,7 +406,7 @@ if __name__ == "__main__":
     try:
         # Create layout using the generator
         generator = WTLayoutGenerator()
-        script_path = generator.create_wt_layout(sample_layout)
+        script_path = generator.create_wt_layout(sample_layout, None)
         print(f"✅ Windows Terminal layout created: {script_path}")
 
         # Show preview

{machineconfig-3.0 → machineconfig-3.1}/src/machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -35,7 +35,7 @@ class WTLocalManager:
         # Create a WTLayoutGenerator for each session
         for layout_config in session_layouts:
             manager = WTLayoutGenerator()
-            manager.create_wt_layout(layout_config=layout_config)
+            manager.create_wt_layout(layout_config=layout_config, output_dir=None)
             self.managers.append(manager)
 
         logger.info(f"Initialized WTLocalManager with {len(self.managers)} sessions")
@@ -324,16 +324,16 @@ class WTLocalManager:
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
 
-        with open(config_file, "r", encoding="utf-8") as f:
-            session_layouts = json.load(f)
+        text = config_file.read_text(encoding="utf-8")
+        session_layouts = json.loads(text)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "LocalWTMgr"  # default fallback
         if metadata_file.exists():
-            with open(metadata_file, "r", encoding="utf-8") as f:
-                metadata = json.load(f)
-                session_name_prefix = metadata.get("session_name_prefix", "LocalWTMgr")
+            text = metadata_file.read_text(encoding="utf-8")
+            metadata = json.loads(text)
+            session_name_prefix = metadata.get("session_name_prefix", "LocalWTMgr")
 
         # Create new instance
         instance = cls(session_layouts=session_layouts, session_name_prefix=session_name_prefix)
@@ -346,8 +346,8 @@ class WTLocalManager:
 
             for manager_file in manager_files:
                 try:
-                    with open(manager_file, "r", encoding="utf-8") as f:
-                        manager_data = json.load(f)
+                    text = manager_file.read_text(encoding="utf-8")
+                    manager_data = json.loads(text)
 
                     # Recreate the manager
                     manager = WTLayoutGenerator()

{machineconfig-3.0 → machineconfig-3.1}/src/machineconfig/cluster/sessions_managers/wt_remote.py

@@ -34,7 +34,7 @@ class WTRemoteLayoutGenerator:
 
     # Tabs are stored and used as List[TabConfig]; no legacy dict compatibility
 
-    def create_wt_layout(self, tabs: List[TabConfig], output_dir: Optional[str] = None) -> str:
+    def create_wt_layout(self, tabs: List[TabConfig], output_dir: Optional[str]) -> str:
         logger.info(f"Creating Windows Terminal layout with {len(tabs)} tabs for remote '{self.remote_name}'")
         self.tabs = tabs
         if output_dir:
@@ -49,7 +49,7 @@ class WTRemoteLayoutGenerator:
     def to_dict(self) -> Dict[str, Any]:
         return {"remote_name": self.remote_name, "session_name": self.session_name, "tabs": self.tabs, "script_path": self.script_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
 
-    def to_json(self, file_path: Optional[str] = None) -> str:
+    def to_json(self, file_path: Optional[str]) -> str:
         # Generate file path if not provided
         if file_path is None:
             random_id = str(uuid.uuid4())[:8]
@@ -87,8 +87,8 @@ class WTRemoteLayoutGenerator:
             raise FileNotFoundError(f"JSON file not found: {path_obj}")
 
         # Load JSON data
-        with open(path_obj, "r", encoding="utf-8") as f:
-            data = json.load(f)
+        text = path_obj.read_text(encoding="utf-8")
+        data = json.loads(text)
 
         # Validate that it's the correct class
         if data.get("class_name") != cls.__name__:
@@ -117,7 +117,7 @@ class WTRemoteLayoutGenerator:
         return instance
 
     @staticmethod
-    def list_saved_sessions(directory_path: Optional[str] = None) -> List[str]:
+    def list_saved_sessions(directory_path: Optional[str]) -> List[str]:
         if directory_path is None:
             dir_path = Path.home() / "tmp_results" / "wt_sessions" / "serialized"
         else:
@@ -146,7 +146,7 @@ if __name__ == "__main__":
     try:
         # Create layout using the remote generator
         generator = WTRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
-        script_path = generator.create_wt_layout(sample_tabs)
+        script_path = generator.create_wt_layout(sample_tabs, None)
         print(f"✅ Remote layout created successfully: {script_path}")
 
         # Check if Windows Terminal is available on remote
@@ -160,11 +160,11 @@ if __name__ == "__main__":
 
         # Demonstrate serialization
         print("\n💾 Demonstrating serialization...")
-        saved_path = generator.to_json()
+        saved_path = generator.to_json(None)
         print(f"✅ Session saved to: {saved_path}")
 
         # List all saved sessions
-        saved_sessions = WTRemoteLayoutGenerator.list_saved_sessions()
+        saved_sessions = WTRemoteLayoutGenerator.list_saved_sessions(None)
         print(f"📋 Available saved sessions: {saved_sessions}")
 
         # Demonstrate loading (using the full path)

{machineconfig-3.0 → machineconfig-3.1}/src/machineconfig/cluster/sessions_managers/wt_remote_manager.py

@@ -24,7 +24,7 @@ class WTSessionManager:
             an_m = WTRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
             # Convert legacy dict[str, tuple[str,str]] to List[TabConfig]
             tabs: list[TabConfig] = [{"tabName": name, "startDir": cwd, "command": cmd} for name, (cwd, cmd) in tab_config.items()]
-            an_m.create_wt_layout(tabs=tabs)
+            an_m.create_wt_layout(tabs=tabs, output_dir=None)
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -124,16 +124,16 @@ class WTSessionManager:
         config_file = session_dir / "machine2wt_tabs.json"
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
-        with open(config_file, "r", encoding="utf-8") as f:
-            machine2wt_tabs = json.load(f)
+        text = config_file.read_text(encoding="utf-8")
+        machine2wt_tabs = json.loads(text)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "WTJobMgr"  # default fallback
         if metadata_file.exists():
-            with open(metadata_file, "r", encoding="utf-8") as f:
-                metadata = json.load(f)
-                session_name_prefix = metadata.get("session_name_prefix", "WTJobMgr")
+            text = metadata_file.read_text(encoding="utf-8")
+            metadata = json.loads(text)
+            session_name_prefix = metadata.get("session_name_prefix", "WTJobMgr")
         # Create new instance (this will create new managers)
         instance = cls(machine2wt_tabs=machine2wt_tabs, session_name_prefix=session_name_prefix)
         # Load saved managers to restore their states