machineconfig 1.95__py3-none-any.whl → 1.97__py3-none-any.whl

machineconfig/cluster/templates/utils.py

@@ -1,37 +1,70 @@
 
-"""
-This module contains utility functions for the cluster module.
-"""
-
-import inspect
-from crocodile.core import Save
-from crocodile.file_management import P
-from machineconfig.cluster.remote_machine import WorkloadParams
-from typing import Optional, Any, Callable
-
-
-def expensive_function(workload_params: WorkloadParams, sim_dict: Optional[dict[str, Any]] = None) -> P:
-    import time
-    from rich.progress import track
-    print("Hello, I am one thread of an expensive function, and I just started running ...")
-    print(f"Oh, I recieved this parameter: {sim_dict=} & {workload_params=} ")
-    execution_time_in_seconds = 60 * 1
-    steps = 100
-    for _ in track(range(steps), description="Progress bar ..."):
-        time.sleep(execution_time_in_seconds / steps)  # Simulate work being done
-    print(f"I'm done, I crunched numbers from {workload_params.idx_start} to {workload_params.idx_end}.")
-    _ = workload_params.idx_max
-
-    save_dir = P.tmp().joinpath("tmp_dirs/expensive_function_single_thread").joinpath(workload_params.save_suffix, f"thread_{workload_params.idx_start}_{workload_params.idx_end}").create()
-    Save.pickle(obj={'a': 1}, path=save_dir.joinpath("trial_func_result.pkl"))
-    return save_dir
-
-
-def assert_has_workload_params(func_or_method: Callable[..., Any]):
-    if not inspect.isfunction(func_or_method) and not inspect.ismethod(func_or_method): raise TypeError(f"{func_or_method} is not a function or method.")
-    try: params = inspect.signature(func_or_method).parameters
-    except ValueError as e: raise ValueError(f"Failed to inspect signature of {func_or_method}: {e}") from e
-    if 'workload_params' not in params: raise ValueError(f"{func_or_method.__name__}() does not have 'workload_params' parameter.")
-    if params['workload_params'].kind != inspect.Parameter.POSITIONAL_OR_KEYWORD: raise ValueError(f"{func_or_method.__name__}() 'workload_params' parameter is not a positional or keyword parameter.")
-    if params['workload_params'].default is not inspect.Parameter.empty: raise ValueError(f"{func_or_method.__name__}() 'workload_params' parameter should not have a default value.")
-    return True
+# """
+# This module contains utility functions for the cluster module.
+# """
+
+# import inspect
+# from machineconfig.utils.io_save import save_pickle
+
+# from machineconfig.cluster.remote_machine import WorkloadParams
+from typing import Optional
+from crocodile.file_management import P, PLike
+
+# def expensive_function(workload_params: WorkloadParams, sim_dict: Optional[dict[str, Any]] = None) -> P:
+#     import time
+#     from rich.progress import track
+#     print("Hello, I am one thread of an expensive function, and I just started running ...")
+#     print(f"Oh, I recieved this parameter: {sim_dict=} & {workload_params=} ")
+#     execution_time_in_seconds = 60 * 1
+#     steps = 100
+#     for _ in track(range(steps), description="Progress bar ..."):
+#         time.sleep(execution_time_in_seconds / steps)  # Simulate work being done
+#     print(f"I'm done, I crunched numbers from {workload_params.idx_start} to {workload_params.idx_end}.")
+#     _ = workload_params.idx_max
+
+#     save_dir = PathExtended.tmp().joinpath("tmp_dirs/expensive_function_single_thread").joinpath(workload_params.save_suffix, f"thread_{workload_params.idx_start}_{workload_params.idx_end}")
+#     save_dir.mkdir(parents=True, exist_ok=True)
+#     save_pickle(obj={'a': 1}, path=save_dir.joinpath("trial_func_result.pkl"))
+#     return save_dir
+
+
+# def assert_has_workload_params(func_or_method: Callable[..., Any]):
+#     if not inspect.isfunction(func_or_method) and not inspect.ismethod(func_or_method): raise TypeError(f"{func_or_method} is not a function or method.")
+#     try: params = inspect.signature(func_or_method).parameters
+#     except ValueError as e: raise ValueError(f"Failed to inspect signature of {func_or_method}: {e}") from e
+#     if 'workload_params' not in params: raise ValueError(f"{func_or_method.__name__}() does not have 'workload_params' parameter.")
+#     if params['workload_params'].kind != inspect.Parameter.POSITIONAL_OR_KEYWORD: raise ValueError(f"{func_or_method.__name__}() 'workload_params' parameter is not a positional or keyword parameter.")
+#     if params['workload_params'].default is not inspect.Parameter.empty: raise ValueError(f"{func_or_method.__name__}() 'workload_params' parameter should not have a default value.")
+#     return True
+
+
+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,
+                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)
+    if zip:
+        localpath = localpath.zip(inplace=False)
+        to_del.append(localpath)
+    if encrypt:
+        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)
+    else: rp = P(remotepath)
+
+    from rclone_python import rclone
+    rclone.copy(localpath.as_posix(), f"{cloud}:{rp.as_posix()}", show_progress=True)
+
+    if share:
+        if verbose: print("🔗 SHARING FILE")
+        tmp = rclone.link(f"{cloud}:{rp.as_posix()}")
+        return P(tmp)
+    return localpath
+
+
+if __name__ == "__main__":
+    from pathlib import Path
+    localpath = Path.home().joinpath("Downloads", "exchangeInfo")
+    to_cloud(localpath, "odp", remotepath=None)

