machineconfig 1.92__py3-none-any.whl → 1.94__py3-none-any.whl

machineconfig/utils/installer_utils/installer_class.py

@@ -0,0 +1,253 @@
+from crocodile.core import Struct
+from crocodile.file_management import P, Read
+from crocodile.meta import Terminal
+from machineconfig.utils.installer_utils.installer_abc import find_move_delete_linux, find_move_delete_windows
+from machineconfig.utils.utils import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT, LIBRARY_ROOT, check_tool_exists
+
+
+import platform
+from typing import Any, Optional
+
+
+class Installer:
+    def __init__(self, repo_url: str, name: str, doc: str, filename_template_windows_amd_64: str, filename_template_linux_amd_64: str,
+                 strip_v: bool, exe_name: str):
+        self.repo_url: str=repo_url
+        self.name: str=name
+        self.doc: str=doc
+        self.filename_template_windows_amd_64: str=filename_template_windows_amd_64
+        self.filename_template_linux_amd_64: str=filename_template_linux_amd_64
+        self.strip_v: bool=strip_v
+        self.exe_name: str=exe_name
+    def __repr__(self) -> str: return f"Installer of {self.repo_url}"
+    def get_description(self):
+        # old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
+        # old_version_cli = os.system(f"{self.exe_name} --version").replace("\n", "")
+        old_version_cli: bool=check_tool_exists(tool_name=self.exe_name)
+        old_version_cli_str = "✅" if old_version_cli else "❌"
+        # name_version = f"{self.exe_name} {old_version_cli_str}"
+        return f"{self.exe_name:<12} {old_version_cli_str} {self.doc}"
+    def to_dict(self): return self.__dict__
+    @staticmethod
+    def from_dict(d: dict[str, Any], name: str):
+        try: return Installer(name=name, **d)
+        except Exception as ex:
+            Struct(d).print(as_config=True)
+            raise ex
+    @staticmethod
+    def choose_app_and_install():
+        print(f"\n{'='*80}\n🔍 SELECT APPLICATION TO INSTALL 🔍\n{'='*80}")
+        from machineconfig.utils.utils import choose_one_option
+        print("📂 Searching for configuration files...")
+        path = choose_one_option(options=LIBRARY_ROOT.joinpath("jobs").search("config.json", r=True).list)
+        print(f"📄 Loading configuration from: {path}")
+        config: dict[str, Any] = Read.json(path)  # /python_generic_installers/config.json"))
+        print("🔍 Select an application to install:")
+        app_name = choose_one_option(options=list(config.keys()), fzf=True)
+        # for keys, dict_ in config.items():
+        installer = Installer.from_dict(d=config[app_name], name=app_name)
+        print(f"📦 Selected application: {installer.exe_name}")
+        version = input(f"📝 Enter version to install for {installer.exe_name} [latest]: ") or None
+        print(f"\n{'='*80}\n🚀 INSTALLING {installer.exe_name.upper()} 🚀\n{'='*80}")
+        installer.install(version=version)
+
+    def install_robust(self, version: Optional[str]):
+        try:
+            print(f"\n{'='*80}\n🚀 INSTALLING {self.exe_name.upper()} 🚀\n{'='*80}")
+            old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
+            print(f"📊 Current version: {old_version_cli or 'Not installed'}")
+
+            self.install(version=version)
+
+            new_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
+            print(f"📊 New version: {new_version_cli}")
+
+            if old_version_cli == new_version_cli:
+                print(f"ℹ️  Same version detected: {old_version_cli}")
+                return f"""echo "📦️ 😑 {self.exe_name}, same version: {old_version_cli}" """
+            else:
+                print(f"🚀 Update successful: {old_version_cli} ➡️ {new_version_cli}")
+                return f"""echo "📦️ 🤩 {self.exe_name} updated from {old_version_cli} ➡️ TO ➡️  {new_version_cli}" """
+
+        except Exception as ex:
+            print(f"❌ ERROR: Installation failed for {self.exe_name}: {ex}")
+            return f"""echo "📦️ ❌ Failed to install `{self.name}` with error: {ex}" """
+
+    def install(self, version: Optional[str]):
+        print(f"\n{'='*80}\n🔧 INSTALLATION PROCESS: {self.exe_name} 🔧\n{'='*80}")
+        if self.repo_url == "CUSTOM":
+            print(f"🧩 Using custom installer for {self.exe_name}")
+            import machineconfig.jobs.python_custom_installers as python_custom_installers
+            installer_path = P(python_custom_installers.__file__).parent.joinpath(self.exe_name + ".py")
+            if not installer_path.exists():
+                installer_path = P(python_custom_installers.__file__).parent.joinpath("dev", self.exe_name + ".py")
+                print(f"🔍 Looking for installer in dev folder: {installer_path}")
+            else:
+                print(f"🔍 Found installer at: {installer_path}")
+
+            import runpy
+            print(f"⚙️  Executing function 'main' from '{installer_path}'...")
+            program: str = runpy.run_path(str(installer_path), run_name=None)['main'](version=version)
+            # print(program)
+            print("🚀 Running installation script...")
+            Terminal(stdin=None, stdout=None, stderr=None).run_script(script=program, shell="default").print(desc="Running custom installer", capture=True)
+            # import subprocess
+            # subprocess.run(program, shell=True, check=True)
+            version_to_be_installed = str(version)
+            print(f"✅ Custom installation completed\n{'='*80}")
+
+        elif "npm " in self.repo_url or "pip " in self.repo_url or "winget " in self.repo_url:
+            package_manager = self.repo_url.split(" ", maxsplit=1)[0]
+            print(f"📦 Using package manager: {package_manager}")
+            desc = package_manager + " installation"
+            version_to_be_installed = package_manager + "Latest"
+            print(f"🚀 Running: {self.repo_url}")
+            Terminal().run(self.repo_url, shell="default").capture().print_if_unsuccessful(desc=desc, strict_err=True, strict_returncode=True)
+            print(f"✅ Package manager installation completed\n{'='*80}")
+
+        else:
+            print("📥 Downloading from repository...")
+            downloaded, version_to_be_installed = self.download(version=version)
+            if downloaded.to_str().endswith(".deb"):
+                print(f"📦 Installing .deb package: {downloaded}")
+                assert platform.system() == "Linux"
+                Terminal().run(f"sudo nala install -y {downloaded}").capture().print_if_unsuccessful(desc="Installing .deb", strict_err=True, strict_returncode=True)
+                print("🗑️  Cleaning up .deb package...")
+                downloaded.delete(sure=True)
+                print(f"✅ DEB package installation completed\n{'='*80}")
+            else:
+                if platform.system() == "Windows":
+                    print("🪟 Installing on Windows...")
+                    exe = find_move_delete_windows(downloaded_file_path=downloaded, exe_name=self.exe_name, delete=True, rename_to=self.exe_name.replace(".exe", "") + ".exe")
+                elif platform.system() == "Linux":
+                    print("🐧 Installing on Linux...")
+                    exe = find_move_delete_linux(downloaded=downloaded, tool_name=self.exe_name, delete=True, rename_to=self.exe_name)
+                else:
+                    error_msg = f"❌ ERROR: System {platform.system()} not supported"
+                    print(error_msg)
+                    raise NotImplementedError(error_msg)
+
+                _ = exe
+                if exe.name.replace(".exe", "") != self.exe_name.replace(".exe", ""):
+                    from rich import print as pprint
+                    from rich.panel import Panel
+                    print("⚠️  Warning: Executable name mismatch")
+                    pprint(Panel(f"Expected exe name: [red]{self.exe_name}[/red] \nAttained name: [red]{exe.name.replace('.exe', '')}[/red]", title="exe name mismatch", subtitle=self.repo_url))
+                    new_exe_name = self.exe_name + ".exe" if platform.system() == "Windows" else self.exe_name
+                    print(f"🔄 Renaming to correct name: {new_exe_name}")
+                    exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
+
+        print(f"💾 Saving version information to: {INSTALL_VERSION_ROOT.joinpath(self.exe_name)}")
+        INSTALL_VERSION_ROOT.joinpath(self.exe_name).create(parents_only=True).write_text(version_to_be_installed)
+        print(f"✅ Installation completed successfully!\n{'='*80}")
+
+    def download(self, version: Optional[str]):
+        print(f"\n{'='*80}\n📥 DOWNLOADING: {self.exe_name} 📥\n{'='*80}")
+        if "github" not in self.repo_url or ".zip" in self.repo_url or ".tar.gz" in self.repo_url:
+            download_link = P(self.repo_url)
+            version_to_be_installed = "predefined_url"
+            print(f"🔗 Using direct download URL: {download_link}")
+            print(f"📦 Version to be installed: {version_to_be_installed}")
+
+        elif "http" in self.filename_template_linux_amd_64 or "http" in self.filename_template_windows_amd_64:
+            if platform.system() == "Windows":
+                download_link = P(self.filename_template_windows_amd_64)
+                print(f"🪟 Using Windows-specific download URL: {download_link}")
+            elif platform.system() == "Linux":
+                download_link = P(self.filename_template_linux_amd_64)
+                print(f"🐧 Using Linux-specific download URL: {download_link}")
+            else:
+                error_msg = f"❌ ERROR: System {platform.system()} not supported"
+                print(error_msg)
+                raise NotImplementedError(error_msg)
+
+            version_to_be_installed = "predefined_url"
+
+        else:
+            print("🌐 Retrieving release information from GitHub...")
+            release_url, version_to_be_installed = Installer.get_github_release(repo_url=self.repo_url, version=version)
+            print(f"📦 Version to be installed: {version_to_be_installed}")
+            print(f"📦 Release URL: {release_url}")
+
+            version_to_be_installed_stripped = version_to_be_installed.replace("v", "") if self.strip_v else version_to_be_installed
+            version_to_be_installed_stripped = version_to_be_installed_stripped.replace("ipinfo-", "")
+
+            if platform.system() == "Windows":
+                file_name = self.filename_template_windows_amd_64.format(version_to_be_installed_stripped)
+                print(f"🪟 Windows file name: {file_name}")
+            elif platform.system() == "Linux":
+                file_name = self.filename_template_linux_amd_64.format(version_to_be_installed_stripped)
+                print(f"🐧 Linux file name: {file_name}")
+            else:
+                error_msg = f"❌ ERROR: System {platform.system()} not supported"
+                print(error_msg)
+                raise NotImplementedError(error_msg)
+
+            print(f"📄 File name: {file_name}")
+            download_link = release_url.joinpath(file_name)
+
+        print(f"📥 Downloading {self.name} from: {download_link.as_url_str()}")
+        downloaded = download_link.download(folder=INSTALL_TMP_DIR).decompress()
+        print(f"✅ Download and extraction completed to: {downloaded}\n{'='*80}")
+        return downloaded, version_to_be_installed
+
+    @staticmethod
+    def get_github_release(repo_url: str, version: Optional[str] = None):
+        print(f"\n{'='*80}\n🔍 GITHUB RELEASE DETECTION 🔍\n{'='*80}")
+        print(f"🌐 Inspecting releases at: {repo_url}")
+        # with console.status("Installing..."):  # makes troubles on linux when prompt asks for password to move file to /usr/bin
+        if version is None:
+            # see this: https://api.github.com/repos/cointop-sh/cointop/releases/latest
+            print("🔍 Finding latest version...")
+            import requests  # https://docs.github.com/en/repositories/releasing-projects-on-github/linking-to-releases
+            _latest_version = requests.get(str(repo_url) + "/releases/latest", timeout=10).url.split("/")[-1]  # this is to resolve the redirection that occures: https://stackoverflow.com/questions/36070821/how-to-get-redirect-url-using-python-requests
+            version_to_be_installed = _latest_version
+            print(f"✅ Latest version detected: {version_to_be_installed}")
+            # print(version_to_be_installed)
+        else:
+            version_to_be_installed = version
+            print(f"📝 Using specified version: {version_to_be_installed}")
+
+        release_url = P(repo_url + "/releases/download/" + version_to_be_installed)
+        print(f"🔗 Release download URL: {release_url}\n{'='*80}")
+        return release_url, version_to_be_installed
+
+    @staticmethod
+    def check_if_installed_already(exe_name: str, version: str, use_cache: bool):
+        print(f"\n{'='*80}\n🔍 CHECKING INSTALLATION STATUS: {exe_name} 🔍\n{'='*80}")
+        version_to_be_installed = version
+        tmp_path = INSTALL_VERSION_ROOT.joinpath(exe_name).create(parents_only=True)
+
+        if use_cache:
+            print("🗂️  Using cached version information...")
+            if tmp_path.exists():
+                existing_version = tmp_path.read_text().rstrip()
+                print(f"📄 Found cached version: {existing_version}")
+            else:
+                existing_version = None
+                print("ℹ️  No cached version information found")
+        else:
+            print("🔍 Checking installed version directly...")
+            resp = Terminal().run(exe_name, "--version", check=False).capture()
+            if resp.op == '':
+                existing_version = None
+                print("ℹ️  Could not detect installed version")
+            else:
+                existing_version = resp.op.strip()
+                print(f"📄 Detected installed version: {existing_version}")
+
+        if existing_version is not None:
+            if existing_version == version_to_be_installed:
+                print(f"✅ {exe_name} is up to date (version {version_to_be_installed})")
+                print(f"📂 Version information stored at: {INSTALL_VERSION_ROOT}")
+                return ("✅ Uptodate", version.strip(), version_to_be_installed.strip())
+            else:
+                print(f"🔄 {exe_name} needs update: {existing_version.rstrip()} → {version_to_be_installed}")
+                tmp_path.write_text(version_to_be_installed)
+                return ("❌ Outdated", existing_version.strip(), version_to_be_installed.strip())
+        else:
+            print(f"📦 {exe_name} is not installed. Will install version: {version_to_be_installed}")
+            tmp_path.write_text(version_to_be_installed)
+
+        print(f"{'='*80}")
+        return ("⚠️ NotInstalled", "None", version_to_be_installed.strip())

