machineconfig 1.9__py3-none-any.whl → 1.91__py3-none-any.whl

machineconfig/scripts/python/scheduler.py

@@ -45,7 +45,7 @@ def main_parse():
         print(f"✅ Task {task_name} created in {task_root}. Head there and edit the config.ini file & task.py file.")
         return None
 
-    main(root=root.str, ignore_conditions=args.ignore_conditions)
+    main(root=root.to_str(), ignore_conditions=args.ignore_conditions)
 
 
 if __name__ == "__main__":

machineconfig/scripts/python/start_slidev.py

@@ -16,7 +16,7 @@ PORT_DEFAULT = 3030
 SLIDEV_REPO = CONFIG_PATH.joinpath(".cache/slidev")
 if not SLIDEV_REPO.joinpath("components").exists():
     # assert slidev is installed first
-    Terminal(stderr=subprocess.PIPE, stdin=subprocess.PIPE, stdout=subprocess.PIPE).run(f"cd {SLIDEV_REPO.parent};npm init slidev")
+    Terminal(stderr=subprocess.PIPE, stdin=subprocess.PIPE, stdout=subprocess.PIPE).run(f"cd {SLIDEV_REPO.parent};npm init slidev@latest")
 
 
 def jupyter_to_markdown(file: P):
@@ -55,10 +55,11 @@ def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("-d", "--directory", default=None, help="Directory of the report")
     parser.add_argument("-j", "--jupyter-file", default=None, help="Jupyter notebook file to convert to slides. If not provided, slides.md is used.")
-    parser.add_argument("--port", default=PORT_DEFAULT, help=f"Port to serve the report, default to {PORT_DEFAULT}")
+    # parser.add_argument("--port", default=PORT_DEFAULT, help=f"Port to serve the report, default to {PORT_DEFAULT}")
     args = parser.parse_args()
 
-    port = args.port
+    # port = args.port
+    port = PORT_DEFAULT
 
     if args.jupyter_file is not None:
         report_dir = jupyter_to_markdown(P(args.jupyter_file))
@@ -95,7 +96,12 @@ def main() -> None:
     print(f"Presentation is served at http://{platform.node()}:{port}")
     print(f"Presentation is served at http://localhost:{port}")
     print(f"Presentation is served at http://{local_ip_v4}:{port}")
-    program: str = f"cd {SLIDEV_REPO}; slidev --port {port} --remote 0.0.0.0; cd {P.cwd()}"
+    # This version requires a globally installed cli of slidev, which is not recommended.
+    # program: str=f"cd {SLIDEV_REPO}; slidev --port {port} --remote 0.0.0.0; cd {P.cwd()}"
+
+    # The recommended approach is do `npm init slidev@latest` in the directory where you want to create the presentation
+    # Then you can do the following:
+    program = "npm run dev slides.md -- --remote"
     PROGRAM_PATH.write_text(program)
     print_code(program, lexer="bash")
 

machineconfig/scripts/python/start_terminals.py

@@ -2,7 +2,7 @@
 """Script to start terminals on windows and wsl
 """
 
-from machineconfig.utils.utils import PROGRAM_PATH, display_options, install_n_import, get_ssh_hosts, platform
+from machineconfig.utils.utils import PROGRAM_PATH, display_options, get_ssh_hosts, platform
 from itertools import cycle
 from typing import Literal
 
@@ -22,14 +22,14 @@ THIS_MACHINE_HOSTNAME = platform.node()
 THIS_MACHINE_HOSTNAME_WSL = f"{THIS_MACHINE_HOSTNAME}wsl"
 
 
-def main_windows_and_wsl(window: int, hosts: list[str], orientation: ORIENTATION_TYPE = "vertical", mprocs: bool = False):
+def main_windows_and_wsl(window: int, hosts: list[str], orientation: ORIENTATION_TYPE = "vertical", mprocs: bool=False):
     orientation_oposite = "horizontal" if orientation == "vertical" else "vertical"
     orientation_swap                = "up" if orientation         == "horizontal" else "left"
     orientation_opposite_move_focus = "up" if orientation_oposite == "horizontal" else "left"
     orientation_opposite_move_focus_other = "down" if orientation_oposite == "horizontal" else "right"
     sleep = 3
     sep = f"\nsleep {sleep}; wt --window {window}"  # or '`;'
