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

machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py

@@ -13,11 +13,11 @@ logger = logging.getLogger(__name__)
 
 class ProcessMonitor:
     """Handles process status checking and verification on remote machines."""
-    
+
     def __init__(self, remote_executor: RemoteExecutor):
         self.remote_executor = remote_executor
-    
-    def check_command_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]], 
+
+    def check_command_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]],
                            use_verification: bool = True) -> Dict[str, Any]:
         """Check command status with optional process verification."""
         if tab_name not in tab_config:
@@ -29,26 +29,26 @@ class ProcessMonitor:
                 "command": None,
                 "remote": self.remote_executor.remote_name
             }
-        
+
         # Use the verified method by default for more accurate results
         if use_verification:
             return self.get_verified_process_status(tab_name, tab_config)
-        
+
         return self._basic_process_check(tab_name, tab_config)
-    
+
     def _basic_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
         """Basic process checking without verification."""
         _, command = tab_config[tab_name]
-        
+
         try:
             check_script = self._create_process_check_script(command)
             remote_cmd = f"$HOME/venvs/ve/bin/python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
-            
+
             if result.returncode == 0:
                 try:
                     matching_processes = json.loads(result.stdout.strip())
-                    
+
                     if matching_processes:
                         return {
                             "status": "running",
@@ -79,14 +79,14 @@ class ProcessMonitor:
                     }
             else:
                 return {
-                    "status": "error", 
+                    "status": "error",
                     "error": f"Remote command failed: {result.stderr}",
                     "running": False,
                     "command": command,
                     "tab_name": tab_name,
                     "remote": self.remote_executor.remote_name
                 }
-                
+
         except Exception as e:
             logger.error(f"Error checking command status for tab '{tab_name}': {e}")
             return {
@@ -97,7 +97,7 @@ class ProcessMonitor:
                 "tab_name": tab_name,
                 "remote": self.remote_executor.remote_name
             }
-    
+
     def _create_process_check_script(self, command: str) -> str:
         """Create Python script for checking processes on remote machine."""
         return f"""
@@ -110,25 +110,25 @@ def check_process():
     full_command = '{command}'
     cmd_parts = [part for part in full_command.split() if len(part) > 2]
     current_pid = os.getpid()
-    
+
     primary_cmd = cmd_parts[0] if cmd_parts else ''
-    
+
     for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'status', 'create_time']):
         try:
             if proc.info['pid'] == current_pid:
                 continue
-                
+
             if proc.info['cmdline'] and len(proc.info['cmdline']) > 0:
                 cmdline_str = ' '.join(proc.info['cmdline'])
-                
+
                 if 'check_process()' in cmdline_str or 'psutil.process_iter' in cmdline_str:
                     continue
-                
+
                 matches_primary = primary_cmd in cmdline_str
                 matches_parts = sum(1 for part in cmd_parts[1:] if part in cmdline_str)
-                
+
                 if (matches_primary and matches_parts >= 2) or \\
-                   (full_command in cmdline_str and not any(python_indicator in cmdline_str.lower() 
+                   (full_command in cmdline_str and not any(python_indicator in cmdline_str.lower()
                                                            for python_indicator in ['python -c', 'import psutil', 'def check_process'])):
                     matching_processes.append({{
                         "pid": proc.info['pid'],
@@ -140,14 +140,14 @@ def check_process():
                     }})
         except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
             continue
-    
+
     return matching_processes
 
 if __name__ == "__main__":
     processes = check_process()
     print(json.dumps(processes))
 """
-    
+
     def force_fresh_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
         """Force a fresh process check with additional validation."""
         if tab_name not in tab_config:
@@ -158,23 +158,23 @@ if __name__ == "__main__":
                 "command": None,
                 "remote": self.remote_executor.remote_name
             }
-        
+
         _, command = tab_config[tab_name]
-        
+
         try:
             # Get timestamp for freshness validation
             timestamp_result = self.remote_executor.run_command("date +%s", timeout=5)
             check_timestamp = timestamp_result.stdout.strip() if timestamp_result.returncode == 0 else "unknown"