machineconfig/utils/procs.py

@@ -1,4 +1,3 @@
-
 """Procs
 """
 import psutil
@@ -12,8 +11,13 @@ pd.options.display.max_rows = 10000
 
 
 def get_processes_accessing_file(path: str):
+    print(f"""
+╔{'═'*78}╗
+║ 🔍  SEARCHING FOR PROCESSES ACCESSING FILE                                     ║
+╚{'═'*78}╝
+""")
     res: dict[int, list[str]] = {}
-    for proc in tqdm(psutil.process_iter()):
+    for proc in tqdm(psutil.process_iter(), desc="🔎 Scanning processes"):
         try:
             files = proc.open_files()
         except psutil.AccessDenied:
@@ -22,19 +26,32 @@ def get_processes_accessing_file(path: str):
         if len(tmp) > 0:
             res[proc.pid] = tmp
     df = pd.DataFrame(res.items(), columns=['pid', 'files'])
+    print(f"\n✅ Found {len(res)} processes accessing the specified file\n{'─'*80}\n")
     return df
 
 
 def kill_process(name: str):
+    print(f"⚠️  Attempting to kill process: {name}...")
+    killed = False
     for proc in psutil.process_iter():
         if proc.name() == name:
             proc.kill()
+            print(f"💀 Process {name} (PID: {proc.pid}) terminated successfully")
+            killed = True
+    if not killed:
+        print(f"❓ No process with name '{name}' was found")
+    print(f"{'─'*80}\n")
 
 
 class ProcessManager:
     def __init__(self):