-    ssh_cmd = f"-t 'mprocs'" if mprocs else ''  # 'wsl_ssh_windows_port_forwarding.ps1'
+    ssh_cmd = "-t 'mprocs'" if mprocs else ''  # 'wsl_ssh_windows_port_forwarding.ps1'
     split_per_machine = 1 / len(hosts)
     size = 0.3
     known_hosts = get_ssh_hosts()
@@ -89,7 +89,8 @@ def main():
         cmd = main_windows_and_wsl(window=args.window, hosts=hosts, orientation="vertical" if args.vertical else "horizontal")
 
     print(cmd)
-    install_n_import("clipboard").copy(cmd)
+    # import clipboard
+    # install_n_import("clipboard").copy(cmd)
     PROGRAM_PATH.write_text(cmd)
 
 

machineconfig/scripts/python/wifi_conn.py

@@ -1,50 +1,44 @@
-
 """Wifi connect
+
+sudo apt-get install network-manager
+
 """
 
 import argparse
 import configparser
 from pathlib import Path
-# import random
-# import string
 import os
-
+import platform
+import subprocess
 
 def create_new_connection(name: str, ssid: str, password: str):
-    config = """<?xml version=\"1.0\"?>
-<WLANProfile xmlns="http://www.microsoft.com/networking/WLAN/profile/v1">
-    <name>""" + name + """</name>
-    <SSIDConfig>
-        <SSID>
-            <name>""" + ssid + """</name>
-        </SSID>
-    </SSIDConfig>
-    <connectionType>ESS</connectionType>
-    <connectionMode>auto</connectionMode>
-    <MSM>
-        <security>
-            <authEncryption>
-                <authentication>WPA2PSK</authentication>
-                <encryption>AES</encryption>
-                <useOneX>false</useOneX>
-            </authEncryption>
-            <sharedKey>
-                <keyType>passPhrase</keyType>
-                <protected>false</protected>
-                <keyMaterial>""" + password + """</keyMaterial>
-            </sharedKey>
-        </security>
-    </MSM>
-</WLANProfile>"""
-    command = "netsh wlan add profile filename=\"" + name + ".xml\"" + " interface=Wi-Fi"
-    with open(name + ".xml", mode='w', encoding="utf-8") as file: file.write(config)
-    os.system(command)
-
+    if platform.system() == "Windows":
+        config = """<?xml version=\"1.0\"?>
+        // ...existing XML config...
+        """
+        command = "netsh wlan add profile filename=\"" + name + ".xml\"" + " interface=Wi-Fi"
+        with open(name + ".xml", mode='w', encoding="utf-8") as file:
+            file.write(config)
+        os.system(command)
+    elif platform.system() == "Linux":
+        # Use nmcli to add/update connection
+        command = f"nmcli connection add type wifi con-name '{name}' ssid '{ssid}' wifi-sec.key-mgmt wpa-psk wifi-sec.psk '{password}'"
+        subprocess.run(command, shell=True, check=True)
 
 def connect(name: str, ssid: str):
-    command = "netsh wlan connect name=\"" + name + "\" ssid=\"" + ssid + "\" interface=Wi-Fi"
-    os.system(command)
-def display_available_networks(): os.system("netsh wlan show networks interface=Wi-Fi")  #
+    if platform.system() == "Windows":
+        command = "netsh wlan connect name=\"" + name + "\" ssid=\"" + ssid + "\" interface=Wi-Fi"
+        os.system(command)
+    elif platform.system() == "Linux":
+        command = f"nmcli connection up '{name}'"
+        subprocess.run(command, shell=True, check=True)
+
+
+def display_available_networks():
+    if platform.system() == "Windows":
+        os.system("netsh wlan show networks interface=Wi-Fi")
+    elif platform.system() == "Linux":
+        subprocess.run("nmcli device wifi list", shell=True, check=True)
 
 
 def main():
