machineconfig 1.96__py3-none-any.whl → 2.0__py3-none-any.whl

machineconfig/cluster/cloud_manager.py

@@ -19,18 +19,18 @@
 #     """Convert list of dictionaries to markdown table format."""
 #     if not data:
 #         return ""
-    
+
 #     # Get all unique keys from all dictionaries
 #     all_keys = set()
 #     for row in data:
 #         all_keys.update(row.keys())
-    
+
 #     keys = sorted(all_keys)
-    
+
 #     # Create header
 #     header = "|" + "|".join(f" {key} " for key in keys) + "|"
 #     separator = "|" + "|".join(" --- " for _ in keys) + "|"
-    
+
 #     # Create rows
 #     rows = []
 #     for row in data:
@@ -44,7 +44,7 @@
 #                 value = str(value)
 #             row_values.append(f" {value} ")
 #         rows.append("|" + "|".join(row_values) + "|")
-    
+
 #     return "\n".join([header, separator] + rows)
 
 
@@ -100,7 +100,6 @@
 #     @staticmethod
 #     def prepare_servers_report(cloud_root: PathExtended) -> list[dict[str, Any]]:
 #         from machineconfig.cluster.remote_machine import RemoteMachine
-#         # Replace crocodile List usage with plain Python list
 #         workers_root = [p for p in cloud_root.joinpath("workers").iterdir()]
 #         res: dict[str, list[RemoteMachine]] = {}
 #         times: dict[str, timedelta] = {}
@@ -109,7 +108,7 @@
 #             file_mod_time = datetime.fromtimestamp(running_jobs.stat().st_mtime) if running_jobs.exists() else datetime.min
 #             times[a_worker.name] = datetime.now() - file_mod_time
 #             res[a_worker.name] = pickle.loads(running_jobs.read_bytes()) if running_jobs.exists() else []
-        
+
 #         # Create list of dictionaries instead of DataFrame
 #         servers_report = []
 #         for machine in res.keys():
@@ -127,7 +126,7 @@
 #             alternative_base = self.fetch_cloud_live()
 #             assert alternative_base is not None
 #             lock_path = alternative_base.expanduser().joinpath("lock.txt")
-#             if lock_path.exists(): lock_owner: str = lock_path.read_text()
+#             if lock_path.exists(): lock_owner: str = lock_path.read_text(encoding="utf-8")
 #             else: lock_owner = "None"
 #             self.console.print(f"🔒 Lock is held by: {lock_owner}")
 #             self.console.print("🧾 Log File:")
@@ -139,7 +138,7 @@
 #             for item_name, item_list in log.items():
 #                 self.console.rule(f"{item_name} Jobs (Latest {'10' if len(item_list) > 10 else len(item_list)} / {len(item_list)})")
 #                 print()  # empty line after the rule helps keeping the rendering clean in the terminal while zooming in and out.
-                
+
 #                 # Add duration calculation for non-queued items
 #                 display_items = []
 #                 for item in item_list:
@@ -162,13 +161,13 @@
 #                 if item_name == "running": excluded_cols.update({"submission_time", "source_machine", "end_time"})
 #                 if item_name == "completed": excluded_cols.update({"submission_time", "source_machine", "start_time", "pid"})
 #                 if item_name == "failed": excluded_cols.update({"submission_time", "source_machine", "start_time"})
-                
+
 #                 # Filter items and take last 10
 #                 filtered_items = []
 #                 for item in display_items[-10:]:
 #                     filtered_item = {k: v for k, v in item.items() if k not in excluded_cols}
 #                     filtered_items.append(filtered_item)
-                
+
 #                 if filtered_items:
 #                     pprint(format_table_markdown(filtered_items))
 #                 pprint("\n\n")
@@ -246,9 +245,6 @@
 #         """This method involves manual selection but has all-files scope (failed and running) and can be used for both local and remote machines.
 #         The reason it is not automated for remotes is because even though the server might have failed, the processes therein might be running, so there is no automated way to tell."""
 #         log = self.read_log()