+        print(f"""
+╔{'═'*78}╗
+║ 📊  INITIALIZING PROCESS MANAGER                                               ║
+╚{'═'*78}╝
+""")
         process_info = []
-        for proc in tqdm(psutil.process_iter(), desc="Reading Processes"):
+        for proc in tqdm(psutil.process_iter(), desc="🔍 Reading system processes"):
             try:
                 mem_usage_mb = proc.memory_info().rss / (1024 * 1024)
                 process_info.append([proc.pid, proc.name(), proc.username(), proc.cpu_percent(), mem_usage_mb, proc.status(), proc.create_time(), " ".join(proc.cmdline())])
@@ -44,61 +61,97 @@ class ProcessManager:
         df['create_time'] = pd.to_datetime(df['create_time'], unit='s', utc=True).apply(lambda x: x.tz_convert(timezone('Australia/Adelaide')))
         df = df.sort_values(by='memory_usage_mb', ascending=False).reset_index(drop=True)
         self.df = df
+        print(f"✅ Process Manager initialized with {len(df)} processes\n{'─'*80}\n")
 
     def choose_and_kill(self):
+        print(f"""
+╔{'═'*78}╗
+║ 🎯  INTERACTIVE PROCESS SELECTION AND TERMINATION                              ║
+╚{'═'*78}╝
+""")
         options = str(self.df).split("\n")[1:]