-            
+
             check_script = self._create_fresh_check_script(command)
             remote_cmd = f"$HOME/venvs/ve/bin/python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
-            
+
             if result.returncode == 0:
                 try:
                     check_result = json.loads(result.stdout.strip())
                     matching_processes = check_result.get("processes", [])
-                    
+
                     return {
                         "status": "running" if matching_processes else "not_running",
                         "running": bool(matching_processes),
@@ -198,14 +198,14 @@ if __name__ == "__main__":
                     }
             else:
                 return {
-                    "status": "error", 
+                    "status": "error",
                     "error": f"Remote command failed: {result.stderr}",
                     "running": False,
                     "command": command,
                     "tab_name": tab_name,
                     "remote": self.remote_executor.remote_name
                 }
-                
+
         except Exception as e:
             logger.error(f"Error in fresh process check for tab '{tab_name}': {e}")
             return {
@@ -216,11 +216,11 @@ if __name__ == "__main__":
                 "tab_name": tab_name,
                 "remote": self.remote_executor.remote_name
             }
-    
+
     def _create_fresh_check_script(self, command: str) -> str:
         """Create enhanced process checking script with freshness validation."""
         escaped_command = command.replace("'", "\\'").replace('"', '\\"')
-        
+
         return f'''
 import psutil
 import json
@@ -229,40 +229,40 @@ import time
 
 def force_fresh_check():
     time.sleep(0.1)
-    
+
     matching_processes = []
     full_command = '{escaped_command}'
     cmd_parts = [part for part in full_command.split() if len(part) > 2]
     current_pid = os.getpid()
     primary_cmd = cmd_parts[0] if cmd_parts else ''
-    
+
     check_time = time.time()
-    
+
     for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'status', 'create_time']):
         try:
             if proc.info['pid'] == current_pid:
                 continue
-                
+
             if proc.info['cmdline'] and len(proc.info['cmdline']) > 0:
                 cmdline_str = ' '.join(proc.info['cmdline'])
-                
+
                 if any(indicator in cmdline_str for indicator in [
                     'check_process()', 'psutil.process_iter', 'force_fresh_check',
                     'import psutil', 'def check_process'
                 ]):
                     continue
-                
+
                 if proc.info['create_time'] and proc.info['create_time'] > check_time - 5:
                     continue
-                
+
                 matches_primary = primary_cmd in cmdline_str and primary_cmd != 'python'
                 matches_parts = sum(1 for part in cmd_parts[1:] if part in cmdline_str)
-                
+
                 if matches_primary and matches_parts >= 2:
                     script_indicators = ['-c', 'import ', 'def ', 'psutil']
-                    is_direct_command = not any(script_indicator in cmdline_str.lower() 
+                    is_direct_command = not any(script_indicator in cmdline_str.lower()
                                               for script_indicator in script_indicators)
-                    
+
                     if is_direct_command or (full_command in cmdline_str and 'python -c' not in cmdline_str):
                         matching_processes.append({{
                             "pid": proc.info['pid'],
@@ -275,7 +275,7 @@ def force_fresh_check():
                         }})
         except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
             continue
-    
+
     return {{
         "processes": matching_processes,
         "check_timestamp": check_time,
@@ -287,23 +287,23 @@ if __name__ == "__main__":
     result = force_fresh_check()
     print(json.dumps(result))
 '''
-    
+
     def verify_process_alive(self, pid: int) -> bool:
         """Verify if a process with given PID is actually alive."""
         try:
             verify_cmd = f"kill -0 {pid} 2>/dev/null && echo 'alive' || echo 'dead'"
             result = self.remote_executor.run_command(verify_cmd, timeout=5)
-            
+
             if result.returncode == 0:
                 return result.stdout.strip() == 'alive'
             return False
         except Exception:
             return False
-    
+
     def get_verified_process_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
         """Get process status with additional verification that processes are actually alive."""
         status = self.force_fresh_process_check(tab_name, tab_config)
-        
+
         if status.get("running") and status.get("processes"):
             verified_processes = []
             for proc in status["processes"]:
@@ -314,20 +314,20 @@ if __name__ == "__main__":
                 else:
                     proc["verified_alive"] = False
                     logger.warning(f"Process PID {pid} found in process list but not actually alive")
-            
+
             status["processes"] = verified_processes
             status["running"] = bool(verified_processes)
             status["status"] = "running" if verified_processes else "not_running"
             status["verification_method"] = "kill_signal_check"
-        
+
         return status
-    
+
     def check_all_commands_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Dict[str, Any]]:
         """Check status of all commands in the tab configuration."""
         if not tab_config:
             logger.warning("No tab configuration provided.")
             return {}
-        
+
         status_report = {}
         for tab_name in tab_config:
             status_report[tab_name] = self.check_command_status(tab_name, tab_config)

machineconfig/cluster/sessions_managers/zellij_utils/remote_executor.py

@@ -11,10 +11,10 @@ logger = logging.getLogger(__name__)
 
 class RemoteExecutor:
     """Handles SSH command execution on remote machines."""
-    
+
     def __init__(self, remote_name: str):
         self.remote_name = remote_name
-    
+
     def run_command(self, command: str, timeout: int = 30) -> subprocess.CompletedProcess[str]:
         """Execute a command on the remote machine via SSH."""
         ssh_cmd = ["ssh", self.remote_name, command]
@@ -32,7 +32,7 @@ class RemoteExecutor:
         except Exception as e:
             logger.error(f"SSH command failed: {e}")
             raise
-    
+
     def copy_file_to_remote(self, local_file: str, remote_path: str) -> Dict[str, Any]:
         """Copy a file to the remote machine using SCP."""
         scp_cmd = ["scp", local_file, f"{self.remote_name}:{remote_path}"]
@@ -47,7 +47,7 @@ class RemoteExecutor:
         except Exception as e:
             logger.error(f"SCP operation failed: {e}")
             return {"success": False, "error": str(e)}
-    
+
     def create_remote_directory(self, remote_dir: str) -> bool:
         """Create a directory on the remote machine."""
         try:
@@ -56,7 +56,7 @@ class RemoteExecutor:
         except Exception as e:
             logger.error(f"Failed to create remote directory {remote_dir}: {e}")
             return False
-    
+
     def attach_to_session_interactive(self, session_name: str) -> None:
         """Attach to a Zellij session interactively via SSH."""
         try:

machineconfig/cluster/sessions_managers/zellij_utils/session_manager.py

@@ -16,39 +16,39 @@ console = Console()
 
 class SessionManager:
     """Handles Zellij session operations on remote machines."""
-    
+
     def __init__(self, remote_executor: RemoteExecutor, session_name: str, tmp_layout_dir: Path):
         self.remote_executor = remote_executor
         self.session_name = session_name
         self.tmp_layout_dir = tmp_layout_dir
-    
+
     def copy_layout_to_remote(self, local_layout_file: Path, random_suffix: str) -> str:
         """Copy the layout file to the remote machine and return the remote path."""
         remote_layout_dir = f"~/{self.tmp_layout_dir.relative_to(Path.home())}"
         remote_layout_file = f"{remote_layout_dir}/zellij_layout_{self.session_name}_{random_suffix}.kdl"
-        
+
         # Create remote directory
         if not self.remote_executor.create_remote_directory(remote_layout_dir):
             raise RuntimeError(f"Failed to create remote directory: {remote_layout_dir}")
-        
+
         # Copy layout file to remote machine
         copy_result = self.remote_executor.copy_file_to_remote(str(local_layout_file), remote_layout_file)
         if not copy_result["success"]:
             raise RuntimeError(f"Failed to copy layout file to remote: {copy_result['error']}")
-        
+
         # Enhanced Rich logging
         console.print(f"[bold green]📁 Zellij layout file copied to remote:[/bold green] [yellow]{self.remote_executor.remote_name}[/yellow][cyan]:{remote_layout_file}[/cyan]")
         return remote_layout_file
-    
+
     def check_zellij_session_status(self) -> Dict[str, Any]:
         """Check if the Zellij session exists and is running."""
         try:
             result = self.remote_executor.run_command('zellij list-sessions', timeout=10)