-#         from machineconfig.cluster.remote_machine import RemoteMachine
-#         from machineconfig.utils.utils import display_options
-#         # Replace crocodile List usage with plain Python list comprehension
 #         jobs_all: list[str] = [p.name for p in self.base_path.expanduser().joinpath("jobs").iterdir()]
 #         jobs_selected = display_options(options=jobs_all, msg="Select Jobs to Redo", multi=True, fzf=True)
 #         for a_job in jobs_selected:
@@ -263,13 +259,13 @@
 #                         break
 #                 if found_log_type:
 #                     break
-            
+
 #             if not found_log_type:
 #                 raise ValueError(f"Job `{a_job}` is not found in any of the log lists.")
-            
+
 #             if found_entry_data is None:
 #                 raise ValueError(f"Job `{a_job}` has no entry data.")
-            
+
 #             entry = LogEntry.from_dict(found_entry_data)
 #             a_job_path = CloudManager.base_path.expanduser().joinpath(f"jobs/{entry.name}")
 #             entry.note += f"| Job failed @ {entry.run_machine}"
@@ -308,14 +304,14 @@
 #             elif status == "completed" or status == "failed":
 #                 job_name = a_rm.config.job_id
 #                 log = self.read_log()
-                
+
 #                 # Find the entry in running jobs
 #                 entry_data = None
 #                 for job_data in log["running"]:
 #                     if job_data.get("name") == job_name:
 #                         entry_data = job_data
 #                         break
-                
+
 #                 if entry_data:
 #                     entry = LogEntry.from_dict(entry_data)
 #                     entry.end_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@@ -344,7 +340,7 @@
 #         while len(self.running_jobs) < self.max_jobs:
 #             if idx >= len(log["queued"]):
 #                 break  # looked at all jobs in the queue
-            
+
 #             queue_entry = LogEntry.from_dict(log["queued"][idx])
 #             a_job_path = CloudManager.base_path.expanduser().joinpath(f"jobs/{queue_entry.name}")
 #             rm: RemoteMachine = pickle.loads(a_job_path.joinpath("data/remote_machine.Machine.pkl").read_bytes())
@@ -352,14 +348,14 @@
 #                 print(f"Job `{queue_entry.name}` is not allowed to run on this machine. Skipping ...")
 #                 idx += 1
 #                 continue  # look at the next job in the queue.
-            
+
 #             pid, _process_cmd = rm.fire(run=True)
 #             queue_entry.pid = pid
 #             # queue_entry.cmd = process_cmd
 #             queue_entry.run_machine = f"{getpass.getuser()}@{platform.node()}"
 #             queue_entry.start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 #             queue_entry.session_name = rm.job_params.session_name
-            
+
 #             # Remove from queued and add to running
 #             log["queued"] = [job for job in log["queued"] if job.get("name") != queue_entry.name]
 #             log["running"].append(queue_entry.__dict__)
@@ -374,7 +370,7 @@
 #         base_path.mkdir(parents=True, exist_ok=True)
 #         base_path.sync_to_cloud(cloud=self.cloud, rel2home=True, sync_up=True, verbose=True, transfers=100)
 #         self.release_lock()
-#     def reset_lock(self): 
+#     def reset_lock(self):
 #         base_path = CloudManager.base_path.expanduser()
 #         base_path.mkdir(parents=True, exist_ok=True)
 #         base_path.joinpath("lock.txt").write_text("").to_cloud(cloud=self.cloud, rel2home=True, verbose=False)
@@ -402,7 +398,7 @@
 #             path.joinpath("lock.txt").write_text(this_machine).to_cloud(cloud=self.cloud, rel2home=True, verbose=False)
 #             return self.claim_lock(first_call=False)
 
-#         locking_machine = lock_path.read_text()
+#         locking_machine = lock_path.read_text(encoding="utf-8")
 #         if locking_machine != "" and locking_machine != this_machine:
 #             lock_mod_time = datetime.fromtimestamp(lock_path.stat().st_mtime)
 #             if (datetime.now() - lock_mod_time).total_seconds() > 3600:
@@ -424,7 +420,7 @@
 #         while counter < self.num_claim_checks:
 #             lock_path_tmp = path.joinpath("lock.txt").from_cloud(cloud=self.cloud, rel2home=True, verbose=False)
 #             assert lock_path_tmp is not None
-#             lock_data_tmp = lock_path_tmp.read_text()
+#             lock_data_tmp = lock_path_tmp.read_text(encoding="utf-8")
 #             if lock_data_tmp != this_machine:
 #                 print(f"CloudManager: Lock already claimed by `{lock_data_tmp}`. 🤷‍♂️")
 #                 print(f"sleeping for {self.inter_check_interval_sec} seconds and trying again.")
@@ -450,7 +446,7 @@
 #             path.joinpath("lock.txt").write_text("").to_cloud(cloud=self.cloud, rel2home=True, verbose=False)
 #             self.lock_claimed = False
 #             return NoReturn
-#         data = lock_path.read_text()
+#         data = lock_path.read_text(encoding="utf-8")
 #         this_machine = f"{getpass.getuser()}@{platform.node()}"
 #         if data != this_machine:
 #             raise ValueError(f"CloudManager: Lock already claimed by `{data}`. 🤷‍♂️ Can't release a lock not owned! This shouldn't happen. Consider increasing trails before confirming the claim.")

machineconfig/cluster/data_transfer.py

@@ -24,7 +24,7 @@
 #         rm.file_manager.cloud_download_py_script_path.expanduser().write_text(cloud_download_py_script, encoding="utf-8")
 #         # modify and save shell_script to including running of cloud_download_py_script before job script.
 #         shell_file = rm.file_manager.shell_script_path.expanduser()
-#         shell_script = shell_file.read_text().replace("# EXTRA-PLACEHOLDER-POST", f"cd ~; python {rm.file_manager.cloud_download_py_script_path.rel2home().as_posix()}")
+#         shell_script = shell_file.read_text(encoding="utf-8").replace("# EXTRA-PLACEHOLDER-POST", f"cd ~; python {rm.file_manager.cloud_download_py_script_path.rel2home().as_posix()}")
 #         download_url = rm.file_manager.job_root.zip().share_on_cloud()
 #         target = rm.file_manager.job_root.rel2home().parent.joinpath(download_url.name).as_posix()
 #         tmp = f"cd ~; curl -o '{target}' '{download_url.as_url_str()}'; unzip '{target}' -d {rm.file_manager.job_root.rel2home().parent.as_posix()}"
@@ -40,7 +40,7 @@
 #         downloads = '\n'.join([f"cloud_copy {cloud}: '{a_path.collapseuser().as_posix()} -r" for a_path in rm.data])
 #         if not rm.config.copy_repo: downloads += f"""\n cloud_copy {cloud}: {P(rm.job_params.repo_path_rh).collapseuser().as_posix()} -zer """
 #         downloads += f"\ncloud_copy {cloud}: {rm.file_manager.job_root} -zr"
-#         rm.file_manager.shell_script_path.expanduser().write_text(downloads + rm.file_manager.shell_script_path.expanduser().read_text(), encoding='utf-8')  # newline={"Windows": None, "Linux": "\n"}[rm.ssh.get_remote_machine()]
+#         rm.file_manager.shell_script_path.expanduser().write_text(downloads + rm.file_manager.shell_script_path.expanduser().read_text(encoding="utf-8"), encoding='utf-8')  # newline={"Windows": None, "Linux": "\n"}[rm.ssh.get_remote_machine()]
 #         PathExtended(rm.file_manager.job_root).to_cloud(cloud=cloud, zip=True, rel2home=True)
 
 #     @staticmethod

machineconfig/cluster/distribute.py

@@ -190,8 +190,6 @@
 #     def viz_load_ratios(self) -> None:
 #         if not self.workload_params: raise RuntimeError("func_kwargs_list is None. You need to run generate_standard_kwargs() first.")
 #         import plottext
-#         names = L(self.sshz).apply(lambda x: x.get_remote_repr(add_machine=True)).list
-
 #         plt.simple_multiple_bar(names, [[machine_specs.cpu for machine_specs in self.machines_specs], [machine_specs.ram for machine_specs in self.machines_specs]], title="Resources per machine", labels=["#cpu threads", "memory size"])
 #         plt.show()
 #         print("")