-        res = display_options(options=str(self.df).split("\n"), msg="", fzf=True, multi=True)
+        res = display_options(options=str(self.df).split("\n"), msg="📋 Select processes to manage:", fzf=True, multi=True)
         indices = [options.index(val) for val in res]
         sub_df = self.df.iloc[indices]
+        print("\n📊 All Processes:")
         print(self.df)
+        print("\n🎯 Selected Processes:")
         print(sub_df)
         from crocodile.core import Struct
         for idx, (_, row) in enumerate(sub_df.iterrows()):
-            Struct(row.to_dict()).print(as_config=True, title=f"Process {idx}")
-        kill_all = input("🔪 Confirm killing ALL? y/[n] ").lower() == "y"
+            Struct(row.to_dict()).print(as_config=True, title=f"📌 Process {idx}")
+        kill_all = input("\n⚠️  Confirm killing ALL selected processes? y/[n] ").lower() == "y"
         if kill_all:
             self.kill(pids=sub_df.pid.to_list())
             return
-        kill_by_index = input("🔫 Kill by index? 1 4 ... /[n] ")
+        kill_by_index = input("\n🔫 Kill by index? (enter numbers separated by spaces, e.g. '1 4') or [n] to cancel: ")
         if kill_by_index != "" and kill_by_index != "n":
             indices = [int(val) for val in kill_by_index.split(" ")]
             sub_sub_df = sub_df.iloc[indices]
             for idx2, row in sub_sub_df.iterrows():