-            
+
             if result.returncode == 0:
                 sessions = result.stdout.strip().split('\n') if result.stdout.strip() else []
                 session_running = any(self.session_name in session for session in sessions)
-                
+
                 return {
                     "zellij_running": True,
                     "session_exists": session_running,
@@ -63,7 +63,7 @@ class SessionManager:
                     "session_name": self.session_name,
                     "remote": self.remote_executor.remote_name
                 }
-                
+
         except Exception as e:
             return {
                 "zellij_running": False,
@@ -71,7 +71,7 @@ class SessionManager:
                 "session_name": self.session_name,
                 "remote": self.remote_executor.remote_name
             }
-    
+
     def start_zellij_session(self, layout_file_path: Optional[str] = None) -> Dict[str, Any]:
         """Start a Zellij session on the remote machine with the generated layout."""
         try:
@@ -80,15 +80,15 @@ class SessionManager:
                 remote_layout_file = f"~/{self.tmp_layout_dir.relative_to(Path.home())}/{layout_filename}"
             else:
                 raise ValueError("No layout file path provided.")
-            
+
             # Enhanced Rich logging for session start
             console.print(f"[bold cyan]🚀 Starting Zellij session[/bold cyan] [yellow]'{self.session_name}'[/yellow] [dim]on remote[/dim] [bold yellow]'{self.remote_executor.remote_name}'[/bold yellow] [dim]with layout:[/dim] [blue]{remote_layout_file}[/blue]")
-            
+
             # Start Zellij session with layout
             start_cmd = f"zellij --layout {remote_layout_file} a -b {self.session_name}"
             console.print(f"[dim]Executing:[/dim] [green]{start_cmd}[/green]")
             result = self.remote_executor.run_command(start_cmd, timeout=30)
-            
+
             if result.returncode == 0:
                 console.print(f"[bold green]✅ Zellij session[/bold green] [yellow]'{self.session_name}'[/yellow] [green]started successfully on[/green] [bold yellow]{self.remote_executor.remote_name}[/bold yellow]")
                 return {
@@ -104,7 +104,7 @@ class SessionManager:
                     "session_name": self.session_name,
                     "remote": self.remote_executor.remote_name
                 }
-                
+
         except Exception as e:
             logger.error(f"Failed to start Zellij session on {self.remote_executor.remote_name}: {e}")
             return {
@@ -113,7 +113,7 @@ class SessionManager:
                 "session_name": self.session_name,
                 "remote": self.remote_executor.remote_name
             }
-    
+
     def attach_to_session(self) -> None:
         """Attach to the Zellij session on the remote machine via SSH."""
         self.remote_executor.attach_to_session_interactive(self.session_name)

machineconfig/cluster/sessions_managers/zellij_utils/status_reporter.py

@@ -12,19 +12,19 @@ logger = logging.getLogger(__name__)
 
 class StatusReporter:
     """Handles comprehensive status reporting for Zellij remote sessions."""
-    
+
     def __init__(self, process_monitor: ProcessMonitor, session_manager: SessionManager):
         self.process_monitor = process_monitor
         self.session_manager = session_manager
-    
+
     def get_comprehensive_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
         """Get comprehensive status including Zellij session and all commands."""
         zellij_status = self.session_manager.check_zellij_session_status()
         commands_status = self.process_monitor.check_all_commands_status(tab_config)
-        
+
         running_count = sum(1 for status in commands_status.values() if status.get("running", False))
         total_count = len(commands_status)
-        
+
         return {
             "zellij_session": zellij_status,
             "commands": commands_status,
@@ -36,17 +36,17 @@ class StatusReporter:
                 "remote": self.session_manager.remote_executor.remote_name
             }
         }
-    
+
     def print_status_report(self, tab_config: Dict[str, Tuple[str, str]]) -> None:
         """Print a formatted status report to console."""
         status = self.get_comprehensive_status(tab_config)
         remote_name = self.session_manager.remote_executor.remote_name
         session_name = self.session_manager.session_name