machineconfig/cluster/file_manager.py

@@ -68,16 +68,16 @@
 #         # else:
 #         if platform.system() == "Windows" and script_path.name.endswith(".sh"):
 #             tmp = script_path.with_suffix(".ps1")
-#             tmp.write_text(script_path.read_text(), encoding="utf-8", newline=None)
+#             tmp.write_text(script_path.read_text(encoding="utf-8"), encoding="utf-8", newline=None)
 #             script_path = tmp
 #         if platform.system() == "Linux" and script_path.name.endswith(".ps1"):
 #             tmp = script_path.with_suffix(".sh")
-#             tmp.write_text(script_path.read_text(), encoding="utf-8", newline='\n')
+#             tmp.write_text(script_path.read_text(encoding="utf-8"), encoding="utf-8", newline='\n')
 #             script_path = tmp
 #         return f". {script_path}"
 #     def get_job_status(self, session_name: str, tab_name: str) -> JOB_STATUS:
 #         pid_path = self.execution_log_dir.expanduser().joinpath("pid.txt")
-#         tmp = self.execution_log_dir.expanduser().joinpath("status.txt").read_text()
+#         tmp = self.execution_log_dir.expanduser().joinpath("status.txt").read_text(encoding="utf-8")
 #         status: JOB_STATUS = tmp  # type: ignore
 #         if status == "running":
 #             if not pid_path.exists():
@@ -85,7 +85,7 @@
 #                 status = 'failed'
 #                 self.execution_log_dir.expanduser().joinpath("status.txt").write_text(status)
 #                 return status
-#             pid: int = int(pid_path.read_text().rstrip())
+#             pid: int = int(pid_path.read_text(encoding="utf-8").rstrip())
 #             import psutil
 #             try: proc = psutil.Process(pid=pid)
 #             except psutil.NoSuchProcess:

machineconfig/cluster/job_params.py

@@ -113,7 +113,7 @@
 #         else: base = f"""
 # res = None  # in case the file did not define it.
 # # --------------------------------- SCRIPT AS IS
-# {P(self.file_path_rh).expanduser().read_text()}
+# {P(self.file_path_rh).expanduser().read_text(encoding="utf-8")}
 # # --------------------------------- END OF SCRIPT AS IS
 # """
 

machineconfig/cluster/loader_runner.py

@@ -111,15 +111,15 @@
 #     @staticmethod
 #     def from_dict(a_dict: dict[str, Any]):
 #         return LogEntry(
-#             name=a_dict["name"], 
-#             submission_time=str(a_dict["submission_time"]), 
-#             start_time=str(a_dict["start_time"]) if a_dict.get("start_time") else None, 
+#             name=a_dict["name"],
+#             submission_time=str(a_dict["submission_time"]),
+#             start_time=str(a_dict["start_time"]) if a_dict.get("start_time") else None,
 #             end_time=str(a_dict["end_time"]) if a_dict.get("end_time") else None,
-#             run_machine=a_dict.get("run_machine"), 
-#             source_machine=a_dict.get("source_machine", ""), 
-#             note=a_dict.get("note", ""), 
-#             pid=a_dict.get("pid"), 
-#             cmd=a_dict.get("cmd"), 
+#             run_machine=a_dict.get("run_machine"),
+#             source_machine=a_dict.get("source_machine", ""),
+#             note=a_dict.get("note", ""),
+#             pid=a_dict.get("pid"),
+#             cmd=a_dict.get("cmd"),
 #             session_name=a_dict.get("session_name")
 #         )
 

machineconfig/cluster/remote_machine.py

@@ -79,7 +79,7 @@
 #                 print(f"🧑‍💻 Waiting for Python process to start and declare its pid @ `{pid_path}` as dictated in python script ... ")
 #                 time.sleep(3)
 #                 try:
-#                     pid = int(pid_path.read_text())
+#                     pid = int(pid_path.read_text(encoding="utf-8"))
 #                     import psutil
 #                     process_command = " ".join(psutil.Process(pid).cmdline())
 #                     print(f"🎉 Python process started running @ {pid=} & {process_command=}")