@@ -52,20 +46,18 @@ def main():
     creds.read(Path.home().joinpath('dotfiles/machineconfig/setup/wifi.ini'))
 
     parser = argparse.ArgumentParser(description='Wifi Connector')
-    parser.add_argument('-n', "--ssid", help=f"SSID of Wifi", default='MyPhoneHotSpot')
+    parser.add_argument('-n', "--ssid", help="SSID of Wifi", default='MyPhoneHotSpot')
 
     args = parser.parse_args()
     ssid = creds[args.ssid]['SSID']
-    # pwd = creds[args.ssid]['pwd']
+    password = creds[args.ssid]['pwd']  # You'll need the password for Linux connections
 
-    # displayAvailableNetworks()
-    # createNewConnection(name, name, password)
+    # Create and connect to the network
+    create_new_connection(ssid, ssid, password)
     connect(ssid, ssid)
 
 
 def get_current_wifi_name() -> str:
-    import subprocess
-    import platform
     if platform.system() == "Windows":
         try:
             cmd_output = subprocess.check_output(["netsh", "wlan", "show", "interface"], shell=True).decode("utf-8")

machineconfig/scripts/python/wsl_windows_transfer.py

@@ -28,7 +28,7 @@ Otherwise, a flag must be raised to indicate the direction.""")
     path = P(args.path).expanduser().absolute()
 
     if args.same_file_system:
-        print(f"💥 Using a not recommended transfer method! Copying same files across different file systems.")
+        print("💥 Using a not recommended transfer method! Copying same files across different file systems.")
         if system == "Windows":  # move files over to WSL
             path.copy(folder=WSL_FROM_WIN.joinpath(UserName).joinpath(path.rel2home().parent), overwrite=True)  # the following works for files and folders alike.
         else:  # move files from WSL to win

machineconfig/setup_windows/wt_and_pwsh/set_pwsh_theme.py

@@ -32,7 +32,7 @@ def install_nerd_fonts():
     folder.search("*readme*").apply(lambda p: p.delete(sure=True))
     folder.search("*LICENSE*").apply(lambda p: p.delete(sure=True))
     file = P.tmpfile(suffix=".ps1").write_text(LIBRARY_ROOT.joinpath("setup_windows/wt_and_pwsh/install_fonts.ps1").read_text().replace(r".\fonts-to-be-installed", str(folder)))
-    subprocess.run(rf"powershell.exe -executionpolicy Bypass -nologo -noninteractive -File {file.str}", check=True)
+    subprocess.run(rf"powershell.exe -executionpolicy Bypass -nologo -noninteractive -File {file.to_str()}", check=True)
     folder.delete(sure=True)
 
 

machineconfig/setup_windows/wt_and_pwsh/set_wt_settings.py

@@ -52,7 +52,7 @@ class TerminalSettings(object):
 
     # 1- Customizing Powershell========================================================
     # as opposed to Windows Powershell
-    def customize_powershell(self, nerd_font: bool = True):
+    def customize_powershell(self, nerd_font: bool=True):
         pwsh: dict[str, Any] = dict(name="PowerShell",
                                     commandline="pwsh",
                                     hidden=False,
@@ -65,7 +65,8 @@ class TerminalSettings(object):
             if item["name"] == "PowerShell":
                 self.profs.list[idx].update(pwsh)
                 break
-        else: print(f"Couldn't customize powershell because profile not found, try to install it first.")
+        else:
+            print("Couldn't customize powershell because profile not found, try to install it first.")
 
     def make_powershell_default_profile(self):
         for profile in self.profs:

machineconfig/utils/installer.py

@@ -3,22 +3,23 @@
 """
 from rich.console import Console
 