-        
+
         print("=" * 60)
         print(f"🔍 ZELLIJ REMOTE LAYOUT STATUS REPORT ({remote_name})")
         print("=" * 60)
-        
+
         # Zellij session status
         zellij = status["zellij_session"]
         if zellij.get("zellij_running", False):
@@ -56,13 +56,13 @@ class StatusReporter:
                 print(f"⚠️  Zellij is running on {remote_name} but session '{session_name}' not found")
         else:
             print(f"❌ Zellij session issue on {remote_name}: {zellij.get('error', 'Unknown error')}")
-        
+
         print()
-        
+
         # Commands status
         print("📋 COMMAND STATUS:")
         print("-" * 40)
-        
+
         for tab_name, cmd_status in status["commands"].items():
             if cmd_status.get("running", False):
                 print(f"✅ {tab_name}: Running on {remote_name}")
@@ -73,7 +73,7 @@ class StatusReporter:
                 print(f"❌ {tab_name}: Not running on {remote_name}")
             print(f"   Command: {cmd_status.get('command', 'Unknown')}")
             print()
-        
+
         # Summary
         summary = status["summary"]
         print("📊 SUMMARY:")

machineconfig/cluster/templates/utils.py

@@ -8,7 +8,7 @@
 
 # from machineconfig.cluster.remote_machine import WorkloadParams
 from typing import Optional
-from crocodile.file_management import P, PLike
+from machineconfig.utils.path_reduced import P, PLike
 
 # def expensive_function(workload_params: WorkloadParams, sim_dict: Optional[dict[str, Any]] = None) -> P:
 #     import time
@@ -40,7 +40,7 @@ from crocodile.file_management import P, PLike
 
 def to_cloud(localpath: PLike, cloud: str, remotepath: Optional[PLike], zip: bool = False, encrypt: bool = False,
                 key: Optional[bytes] = None, pwd: Optional[str] = None, rel2home: bool = False, strict: bool = True,
-                obfuscate: bool = False,
+                # obfuscate: bool = False,
                 share: bool = False, verbose: bool = True, os_specific: bool = False, transfers: int = 10, root: Optional[str] = "myhome") -> 'P':
     to_del = []
     localpath = P(localpath).expanduser().absolute() if not P(localpath).exists() else P(localpath)