machineconfig/jobs/python/check_installations.py

@@ -1,196 +1,264 @@
-"""CI
-"""
+# """CI
+# """
 
 
-import time
-import pandas as pd
+# import time
 import platform
-from rich.console import Console
-# from rich.progress import track
-from machineconfig.utils.utils import LIBRARY_ROOT, INSTALL_VERSION_ROOT
-from machineconfig.utils.installer import get_installed_cli_apps
-from crocodile.core import List as L, install_n_import, Struct
-from crocodile.file_management import P
-from crocodile.meta import Terminal
-from tqdm import tqdm
-from typing import Optional
-from datetime import datetime
+# from typing import Any
+# from rich.console import Console
+# from machineconfig.utils.utils2 import pprint
+# # from rich.progress import track
+from machineconfig.utils.utils import LIBRARY_ROOT
+# from machineconfig.utils.installer import get_installed_cli_apps
+
+# from tqdm import tqdm
+# from typing import Optional
+# from datetime import datetime
+# import csv
 
 
 APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lower()}/apps_summary_report.csv")
-CLOUD: str = "gdw"  # Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
-# my onedrive doesn't allow sharing.
-
-
-def scan(path: P, pct: float = 0.0):
-    vt = install_n_import(library="vt", package="vt-py")
-    client = vt.Client(P.home().joinpath("dotfiles/creds/tokens/virustotal").read_text().split("\n")[0])
-    console = Console()
-    console.rule(f"Scanning {path}. {pct:.2f}% done")
-    if path.is_dir():
-        print(f"📁 Skipping {path} as it is a directory.")
-        return None
-    with open(str(path), "rb") as f:
-        analysis = client.scan_file(f)
-    repeat_counter: int = 0
-    while True:
-        with console.status(f"waiting for scan of {path} ... "):
-            try:
-                anal = client.get_object("/analyses/{}", analysis.id)
-                if anal.status == "completed": break
-            except Exception as ex:  # type: ignore
-                repeat_counter += 1
-                if repeat_counter > 2:
-                    raise ValueError(f"❌ Error in scanning {path}") from ex
-                print("⚠️  Error in scanning, trying again...")
-            time.sleep(30)
-    df = pd.DataFrame(anal.results.values())
-    malicious = []
-    for _idx, row in df.iterrows():
-        # try:
-        #     print(row.result)
-        # except Exception as ex:  # type: ignore
-        #     print(row)
-        if row.result is None and row.category in ["undetected", "type-unsupported", "failure", "timeout", "confirmed-timeout"]: continue
-        else:
-            Struct(row.to_dict()).print(as_config=True, title=f"🔍 Found Category {row.category}")
-            malicious.append(row)
-    positive_pct: float = round(number=len(malicious) / len(df) * 100, ndigits=1)
-    print(f"""
-{'=' * 50}
-🔬 SCAN RESULTS | Positive ratio: {positive_pct:.1f}%
-{'=' * 50}
-""")
-    return positive_pct, df
-
-
-def main() -> None:
-    apps_paths_tmp: L[P] = get_installed_cli_apps()
-    versions_files_paths: L[P] = INSTALL_VERSION_ROOT.search()
-    app_versions: list[Optional[str]] = []
-    apps_paths_raw: L[P] = L([])
-    for an_app in apps_paths_tmp:
-        version_path = versions_files_paths.filter(lambda x: x.stem == an_app.stem)
-        if len(version_path) == 1:
-            app_versions.append(version_path.list[0].read_text())
-            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)
-        #     if tmp is not None: tmp = tmp.split("\n")[0]
-        #     print(f"➡️ Found version `{tmp}` for {an_app.stem}.")
-        #     app_versions.append(None)
-    print(f"""
-{'=' * 150}
-🔍 TOOL CHECK | Checking tools (#{len(apps_paths_tmp)}) collected from `{INSTALL_VERSION_ROOT}`
-{'=' * 150}
-""")
-    apps_paths_raw.print()
-    positive_pct: list[Optional[float]] = []
-    scan_time: list[str] = []
-    detailed_results: list[dict[str, Optional[pd.DataFrame]]] = []
-
-    for idx, app in enumerate(apps_paths_raw):
-        try: res = scan(path=app, pct=idx / len(apps_paths_raw) * 100)
-        except ValueError as ve:
-            print(f"❌ ERROR | {ve}")
-            res = None
-        if res is None:
-            positive_pct.append(None)
-            detailed_results.append({app.stem: None})
-        else:
-            ppct, df = res
-            positive_pct.append(ppct)
-            detailed_results.append({app.stem: df})
-        scan_time.append(datetime.now().strftime("%Y-%m-%d %H:%M"))
-
-    res_df = pd.DataFrame({"app_name": apps_paths_raw.apply(lambda x: x.stem).list,
-                           "version": app_versions,
-                           "positive_pct": positive_pct,
-                            "scan_time": scan_time,
-                           "app_path": apps_paths_raw.apply(lambda x: x.collapseuser(strict=False).as_posix()).list})
-
-    app_url: list[Optional[str]] = []
-    for idx, row in tqdm(res_df.iterrows(), total=res_df.shape[0]):
-        apps_safe_url = upload(P(str(row["app_path"])).expanduser())
-        app_url.append(apps_safe_url.as_posix() if type(apps_safe_url) is P else apps_safe_url)
-    res_df["app_url"] = app_url
-    res_df.to_csv(APP_SUMMARY_PATH.with_suffix(".csv").create(parents_only=True), index=False)
-    APP_SUMMARY_PATH.with_suffix(".md").write_text(res_df.to_markdown())
-    print(f"""
-{'=' * 150}
-📊 SAFETY REPORT | Summary of app scanning results
-{'=' * 150}
-""")
-    print(res_df)
-
-
-def upload(path: P):
-    import call_function_with_timeout
-    set_time_out = call_function_with_timeout.SetTimeout
-    func_with_timeout = set_time_out(lambda: path.to_cloud(CLOUD, rel2home=True, share=True, os_specific=True), timeout=180)
-    is_done, _is_timeout, _erro_message, results = func_with_timeout()
-    if is_done: return results
-    else: return None
-
-
-class PrecheckedCloudInstaller:
-    def __init__(self):
-        install_n_import("gdown")
-        self.df = pd.read_csv(APP_SUMMARY_PATH)
-
-    @staticmethod
-    def download_google_links(url: str):
-        # if "drive.google.com" in str(url): url = str(url).replace("open?", "uc?")
-        # else: raise NotImplementedError("Only google drive is supported for now.")
-        # return P(url).download(name=name)
-        gdrive_id = P(url).parts[-1].split("id=")[1]
-        gdown = install_n_import("gdown")
-        result = P(gdown.download(id=gdrive_id)).absolute()
-        return result
-
-    @staticmethod
-    def install_cli_apps(app_url: str):
-        try:
-            exe = PrecheckedCloudInstaller.download_google_links(app_url)
-        except Exception as ex:  # type: ignore
-            print(f"❌ ERROR | Failed downloading {app_url}: {ex}")
-            return None
-        if platform.system().lower() == "linux":
-            Terminal().run(f"chmod +x {exe}")
-            Terminal().run(f"mv {exe} /usr/local/bin/")
-        elif platform.system().lower() == "windows":
-            exe.move(folder=P.home().joinpath("AppData/Local/Microsoft/WindowsApps"), overwrite=True)
-        return True
-
-    def download_safe_apps(self, name: str="AllEssentials"):
-        # if platform.system().lower() == "windows":
-        #     from machineconfig.jobs.python.python_windows_installers_all import get_cli_py_installers
-        #     cli_installers = get_cli_py_installers()
-        # elif platform.system().lower() == "linux":
-        #     from machineconfig.jobs.python.python_linux_installers_all import get_cli_py_installers
-        #     cli_installers = get_cli_py_installers()
-        # else: raise NotImplementedError(f"Platform {platform.system().lower()} is not supported yet.")
-
-        if name == "AllEssentials":
-            print(f"""
-{'=' * 150}
-📥 DOWNLOAD | Downloading {self.df.shape[0]} apps...
-{'=' * 150}
-""")
-            print(self.df)
-            _res = L(self.df.app_url).apply(PrecheckedCloudInstaller.install_cli_apps, jobs=20)
-        else:
-            app_url = self.df[self.df.app_name == name].iloc[0].app_url
-            _res = PrecheckedCloudInstaller.install_cli_apps(app_url=app_url)
-
-        # print("\n" * 3)
-        # for item_flag, item_name in zip(res, self.df["app_name"]):
-        #     if item_flag: print(f"✅ {item_name} is installed. 😁")
-        #     else: print(f"❌ {item_name} failed to install for reasons explained in the log above, try manually.")
-
-
-if __name__ == '__main__':
-    pass
+# CLOUD: str = "gdw"  # Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
+# # my onedrive doesn't allow sharing.
+
+
+# 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])
+#     console = Console()
+#     console.rule(f"Scanning {path}. {pct:.2f}% done")
+#     if path.is_dir():
+#         print(f"📁 Skipping {path} as it is a directory.")
+#         return None
+#     with open(str(path), "rb") as f:
+#         analysis = client.scan_file(f)
+#     repeat_counter: int = 0
+#     while True:
+#         with console.status(f"waiting for scan of {path} ... "):
+#             try:
+#                 anal = client.get_object("/analyses/{}", analysis.id)
+#                 if anal.status == "completed": break
+#             except Exception as ex:  # type: ignore
+#                 repeat_counter += 1
+#                 if repeat_counter > 2:
+#                     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 = []
+#     for result_item in results_data:
+#         # Convert result item to dictionary if it has attributes
+#         if hasattr(result_item, '__dict__'):
+#             result_dict = result_item.__dict__
+#         else:
+#             # Assume it already has the necessary attributes
+#             result_dict = {
+#                 '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"]: 
+#             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}
+# 🔬 SCAN RESULTS | Positive ratio: {positive_pct:.1f}%
+# {'=' * 50}
+# """)
+#     return positive_pct, results_data
+
+
+# def main() -> None:
+#     # Convert potential custom List types to plain Python lists
+#     tmp_apps = get_installed_cli_apps()
+#     apps_paths_tmp: list[PathExtended]
+#     if hasattr(tmp_apps, "list"):
+#         apps_paths_tmp = list(tmp_apps.list)
+#     else:
+#         try:
+#             apps_paths_tmp = list(tmp_apps)
+#         except TypeError:
+#             apps_paths_tmp = [tmp_apps]
+
+#     tmp_versions = INSTALL_VERSION_ROOT.search()
+#     versions_files_paths: list[PathExtended]
+#     if hasattr(tmp_versions, "list"):
+#         versions_files_paths = list(tmp_versions.list)
+#     else:
+#         try:
+#             versions_files_paths = list(tmp_versions)
+#         except TypeError:
+#             versions_files_paths = [tmp_versions]
+
+#     app_versions: list[Optional[str]] = []
+#     apps_paths_raw: list[PathExtended] = []
+#     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())
+#             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)
+#         #     if tmp is not None: tmp = tmp.split("\n")[0]
+#         #     print(f"➡️ Found version `{tmp}` for {an_app.stem}.")
+#         #     app_versions.append(None)
+#     print(f"""
+# {'=' * 150}
+# 🔍 TOOL CHECK | Checking tools (#{len(apps_paths_tmp)}) collected from `{INSTALL_VERSION_ROOT}`
+# {'=' * 150}
+# """)
+#     for path_item in apps_paths_raw:
+#         print(path_item)
+#     positive_pct: list[Optional[float]] = []
+#     scan_time: list[str] = []
+#     detailed_results: list[dict[str, Optional[list[Any]]]] = []
+
+#     for idx, app in enumerate(apps_paths_raw):
+#         try: res = scan(path=app, pct=idx / len(apps_paths_raw) * 100)
+#         except ValueError as ve:
+#             print(f"❌ ERROR | {ve}")
+#             res = None
+#         if res is None:
+#             positive_pct.append(None)
+#             detailed_results.append({app.stem: None})
+#         else:
+#             ppct, results_data = res
+#             positive_pct.append(ppct)
+#             detailed_results.append({app.stem: results_data})
+#         scan_time.append(datetime.now().strftime("%Y-%m-%d %H:%M"))
+
+#     # Create list of dictionaries instead of DataFrame
+#     app_data = []
+#     for i, app_path in enumerate(apps_paths_raw):
+#         app_data.append({
+#             "app_name": app_path.stem,
+#             "version": app_versions[i],
+#             "positive_pct": positive_pct[i],
+#             "scan_time": scan_time[i],
+#             "app_path": app_path.collapseuser(strict=False).as_posix()
+#         })
+
+#     # Add app URLs
+#     for i, app_info in enumerate(tqdm(app_data, desc="Uploading apps")):
+#         apps_safe_url = upload(PathExtended(app_info["app_path"]).expanduser())
+#         app_info["app_url"] = apps_safe_url.as_posix() if (apps_safe_url is not None and type(apps_safe_url) is P) else str(apps_safe_url) if apps_safe_url is not None else ""
+
+#     # Write to CSV using standard library
+#     csv_path = APP_SUMMARY_PATH.with_suffix(".csv")
+#     csv_path.parent.mkdir(parents=True, exist_ok=True)
+#     with open(csv_path, 'w', newline='', encoding='utf-8') as csvfile:
+#         if app_data:
+#             fieldnames = app_data[0].keys()
+#             writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+#             writer.writeheader()
+#             writer.writerows(app_data)
+
+#     # Create markdown table
+#     def format_app_table_markdown(data: list[dict[str, Any]]) -> str:
+#         if not data:
+#             return ""
+#         keys = list(data[0].keys())
+#         header = "|" + "|".join(f" {key} " for key in keys) + "|"
+#         separator = "|" + "|".join(" --- " for _ in keys) + "|"
+#         rows = []
+#         for row in data:
+#             row_values = [f" {str(row.get(key, ''))} " for key in keys]
+#             rows.append("|" + "|".join(row_values) + "|")
+#         return "\n".join([header, separator] + rows)
+
+#     markdown_content = format_app_table_markdown(app_data)
+#     APP_SUMMARY_PATH.with_suffix(".md").write_text(markdown_content)
+    
+#     print(f"""
+# {'=' * 150}
+# 📊 SAFETY REPORT | Summary of app scanning results
+# {'=' * 150}
+# """)
+#     print(markdown_content)
+
+
+# def upload(path: PathExtended):
+#     import call_function_with_timeout
+#     set_time_out = call_function_with_timeout.SetTimeout
+#     func_with_timeout = set_time_out(lambda: path.to_cloud(CLOUD, rel2home=True, share=True, os_specific=True), timeout=180)
+#     is_done, _is_timeout, _erro_message, results = func_with_timeout()
+#     if is_done: return results
+#     else: return None
+
+
+# class PrecheckedCloudInstaller:
+#     def __init__(self):
+#         # Read CSV using standard library
+#         self.data = []
+#         if APP_SUMMARY_PATH.exists():
+#             with open(APP_SUMMARY_PATH, 'r', encoding='utf-8') as csvfile:
+#                 reader = csv.DictReader(csvfile)
+#                 self.data = list(reader)
+
+#     @staticmethod
+#     def download_google_links(url: str):
+#         # if "drive.google.com" in str(url): url = str(url).replace("open?", "uc?")
+#         # else: raise NotImplementedError("Only google drive is supported for now.")
+#         # return PathExtended(url).download(name=name)
+#         gdrive_id = PathExtended(url).parts[-1].split("id=")[1]
+#         result = PathExtended(gdown.download(id=gdrive_id)).absolute()
+#         return result
+
+#     @staticmethod
+#     def install_cli_apps(app_url: str):
+#         try:
+#             exe = PrecheckedCloudInstaller.download_google_links(app_url)
+#         except Exception as ex:  # type: ignore
+#             print(f"❌ ERROR | Failed downloading {app_url}: {ex}")
+#             return None
+#         if platform.system().lower() in ["linux", "darwin"]:
+#             Terminal().run(f"chmod +x {exe}")
+#             Terminal().run(f"mv {exe} /usr/local/bin/")
+#         elif platform.system().lower() == "windows":
+#             exe.move(folder=PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps"), overwrite=True)
+#         return True
+
+#     def download_safe_apps(self, name: str="AllEssentials"):
+#         # if platform.system().lower() == "windows":
+#         #     from machineconfig.jobs.python.python_windows_installers_all import get_cli_py_installers
+#         #     cli_installers = get_cli_py_installers()
+#         # elif platform.system().lower() == "linux":
+#         #     from machineconfig.jobs.python.python_linux_installers_all import get_cli_py_installers
+#         #     cli_installers = get_cli_py_installers()
+#         # else: raise NotImplementedError(f"Platform {platform.system().lower()} is not supported yet.")
+
+#         if name == "AllEssentials":
+#             print(f"""
+# {'=' * 150}
+# 📥 DOWNLOAD | Downloading {len(self.data)} apps...
+# {'=' * 150}
+# """)
+#             print(self.data)
+#             app_urls = [item['app_url'] for item in self.data]
+#             from concurrent.futures import ThreadPoolExecutor
+#             with ThreadPoolExecutor(max_workers=20) as executor:
+#                 _res = list(executor.map(PrecheckedCloudInstaller.install_cli_apps, app_urls))
+#         else:
+#             app_items = [item for item in self.data if item['app_name'] == name]
+#             if not app_items:
+#                 raise ValueError(f"App '{name}' not found in data")
+#             app_url = app_items[0]['app_url']
+#             _res = PrecheckedCloudInstaller.install_cli_apps(app_url=app_url)
+
+#         # print("\n" * 3)
+#         # for item_flag, item_name in zip(res, self.df["app_name"]):
+#         #     if item_flag: print(f"✅ {item_name} is installed. 😁")
+#         #     else: print(f"❌ {item_name} failed to install for reasons explained in the log above, try manually.")
+
+
+# if __name__ == '__main__':
+#     pass