-                Struct(row.to_dict()).print(as_config=True, title=f"Process {idx2}")
-            _ = self.kill(pids=sub_sub_df.pid.to_list()) if input("Confirm kill? y/[n] ").lower() == "y" else None
-        print("🫠🐔 Not killing any process.")
+                Struct(row.to_dict()).print(as_config=True, title=f"🎯 Target Process {idx2}")
+            _ = self.kill(pids=sub_sub_df.pid.to_list()) if input("\n⚠️  Confirm termination? y/[n] ").lower() == "y" else None
+        print(f"\n🔔 No processes were terminated.\n{'─'*80}\n")
 
     def filter_and_kill(self, name: Optional[str] = None):
+        print(f"""
+╔{'═'*78}╗
+║ 🔍  FILTERING AND TERMINATING PROCESSES BY NAME                                ║
+╚{'═'*78}╝
+""")
         _ = 20
         df_sub = self.df.query(f"name == '{name}' ").sort_values(by='create_time', ascending=True)
+        print(f"🎯 Found {len(df_sub)} processes matching name: '{name}'")
         self.kill(pids=df_sub.pid.to_list())
+        print(f"{'─'*80}\n")
 
     def kill(self, names: Optional[list[str]] = None, pids: Optional[list[int]] = None, commands: Optional[list[str]] = None):
+        print(f"""
+╔{'═'*78}╗
+║ 💀  PROCESS TERMINATION                                                        ║
+╚{'═'*78}╝
+""")
         if names is None and pids is None and commands is None:
+            print("❌ Error: No termination targets specified (names, pids, or commands)")
             raise ValueError('names, pids and commands cannot all be None')
         if names is None: names = []
         if pids is None: pids = []
         if commands is None: commands = []
+        
+        killed_count = 0
+        
         for name in names:
             rows = self.df[self.df['name'] == name]
             if len(rows) > 0:
                 for _idx, a_row in rows.iterrows():
                     psutil.Process(a_row.pid).kill()
-                    print(f'💀 Killed process {name} with pid {a_row.pid}. It lived {get_age(a_row.create_time)}. RIP 🪦💐')
-            else: print(f'No process named {name} found')
+                    print(f'💀 Killed process {name} with PID {a_row.pid}. It lived {get_age(a_row.create_time)}. RIP 🪦💐')
+                    killed_count += 1
+            else: 
+                print(f'❓ No process named "{name}" found')
+        
         for pid in pids:
             try:
                 proc = psutil.Process(pid)
+                proc_name = proc.name()
+                proc_lifetime = get_age(proc.create_time())
                 proc.kill()
-                print(f'💀 Killed process with pid {pid} and name {proc.name()}.  It lived {get_age(proc.create_time())}. RIP 🪦💐')
-            except psutil.NoSuchProcess: print(f'No process with pid {pid} found')
+                print(f'💀 Killed process with PID {pid} and name "{proc_name}". It lived {proc_lifetime}. RIP 🪦💐')
+                killed_count += 1
+            except psutil.NoSuchProcess: 
+                print(f'❓ No process with PID {pid} found')
+        
         for command in commands:
             rows = self.df[self.df['command'].to_str().contains(command)]
             if len(rows) > 0:
                 for _idx, a_row in rows.iterrows():
                     psutil.Process(a_row.pid).kill()
-                    print(f'💀 Killed process with `{command}` in its command & pid = {a_row.pid}. It lived {get_age(a_row.create_time)}. RIP 🪦💐')
-            else: print(f'No process has `{command}` in its command.')
+                    print(f'💀 Killed process with "{command}" in its command & PID {a_row.pid}. It lived {get_age(a_row.create_time)}. RIP 🪦💐')
+                    killed_count += 1
+            else: 
+                print(f'❓ No process has "{command}" in its command.')
+        
+        print(f"\n✅ Termination complete: {killed_count} processes terminated\n{'─'*80}\n")
 
 
 def get_age(create_time: float):

machineconfig/utils/scheduling.py

@@ -1,5 +1,3 @@
-
-
 """Task scheduler
 """
 
@@ -113,7 +111,13 @@ def main(root: Optional[str] = None, ignore_conditions: bool=True):
     else: root_resolved = P(root).expanduser().absolute()
     tasks_dirs = root_resolved.search(files=False, folders=True).filter(lambda x: x.joinpath("task.py").exists())
 
-    print(root_resolved)
+    print(f"""
+╔{'═'*78}╗
+║ 📂  TASK SCHEDULER INITIALIZED                                                ║
+╚{'═'*78}╝
+""")
+    print(f"📁 Root directory resolved: {root_resolved}")
+
     tasks: list[Task] = []
     for a_dir in tasks_dirs:
         tasks.append(read_task_from_dir(a_dir))
@@ -121,9 +125,14 @@ def main(root: Optional[str] = None, ignore_conditions: bool=True):
     from machineconfig.utils.utils import choose_multiple_options
     import pandas as pd
     df_res = pd.DataFrame([Report.from_path(path=a_task.report_path).__dict__ for a_task in tasks])
-    tasks_chosen_raw = choose_multiple_options(df_res.to_markdown().splitlines(), "Choose tasks to run")
+    tasks_chosen_raw = choose_multiple_options(df_res.to_markdown().splitlines(), "📋 Choose tasks to run")
     tasks_chosen = [tasks[int(a_task_chosen.split("|")[1])] for a_task_chosen in tasks_chosen_raw]
 