-from crocodile.file_management import P, List as L, Read, Struct
+from crocodile.file_management import P, List as L, Read
+from crocodile.core import Struct
 from crocodile.meta import Terminal
 from machineconfig.utils.utils import INSTALL_VERSION_ROOT, INSTALL_TMP_DIR, LIBRARY_ROOT, check_tool_exists
 
 # from dataclasses import dataclass
-from typing import Optional, Any
+from typing import Optional, Any, TypeAlias, Literal
 import platform
 # import os
 
 
 LINUX_INSTALL_PATH = '/usr/local/bin'
-WINDOWS_INSTALL_PATH = '~/AppData/Local/Microsoft/WindowsApps'
+WINDOWS_INSTALL_PATH = P.home().joinpath("AppData/Local/Microsoft/WindowsApps").__str__()
+CATEGORY: TypeAlias = Literal["OS_SPECIFIC", "OS_GENERIC", "CUSTOM", "OS_SPECIFIC_DEV", "OS_GENERIC_DEV", "CUSTOM_DEV"]
 
 
-def find_move_delete_windows(downloaded_file_path: P, exe_name: Optional[str] = None, delete: bool = True, rename_to: Optional[str] = None):
-    """Moves executable to {WINDOWS_INSTALL_PATH}"""
+def find_move_delete_windows(downloaded_file_path: P, exe_name: Optional[str] = None, delete: bool=True, rename_to: Optional[str] = None):
     if exe_name is not None and ".exe" in exe_name: exe_name = exe_name.replace(".exe", "")
     if downloaded_file_path.is_file():
         exe = downloaded_file_path
@@ -66,19 +67,20 @@ def find_move_delete_linux(downloaded: P, tool_name: str, delete: Optional[bool]
 
 
 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 = repo_url
-        self.name = name
-        self.doc = doc
-        self.filename_template_windows_amd_64 = filename_template_windows_amd_64
-        self.filename_template_linux_amd_64 = filename_template_linux_amd_64
-        self.strip_v = strip_v
-        self.exe_name = exe_name
+    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 = check_tool_exists(tool_name=self.exe_name)
+        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}"
@@ -102,34 +104,41 @@ class Installer:
 
     def install_robust(self, version: Optional[str]):
         try:
+
             old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
             self.install(version=version)
             new_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
-            if old_version_cli == new_version_cli: return f"📦️ 😑 {self.exe_name}, same version: {old_version_cli}"
-            else: return f"📦️ 🤩 {self.exe_name} updated from {old_version_cli} === to ===> {new_version_cli}"
+
+            if old_version_cli == new_version_cli: return f"""echo "📦️ 😑 {self.exe_name}, same version: {old_version_cli}" """
+            else: return f"""echo "📦️ 🤩 {self.exe_name} updated from {old_version_cli} === to ===> {new_version_cli}" """
+
         except Exception as ex:
             print(ex)
-            return f"📦️ Failed at {self.exe_name} with {ex}"
+            return f"""echo "📦️ Failed at `{self.name}` with {ex}" """
 
     def install(self, version: Optional[str]):
         if self.repo_url == "CUSTOM":
+
             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")
+
             import runpy
-            program = runpy.run_path(str(installer_path), run_name=None)['main'](version=version)
-            Terminal().run_script(script=program, shell="default").print(desc="Running custom installer", capture=True)
+            print(f"Executing func `main` from `{installer_path}`to get the program to run")
+            program: str=runpy.run_path(str(installer_path), run_name=None)['main'](version=version)
+            # print(program)
+            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)
-        elif "npm " in self.repo_url:
-            Terminal().run(self.repo_url, shell="default").print_if_unsuccessful(desc="npm install", strict_err=True, strict_returncode=True)
-            version_to_be_installed = "npmLatest"
-        elif "pip " in self.repo_url:
-            Terminal().run(self.repo_url, shell="default").print_if_unsuccessful(desc="pip install", strict_err=True, strict_returncode=True)
-            version_to_be_installed = "pipLatest"
+        elif "npm " in self.repo_url or "pip " in self.repo_url or "winget " in self.repo_url:
+            desc = self.repo_url.split(" ", maxsplit=1)[0] + "installation"
+            version_to_be_installed = self.repo_url.split(" ", maxsplit=1)[0] + "Latest"
+            Terminal().run(self.repo_url, shell="default").print_if_unsuccessful(desc=desc, strict_err=True, strict_returncode=True)
         else:
             downloaded, version_to_be_installed = self.download(version=version)