@@ -51,7 +51,7 @@ def to_cloud(localpath: PLike, cloud: str, remotepath: Optional[PLike], zip: boo
         localpath = localpath.encrypt(key=key, pwd=pwd, inplace=False)
         to_del.append(localpath)
     if remotepath is None:
-        rp = localpath.get_remote_path(root=root, os_specific=os_specific, rel2home=rel2home, strict=strict, obfuscate=obfuscate)  # if rel2home else (P(root) / localpath if root is not None else localpath)
+        rp = localpath.get_remote_path(root=root, os_specific=os_specific, rel2home=rel2home, strict=strict)  # if rel2home else (P(root) / localpath if root is not None else localpath)
     else: rp = P(remotepath)
 
     from rclone_python import rclone

machineconfig/jobs/python/check_installations.py

@@ -24,7 +24,7 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 
 # def scan(path: P, pct: float = 0.0):
 #     import vt  # vt-py
-#     client = vt.Client(PathExtended.home().joinpath("dotfiles/creds/tokens/virustotal").read_text().split("\n")[0])
+#     client = vt.Client(PathExtended.home().joinpath("dotfiles/creds/tokens/virustotal").read_text(encoding="utf-8").split("\n")[0])
 #     console = Console()
 #     console.rule(f"Scanning {path}. {pct:.2f}% done")
 #     if path.is_dir():
@@ -44,7 +44,7 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #                     raise ValueError(f"❌ Error in scanning {path}") from ex
 #                 print("⚠️  Error in scanning, trying again...")
 #             time.sleep(30)
-    
+
 #     # Convert results to list of dictionaries
 #     results_data = list(anal.results.values())
 #     malicious = []
@@ -58,13 +58,13 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #                 'result': getattr(result_item, 'result', None),
 #                 'category': getattr(result_item, 'category', 'unknown')
 #             }
-        
-#         if result_dict.get('result') is None and result_dict.get('category') in ["undetected", "type-unsupported", "failure", "timeout", "confirmed-timeout"]: 
+
+#         if result_dict.get('result') is None and result_dict.get('category') in ["undetected", "type-unsupported", "failure", "timeout", "confirmed-timeout"]:
 #             continue
 #         else:
 #             pprint(result_dict, f"🔍 Found Category {result_dict.get('category')}")
 #             malicious.append(result_item)
-    
+
 #     positive_pct: float = round(number=len(malicious) / len(results_data) * 100, ndigits=1)
 #     print(f"""
 # {'=' * 50}
@@ -101,10 +101,9 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #     for an_app in apps_paths_tmp:
 #         version_path = [x for x in versions_files_paths if x.stem == an_app.stem]
 #         if len(version_path) == 1:
-#             app_versions.append(version_path[0].read_text())
+#             app_versions.append(version_path[0].read_text(encoding="utf-8"))
 #             apps_paths_raw.append(an_app)
 #         # if an_app.stem in versions_files_paths.stem:
-#         #     app_versions.append(versions_files_paths.filter(lambda x: x.stem == an_app.stem.replace(".exe", "")).list[0].read_text())
 #         # else:
 #         #     print(f"🤔 Cloud not find a documented version for installation of {an_app.stem}, trying to get it from the app itself.")
 #         #     tmp = Terminal().run(f"{an_app.stem} --version", shell="powershell").capture().op_if_successfull_or_default(strict_err=False, strict_returcode=False)
@@ -176,8 +175,8 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #         return "\n".join([header, separator] + rows)
 
 #     markdown_content = format_app_table_markdown(app_data)
-#     APP_SUMMARY_PATH.with_suffix(".md").write_text(markdown_content)
-    
+#     APP_SUMMARY_PATH.with_suffix(".md").write_text(markdown_content, encoding="utf-8")
+
 #     print(f"""
 # {'=' * 150}
 # 📊 SAFETY REPORT | Summary of app scanning results

machineconfig/jobs/python/python_cargo_build_share.py

@@ -2,7 +2,7 @@
 cargo install
 """
 
-# from crocodile.meta import Terminal
+# from machineconfig.utils.terminal import Terminal
 # from machineconfig.utils.path_reduced import P as PathExtended
 # import platform
 
@@ -27,7 +27,7 @@ cargo install
 # {'=' * 150}
 # """)
 #     if platform.system() == "Windows":
-#         Terminal(stdout=None).run(f". {PathExtended.tmpfile(suffix='.ps1').write_text(script)}", shell="pwsh").print()
+#         Terminal(stdout=None).run(f". {PathExtended.tmpfile(suffix='.ps1').write_text(script, encoding="utf-8")}", shell="pwsh").print()
 #     else:
 #         Terminal(stdout=None).run(script, shell="pwsh")
 

machineconfig/jobs/python/vscode/link_ve.py

@@ -15,9 +15,9 @@ def select_interpreter(workspace_root: str):
 📂 Workspace: {workspace_root}
 {'=' * 150}
 """)
-    
+
     path = Path(workspace_root).joinpath('.ve_path')
-    
+
     if not path.exists():
         print(f"""
 {'⚠️' * 20}
@@ -26,12 +26,12 @@ def select_interpreter(workspace_root: str):
 {'⚠️' * 20}
 """)
         return
-    
+
     with open(path, 'r', encoding='utf-8') as f:
         ve_path = Path(f.read().strip()).expanduser()
-    
+
     venv_link = Path(workspace_root).joinpath(".venv")
-    
+
     if venv_link.exists() and not venv_link.is_symlink():
         print(f"""
 {'⚠️' * 20}
@@ -40,9 +40,9 @@ def select_interpreter(workspace_root: str):
 {'⚠️' * 20}
 """)
         return
-    
+
     venv_link.symlink_to(target=ve_path.expanduser().absolute())
-    
+
     print(f"""
 {'=' * 150}
 ✅ SUCCESS | Virtual environment linked successfully