@@ -133,7 +133,7 @@
 #             email_script = PathExtended(cluster.__file__).parent.joinpath("script_notify_upon_completion.py").read_text(encoding="utf-8").replace("email_params = EmailParams.from_empty()", f"email_params = {email_params}").replace('manager = FileManager.from_pickle(params.file_manager_path)', '')
 #             py_script = py_script.replace("# NOTIFICATION-CODE-PLACEHOLDER", email_script)
 #         ve_path = PathExtended(self.job_params.repo_path_rh).expanduser().joinpath(".ve_path")
-#         if ve_path.exists(): ve_name = PathExtended(ve_path.read_text()).expanduser().name
+#         if ve_path.exists(): ve_name = PathExtended(ve_path.read_text(encoding="utf-8")).expanduser().name
 #         else:
 #             import sys
 #             ve_name = PathExtended(sys.executable).parent.parent.name
@@ -216,7 +216,7 @@
 #             if not start_time_file.exists():
 #                 print(f"Job {self.config.job_id} is still in the queue. 😯")
 #             else:
-#                 start_time = start_time_file.read_text()
+#                 start_time = start_time_file.read_text(encoding="utf-8")
 #                 txt = f"Machine {self.ssh.get_remote_repr(add_machine=True)} has not yet finished job `{self.config.job_id}`. 😟"
 #                 txt += f"\nIt started at {start_time}. 🕒, and is still running. 🏃‍♂️"
 #                 try:
@@ -229,7 +229,7 @@
 #                 print("\n")
 #         else:
 #             results_folder_file = base.joinpath("results_folder_path.txt")  # it could be one returned by function executed or one made up by the running context.
-#             results_folder = results_folder_file.read_text()
+#             results_folder = results_folder_file.read_text(encoding="utf-8")
 #             print("\n" * 2)
 #             console.rule("Job Completed 🎉🥳🎆🥂🍾🎊🪅")
 #             print(f"""Machine {self.ssh.get_remote_repr(add_machine=True)} has finished job `{self.config.job_id}`. 😁

machineconfig/cluster/script_execution.py

@@ -63,9 +63,9 @@
 # ⏰ Time: {time_at_execution_start_local}
 # """, style="bold blue")
 
-# if isinstance(func_kwargs, dict): 
+# if isinstance(func_kwargs, dict):
 #     pprint(func_kwargs, "📋 Function Arguments")
-# else: 
+# else:
 #     pprint(func_kwargs, f"📋 Function Arguments from `{manager.kwargs_path.collapseuser().as_posix()}`")
 
 # print("\n" + "•" * 60 + "\n")

machineconfig/cluster/sessions_managers/archive/create_zellij_template.py

@@ -44,7 +44,7 @@ def build_template(tabs: list[str]):
     res += suffix.replace("THISMACHINE", socket.gethostname())
     file = PathExtended.tmp().joinpath("tmp_files/templates/zellij_template.kdl")
     file.parent.mkdir(parents=True, exist_ok=True)
-    file.write_text(res)
+    file.write_text(res, encoding="utf-8")
     res = f"zellij --layout {file}"
     return res
 

machineconfig/cluster/sessions_managers/enhanced_command_runner.py

@@ -14,27 +14,27 @@ from rich import box
 console = Console()
 
 def run_enhanced_command(
-    command: str, 
+    command: str,
     description: Optional[str] = None,
     show_progress: bool = True,
     timeout: Optional[int] = None
 ) -> Dict[str, Any]:
     """
     Run a command with enhanced Rich formatting and user feedback.
-    
+
     Args:
         command: The command to execute
         description: Optional description for progress display
         show_progress: Whether to show a progress spinner
         timeout: Optional timeout in seconds
-    
+
     Returns:
         Dictionary with success status, output, and error information
     """
-    
+
     if description is None:
         description = f"Executing: {command[:50]}..."