-            if downloaded.str.endswith(".deb"):
+            if downloaded.to_str().endswith(".deb"):
                 assert platform.system() == "Linux"
                 Terminal().run(f"sudo apt install -y {downloaded}").print_if_unsuccessful(desc="Installing .deb", strict_err=True, strict_returncode=True)
                 downloaded.delete(sure=True)
@@ -161,7 +170,7 @@ class Installer:
             else: raise NotImplementedError(f"📦️ System {platform.system()} not implemented")
             version_to_be_installed = "predefined_url"
         else:
-            release_url, version_to_be_installed = self.get_github_release(repo_url=self.repo_url, version=version)
+            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
@@ -170,7 +179,7 @@ class Installer:
             elif platform.system() == "Linux":
                 file_name = self.filename_template_linux_amd_64.format(version_to_be_installed_stripped)
             else: raise NotImplementedError(f"📦️ System {platform.system()} not implemented")
-            print(f"📦️ File name", file_name)
+            print("📦️ File name", file_name)
             download_link = release_url.joinpath(file_name)
         print(f"📦️ Downloading {self.name}: ", download_link.as_url_str())
         downloaded = download_link.download(folder=INSTALL_TMP_DIR).decompress()
@@ -262,36 +271,66 @@ def get_installed_cli_apps():
 
 
 def get_installers(system: str, dev: bool) -> list[Installer]:
+    res_all = get_all_dicts(system=system)
+    if not dev:
+        del res_all["CUSTOM_DEV"]
+        del res_all["OS_SPECIFIC_DEV"]
+        del res_all["OS_GENERIC_DEV"]
+    res_final = {}
+    for _k, v in res_all.items():
+        res_final.update(v)
+    return [Installer.from_dict(d=vd, name=k) for k, vd in res_final.items()]
+
+
+def get_all_dicts(system: str) -> dict[CATEGORY, dict[str, dict[str, Any]]]:
     if system == "Windows": import machineconfig.jobs.python_windows_installers as os_specific_installer
     else: import machineconfig.jobs.python_linux_installers as os_specific_installer
+
     import machineconfig.jobs.python_generic_installers as generic_installer
     path_os_specific = P(os_specific_installer.__file__).parent
     path_os_generic = P(generic_installer.__file__).parent
+
+    path_os_specific_dev = path_os_specific.joinpath("dev")
+    path_os_generic_dev = path_os_generic.joinpath("dev")
+
+    res_final: dict[CATEGORY, dict[str, dict[str, Any]]] = {}
+    res_final["OS_SPECIFIC"] = Read.json(path=path_os_specific.joinpath("config.json"))
+    res_final["OS_GENERIC"] = Read.json(path=path_os_generic.joinpath("config.json"))
+    res_final["OS_SPECIFIC_DEV"] = Read.json(path=path_os_specific_dev.joinpath("config.json"))
+    res_final["OS_GENERIC_DEV"] = Read.json(path=path_os_generic_dev.joinpath("config.json"))
+
     path_custom_installer = path_os_generic.with_name("python_custom_installers")
-    if dev:
-        path_os_specific = path_os_specific.joinpath("dev")
-        path_os_generic = path_os_generic.joinpath("dev")
-    res1: dict[str, Any] = Read.json(path=path_os_specific.joinpath("config.json"))
-    res2: dict[str, Any] = Read.json(path=path_os_generic.joinpath("config.json"))
-    res2.update(res1)
+    path_custom_installer_dev = path_custom_installer.joinpath("dev")
+
     import runpy