machineconfig/jobs/python/create_bootable_media.py

@@ -5,9 +5,13 @@
 # # one can either install rufus: https://rufus.ie/en/
 # # however, to create bootable media with multiple OSs to choose from:
 
-# P(r'https://github.com/ventoy/Ventoy/archive/refs/tags/v1.0.78.zip').download().unzip().search[0]()
-# P(r'https://mirrors.layeronline.com/linuxmint/stable/21/linuxmint-21-cinnamon-64bit.iso').download(folder=P.home().joinpath("Downloads/os").create())
-# P(r'https://download.manjaro.org/kde/21.3.7/manjaro-kde-21.3.7-minimal-220816-linux515.iso').download(folder=P.home().joinpath("Downloads/os").create())
+# PathExtended(r'https://github.com/ventoy/Ventoy/archive/refs/tags/v1.0.78.zip').download().unzip().search[0]()
+# download_folder = PathExtended.home().joinpath("Downloads/os")
+# download_folder.mkdir(parents=True, exist_ok=True)
+# PathExtended(r'https://mirrors.layeronline.com/linuxmint/stable/21/linuxmint-21-cinnamon-64bit.iso').download(folder=download_folder)
+# download_folder2 = PathExtended.home().joinpath("Downloads/os")
+# download_folder2.mkdir(parents=True, exist_ok=True)
+# PathExtended(r'https://download.manjaro.org/kde/21.3.7/manjaro-kde-21.3.7-minimal-220816-linux515.iso').download(folder=download_folder2)
 
 
 # if __name__ == '__main__':