-    
+
     try:
         if show_progress:
             with Progress(
@@ -44,7 +44,7 @@ def run_enhanced_command(
                 transient=True
             ) as progress:
                 task = progress.add_task(f"[cyan]{description}[/cyan]", total=None)
-                
+
                 result = subprocess.run(
                     command,
                     shell=True,
@@ -52,7 +52,7 @@ def run_enhanced_command(
                     text=True,
                     timeout=timeout
                 )
-                
+
                 progress.update(task, completed=True)
         else:
             result = subprocess.run(
@@ -62,27 +62,27 @@ def run_enhanced_command(
                 text=True,
                 timeout=timeout
             )
-        
+
         # Enhanced output processing
         stdout = result.stdout.strip() if result.stdout else ""
         stderr = result.stderr.strip() if result.stderr else ""
-        
+
         # Process common Zellij messages with enhanced formatting
         if "Session:" in stdout and "successfully deleted" in stdout:
             session_match = re.search(r'Session: "([^"]+)" successfully deleted', stdout)
             if session_match:
                 session_name = session_match.group(1)
                 console.print(f"[bold red]🗑️  Session[/bold red] [yellow]'{session_name}'[/yellow] [red]successfully deleted[/red]")
-        
+
         if "zellij layout is running" in stdout:
-            console.print(stdout.replace("zellij layout is running @", 
+            console.print(stdout.replace("zellij layout is running @",
                                        "[bold green]🚀 Zellij layout is running[/bold green] [yellow]@[/yellow]"))
-        
+
         # Handle pseudo-terminal warnings with less alarming appearance
         if "Pseudo-terminal will not be allocated" in stderr:
             console.print("[dim yellow]ℹ️  Note: Running in non-interactive mode[/dim yellow]")
             stderr = stderr.replace("Pseudo-terminal will not be allocated because stdin is not a terminal.\n", "")
-        
+
         if result.returncode == 0:
             if stdout and not any(msg in stdout for msg in ["Session:", "zellij layout is running"]):
                 console.print(f"[green]{stdout}[/green]")
@@ -101,7 +101,7 @@ def run_enhanced_command(
                 "stdout": stdout,
                 "stderr": stderr
             }
-            
+
     except subprocess.TimeoutExpired:
         console.print(f"[bold red]⏰ Command timed out after {timeout} seconds[/bold red]")
         return {
@@ -121,18 +121,18 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
     Start a Zellij session with enhanced visual feedback.
     """
     console.print()
-    console.print(Panel.fit(f"🚀 Starting Zellij Session: [bold cyan]{session_name}[/bold cyan]", 
+    console.print(Panel.fit(f"🚀 Starting Zellij Session: [bold cyan]{session_name}[/bold cyan]",
                           style="green", box=box.ROUNDED))
-    
+
     # Delete existing session first (suppress normal output)
     delete_cmd = f"zellij delete-session --force {session_name}"
     run_enhanced_command(
-        delete_cmd, 
+        delete_cmd,
         f"Cleaning up existing session '{session_name}'",
         show_progress=False,
         timeout=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(
@@ -141,20 +141,20 @@ def enhanced_zellij_session_start(session_name: str, layout_path: str) -> Dict[s
         show_progress=False,
         timeout=10  # Add timeout to prevent hanging
     )
-    
+
     if start_result["success"]:
-        console.print(Panel(f"[bold green]✅ Session '{session_name}' is now running![/bold green]\n[dim]Layout: {layout_path}[/dim]", 
+        console.print(Panel(f"[bold green]✅ Session '{session_name}' is now running![/bold green]\n[dim]Layout: {layout_path}[/dim]",
                            style="green", title="🎉 Success"))
     else:
-        console.print(Panel(f"[bold red]❌ Failed to start session '{session_name}'[/bold red]\n[red]{start_result.get('stderr', 'Unknown error')}[/red]", 
+        console.print(Panel(f"[bold red]❌ Failed to start session '{session_name}'[/bold red]\n[red]{start_result.get('stderr', 'Unknown error')}[/red]",
                            style="red", title="💥 Error"))
-    
+
     return start_result
 
 if __name__ == "__main__":
     # Demo the enhanced command execution
     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")
     console.print(f"Result: {result}")