-    for item in path_custom_installer.search("*.py", r=False):
+    res_custom: dict[str, dict[str, Any]] = {}
+    for item in path_custom_installer.search("*.py", r=False, not_in=["__init__"]):
+        try:
+            config_dict = runpy.run_path(str(item), run_name=None)['config_dict']
+            res_custom[item.stem] = config_dict
+        except Exception as ex:
+            print(f"Failed to load {item}: {ex}")
+
+    res_custom_dev: dict[str, dict[str, Any]] = {}
+    for item in path_custom_installer_dev.search("*.py", r=False, not_in=["__init__"]):
         try:
             config_dict = runpy.run_path(str(item), run_name=None)['config_dict']
-            res2[item.stem] = config_dict
+            res_custom_dev[item.stem] = config_dict
         except Exception as ex:
             print(f"Failed to load {item}: {ex}")
 
-    return [Installer.from_dict(d=vd, name=k) for k, vd in res2.items()]
+    res_final["CUSTOM"] = res_custom
+    res_final["CUSTOM_DEV"] = res_custom_dev
+    return res_final
 
 
-def install_all(installers: L[Installer], safe: bool = False, jobs: int = 10, fresh: bool = False):
+def install_all(installers: L[Installer], safe: bool=False, jobs: int = 10, fresh: bool=False):
     if fresh: INSTALL_VERSION_ROOT.delete(sure=True)
     if safe:
         from machineconfig.jobs.python.check_installations import APP_SUMMARY_PATH
         apps_dir = APP_SUMMARY_PATH.readit()
         if platform.system().lower() == "windows":
-            apps_dir.search("*").apply(lambda app: app.move(folder=P.get_env().WindowsApps))
+            apps_dir.search("*").apply(lambda app: app.move(folder=P.get_env().WindowsPaths().WindowsApps))
         elif platform.system().lower() == "linux":
             Terminal().run(f"sudo mv {apps_dir.as_posix()}/* {LINUX_INSTALL_PATH}/").print_if_unsuccessful(desc=f"MOVING executable to {LINUX_INSTALL_PATH}", strict_err=True, strict_returncode=True)
         else: raise NotImplementedError(f"I don't know this system {platform.system()}")

machineconfig/utils/procs.py

@@ -60,7 +60,7 @@ class ProcessManager:
             self.kill(pids=sub_df.pid.to_list())
             return
         kill_by_index = input("🔫 Kill by index? 1 4 ... /[n] ")
-        if kill_by_index != "":
+        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():
@@ -93,7 +93,7 @@ class ProcessManager:
                 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')
         for command in commands:
-            rows = self.df[self.df['command'].str.contains(command)]
+            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()

machineconfig/utils/scheduling.py

@@ -62,7 +62,7 @@ class Report:
     status: str
 
     @classmethod
-    def from_path(cls, path: P, return_default_if_not_found: bool = False):
+    def from_path(cls, path: P, return_default_if_not_found: bool=False):
         if not path.exists():
             if return_default_if_not_found:
                 return Report(name=path.parent.name, start=datetime(year=2000, month=1, day=1), end=datetime(year=2000, month=1, day=1), status="NA")
@@ -108,7 +108,7 @@ def read_task_from_dir(path: P):
     return task
 
 
-def main(root: Optional[str] = None, ignore_conditions: bool = True):
+def main(root: Optional[str] = None, ignore_conditions: bool=True):
     if root is None: root_resolved = SCHEDULER_DEFAULT_ROOT
     else: root_resolved = P(root).expanduser().absolute()
     tasks_dirs = root_resolved.search(files=False, folders=True).filter(lambda x: x.joinpath("task.py").exists())
@@ -168,7 +168,7 @@ def should_task_run(task: Task, tolerance_mins: int = 1440) -> tuple[bool, Optio
 def run_task(task: Task) -> Report:
     start_time = datetime.now()
 
-    shell_script = get_shell_script_executing_python_file(python_file=task.task_root.joinpath("task.py").str, ve_name=task.venv)
+    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:
         if platform.system() == 'Windows':