+    print(f"""
+🎯 Selected Tasks:
+{df_res}
+""")
+
     result: list[Report] = []
     for a_task in tasks_chosen:
         if not ignore_conditions:
@@ -136,23 +145,33 @@ def main(root: Optional[str] = None, ignore_conditions: bool=True):
         result.append(report)
 
     df_res = pd.DataFrame([r.__dict__ for r in result])
-    print(df_res)
-    # root_resolved.joinpath("task_report.md").write_text(df_res.to_markdown(), encoding="utf-8")
+    print(f"""
+✅ Task Execution Results:
+{df_res}
+""")
     return ""
 
 
 def should_task_run(task: Task, tolerance_mins: int = 1440) -> tuple[bool, Optional[Report]]:
     if not task.report_path.exists():
-        print(f"Task {task.name} has no record of being run before, running now...")
+        print(f"""
+⚠️  Task {task.name} has no record of being run before. Running now...
+""")
         return True, None
     old_report = Report.from_path(task.report_path)
     time_since_execution = datetime.now() - old_report.end
     if time_since_execution > task.frequency:
-        print(f"⚠️ Task {task.name} has not been run for {time_since_execution}, It is mean to run every {task.frequency}. running now if time is okay ...")
+        print(f"""
+⚠️  Task {task.name} has not been run for {time_since_execution}. It is meant to run every {task.frequency}. Running now if time is okay...
+""")
     elif old_report.status != SUCCESS:
-        print(f"⚠️ Task {task.name} last run failed, running now if time is okay ...")
+        print(f"""
+⚠️  Task {task.name} last run failed. Running now if time is okay...
+""")
     else:
-        print(f"Task `{task.name}` was run successfully {time_since_execution} ago, skipping...")
+        print(f"""
+✅ Task `{task.name}` was run successfully {time_since_execution} ago. Skipping...
+""")
         return False, old_report
 
     suitable_run_time = task.start.time()
@@ -160,7 +179,9 @@ def should_task_run(task: Task, tolerance_mins: int = 1440) -> tuple[bool, Optio
     min_diff = abs(suitable_run_time.hour - time_now.hour) * 60 + abs(suitable_run_time.minute - time_now.minute)
     if not min_diff < tolerance_mins:
         status = f"⌚ Time now is not suitable for running task {task.name} (Ideally, it should be run at {suitable_run_time})"
-        print(status)
+        print(f"""
+{status}
+""")
         return False, old_report
     return True, old_report
 
@@ -168,6 +189,13 @@ def should_task_run(task: Task, tolerance_mins: int = 1440) -> tuple[bool, Optio
 def run_task(task: Task) -> Report:
     start_time = datetime.now()
 
+    print(f"""
+╔{'═'*78}╗
+║ 🚀  RUNNING TASK                                                              ║
+╚{'═'*78}╝
+""")
+    print(f"🔧 Task Name: {task.name}")
+
     shell_script = get_shell_script_executing_python_file(python_file=task.task_root.joinpath("task.py").to_str(), ve_name=task.venv)
     shell_script_root = P.tmp().joinpath(f"tmp_scripts/scheduler/{task.name}").create()
     try:
@@ -179,10 +207,16 @@ def run_task(task: Task) -> Report:
             subprocess.run(['bash', shell_script], check=True)
         else: res = f"Error: Unsupported platform {platform.system()}."
         res = SUCCESS
-    except subprocess.CalledProcessError: res = f"Error: The script {shell_script_root} failed to run."
-    except Exception as e: res = f"Error: An unexpected error occurred while running the script {shell_script_root}: {e}"
+    except subprocess.CalledProcessError:
+        res = f"Error: The script {shell_script_root} failed to run."
+    except Exception as e:
+        res = f"Error: An unexpected error occurred while running the script {shell_script_root}: {e}"
 
     end_time = datetime.now()
     report = Report(name=task.name, start=start_time, end=end_time, status=res.replace('\n', '_NL_').strip().replace('=', '_eq_'))
     report.to_path(task.report_path)
+
+    print(f"""
+✅ Task {task.name} completed with status: {res}
+""")
     return report