machineconfig 2.1__py3-none-any.whl → 2.2__py3-none-any.whl

machineconfig/utils/links.py

@@ -33,31 +33,78 @@ def build_links(target_paths: list[tuple[PLike, str]], repo_root: PLike):
         links_path.symlink_to(target=a_target_path)
 
 
-def symlink_func(this: PathExtended, to_this: PathExtended, prioritize_to_this: bool = True):
+def symlink_func(this: PathExtended, to_this: PathExtended, prioritize_to_this: bool):
     """helper function. creates a symlink from `this` to `to_this`.
-    What can go wrong?
-    depending on this and to_this existence, one will be prioretized depending on overwrite value.
-    True means this will potentially be overwritten (depending on whether to_this exists or not)
-    False means to_this will potentially be overwittten."""
+
+    this: exists           AND    to_this exists            AND this is a symlink pointing to to_this              ===> Resolution: AUTO: do nothing, already linked correctly.
+    this: exists           AND    to_this exists            AND this is a symlink pointing to somewhere else       ===> Resolution: AUTO: delete this symlink, create symlink to to_this
+    this: exists           AND    to_this exists            AND this is a concrete path                            ===> Resolution: DANGER: require user input to decide (param prioritize_to_this). Give two options: 1) prioritize `this`: to_this is backed up as to_this.orig_<randstr()>, to_this is deleted,  and symlink is created from this to to_this as normal; 2) prioritize `to_this`: `this` is backed up as this.orig_<randstr()>, `this` is deleted, and symlink is created from this to to_this as normal.
+
+    this: exists           AND    to_this doesn't exist     AND this is a symlink pointing to somewhere else       ===> Resolution: AUTO: delete this symlink, create symlink to to_this (touch to_this)
+    this: exists           AND    to_this doesn't exist     AND this is a symlink pointing to to_this              ===> Resolution: AUTO: delete this symlink, create symlink to to_this (touch to_this)
+    this: exists           AND    to_this doesn't exist     AND this is a concrete path                            ===> Resolution: AUTO: move this to to_this, then create symlink from this to to_this.
+
+    this: doesn't exist    AND    to_this exists                                                                   ===> Resolution: AUTO: create link from this to to_this
+    this: doesn't exist    AND    to_this doesn't exist                                                            ===> Resolution: AUTO: create link from this to to_this (touch to_this)
+
+    """
     this = PathExtended(this).expanduser().absolute()
     to_this = PathExtended(to_this).expanduser().absolute()
-    if this.is_symlink():
-        this.delete(sure=True)  # delete if it exists as symblic link, not a concrete path.
-    if this.exists():  # this is a problem. It will be resolved via `overwrite`
-        if prioritize_to_this is True:  # it *can* be deleted, but let's look at target first.
-            if to_this.exists():  # this exists, to_this as well. to_this is prioritized.
-                this.append(f".orig_{randstr()}", inplace=True)  # rename is better than deletion
+    # Case analysis based on docstring
+    if this.exists():
+        if to_this.exists():
+            if this.is_symlink():
+                # Check if symlink already points to correct target
+                try:
+                    if this.readlink().resolve() == to_this.resolve():
+                        # Case: this exists AND to_this exists AND this is a symlink pointing to to_this
+                        console.print(Panel(f"✅ ALREADY LINKED | {this} ➡️  {to_this}", title="Already Linked", expand=False))
+                        return
+                    else:
+                        # Case: this exists AND to_this exists AND this is a symlink pointing to somewhere else
+                        console.print(Panel(f"🔄 RELINKING | Updating symlink from {this} ➡️  {to_this}", title="Relinking", expand=False))
+                        this.delete(sure=True)
+                except OSError:
+                    # Broken symlink case
+                    console.print(Panel(f"🔄 FIXING BROKEN LINK | Fixing broken symlink from {this} ➡️  {to_this}", title="Fixing Broken Link", expand=False))
+                    this.delete(sure=True)
             else:
-                this.move(path=to_this)  # this exists, to_this doesn't. to_this is prioritized.
-        elif prioritize_to_this is False:  # don't sacrefice this, sacrefice to_this.
-            if to_this.exists():
-                this.move(path=to_this, overwrite=True)  # this exists, to_this as well, this is prioritized.   # now we are readly to make the link
+                # Case: this exists AND to_this exists AND this is a concrete path
+                if prioritize_to_this:
+                    # prioritize `to_this`: `this` is backed up, `this` is deleted, symlink created
+                    backup_name = f"{this}.orig_{randstr()}"
+                    console.print(Panel(f"📦 BACKING UP | Moving {this} to {backup_name}, prioritizing {to_this}", title="Backing Up", expand=False))
+                    this.move(path=backup_name)
+                else:
+                    # prioritize `this`: to_this is backed up, to_this is deleted, this content moved to to_this location
+                    backup_name = f"{to_this}.orig_{randstr()}"
+                    console.print(Panel(f"📦 BACKING UP | Moving {to_this} to {backup_name}, prioritizing {this}", title="Backing Up", expand=False))
+                    to_this.move(path=backup_name)
+                    this.move(path=to_this)
+        else:
+            # to_this doesn't exist
+            if this.is_symlink():
+                # Case: this exists AND to_this doesn't exist AND this is a symlink (pointing anywhere)
+                console.print(Panel(f"🔄 RELINKING | Updating symlink from {this} ➡️  {to_this}", title="Relinking", expand=False))
+                this.delete(sure=True)
+                # Create to_this
+                to_this.parent.mkdir(parents=True, exist_ok=True)
+                to_this.touch()
             else:
-                this.move(path=to_this)  # this exists, to_this doesn't, this is prioritized.
-    else:  # this doesn't exist.
-        if not to_this.exists():
+                # Case: this exists AND to_this doesn't exist AND this is a concrete path
+                console.print(Panel(f"📁 MOVING | Moving {this} to {to_this}, then creating symlink", title="Moving", expand=False))
+                this.move(path=to_this)
+    else:
+        # this doesn't exist
+        if to_this.exists():
+            # Case: this doesn't exist AND to_this exists
+            console.print(Panel(f"🆕 NEW LINK | Creating new symlink from {this} ➡️  {to_this}", title="New Link", expand=False))
+        else:
+            # Case: this doesn't exist AND to_this doesn't exist
+            console.print(Panel(f"🆕 NEW LINK & TARGET | Creating {to_this} and symlink from {this} ➡️  {to_this}", title="New Link & Target", expand=False))
             to_this.parent.mkdir(parents=True, exist_ok=True)
-            to_this.touch()  # we have to touch it (file) or create it (folder)
+            to_this.touch()
+    # Create the symlink
     try:
         console.print(Panel(f"🔗 LINKING | Creating symlink from {this} ➡️  {to_this}", title="Linking", expand=False))
         PathExtended(this).symlink_to(target=to_this, verbose=True, overwrite=True)
@@ -68,23 +115,46 @@ def symlink_func(this: PathExtended, to_this: PathExtended, prioritize_to_this:
 def symlink_copy(this: PathExtended, to_this: PathExtended, prioritize_to_this: bool = True):
     this = PathExtended(this).expanduser().absolute()
     to_this = PathExtended(to_this).expanduser().absolute()
-    if this.is_symlink():
-        this.delete(sure=True)  # delete if it exists as symblic link, not a concrete path.
-    if this.exists():  # this is a problem. It will be resolved via `overwrite`
-        if prioritize_to_this is True:  # it *can* be deleted, but let's look at target first.
-            if to_this.exists():  # this exists, to_this as well. to_this is prioritized.
-                this.append(f".orig_{randstr()}", inplace=True)  # rename is better than deletion
+    # Case analysis based on docstring of symlink_func
+    if this.exists():
+        if to_this.exists():
+            if this.is_symlink():
+                try:
+                    if this.readlink().resolve() == to_this.resolve():
+                        console.print(Panel(f"✅ ALREADY LINKED | {this} ➡️  {to_this}", title="Already Linked", expand=False))
+                        return
+                    else:
+                        console.print(Panel(f"🔄 RELINKING | Updating symlink from {this} ➡️  {to_this}", title="Relinking", expand=False))
+                        this.delete(sure=True)
+                except OSError:
+                    console.print(Panel(f"🔄 FIXING BROKEN LINK | Fixing broken symlink from {this} ➡️  {to_this}", title="Fixing Broken Link", expand=False))
+                    this.delete(sure=True)
             else:
-                this.move(path=to_this)  # this exists, to_this doesn't. to_this is prioritized.
-        elif prioritize_to_this is False:  # don't sacrefice this, sacrefice to_this.
-            if to_this.exists():
-                this.move(path=to_this, overwrite=True)  # this exists, to_this as well, this is prioritized.   # now we are readly to make the link
+                if prioritize_to_this:
+                    backup_name = f"{this}.orig_{randstr()}"
+                    console.print(Panel(f"📦 BACKING UP | Moving {this} to {backup_name}, prioritizing {to_this}", title="Backing Up", expand=False))
+                    this.move(path=backup_name)
+                else:
+                    backup_name = f"{to_this}.orig_{randstr()}"
+                    console.print(Panel(f"📦 BACKING UP | Moving {to_this} to {backup_name}, prioritizing {this}", title="Backing Up", expand=False))
+                    to_this.move(path=backup_name)
+                    this.move(path=to_this)
+        else:
+            if this.is_symlink():
+                console.print(Panel(f"🔄 RELINKING | Updating symlink from {this} ➡️  {to_this}", title="Relinking", expand=False))
+                this.delete(sure=True)
+                to_this.parent.mkdir(parents=True, exist_ok=True)
+                to_this.touch()
             else:
-                this.move(path=to_this)  # this exists, to_this doesn't, this is prioritized.
-    else:  # this doesn't exist.
-        if not to_this.exists():
+                console.print(Panel(f"📁 MOVING | Moving {this} to {to_this}, then copying", title="Moving", expand=False))
+                this.move(path=to_this)
+    else:
+        if to_this.exists():
+            console.print(Panel(f"🆕 NEW LINK | Copying {to_this} to {this}", title="New Link", expand=False))
+        else:
+            console.print(Panel(f"🆕 NEW LINK & TARGET | Creating {to_this} and copying to {this}", title="New Link & Target", expand=False))
             to_this.parent.mkdir(parents=True, exist_ok=True)
-            to_this.touch()  # we have to touch it (file) or create it (folder)
+            to_this.touch()
     try:
         console.print(Panel(f"📋 COPYING | Copying {to_this} to {this}", title="Copying", expand=False))
         to_this.copy(path=this, overwrite=True, verbose=True)

machineconfig/utils/notifications.py

@@ -1,30 +1,32 @@
-
-"""Notifications Module
-"""
+"""Notifications Module"""
 
 # from crocodile.core import install_n_import
 # from crocodile.file_management import P, Read
 from pathlib import Path
+
 # from crocodile.meta import RepeatUntilNoException
 import smtplib
 import imaplib
+
 # from email import message
 # from email import encoders
 # from email.mime.base import MIMEBase
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
-from typing import Optional, Any, Union, Literal
+from typing import Optional, Any, Union
 from markdown import markdown
 
 
-
-def download_to_memory(path: Path, allow_redirects: bool = True, timeout: Optional[float] = None, params: Any = None) -> 'Any':
+def download_to_memory(path: Path, allow_redirects: bool = True, timeout: Optional[float] = None, params: Any = None) -> "Any":
     import requests
-    return requests.get(path.as_posix().replace("https:/", "https://").replace("http:/", "http://"), allow_redirects=allow_redirects, timeout=timeout, params=params)  # Alternative: from urllib import request; request.urlopen(url).read().decode('utf-8').
+
+    return requests.get(
+        path.as_posix().replace("https:/", "https://").replace("http:/", "http://"), allow_redirects=allow_redirects, timeout=timeout, params=params
+    )  # Alternative: from urllib import request; request.urlopen(url).read().decode('utf-8').
 
 
 def get_github_markdown_css() -> str:
-    pp = r'https://raw.githubusercontent.com/sindresorhus/github-markdown-css/main/github-markdown-dark.css'
+    pp = r"https://raw.githubusercontent.com/sindresorhus/github-markdown-css/main/github-markdown-dark.css"
     return download_to_memory(Path(pp)).text
 
 
@@ -75,8 +77,10 @@ encryption = ssl
 
 """)
 
-        if not Path(path).exists() or Path(path).is_dir(): raise FileNotFoundError(f"File not found or is a directory: {path}")
+        if not Path(path).exists() or Path(path).is_dir():
+            raise FileNotFoundError(f"File not found or is a directory: {path}")
         import configparser
+
         res = configparser.ConfigParser()
         res.read(filenames=[str(path)], encoding=None)
         return res
@@ -84,10 +88,13 @@ encryption = ssl
     def __init__(self, config: dict[str, Any]):
         self.config = config
         from smtplib import SMTP_SSL, SMTP
+
         self.server: Union[SMTP_SSL, SMTP]
-        if config['encryption'].lower() == "ssl": self.server = smtplib.SMTP_SSL(host=self.config["smtp_host"], port=self.config["smtp_port"])
-        elif config['encryption'].lower() == "tls": self.server = smtplib.SMTP(host=self.config["smtp_host"], port=self.config["smtp_port"])
-        self.server.login(self.config['email_add'], password=self.config["password"])
+        if config["encryption"].lower() == "ssl":
+            self.server = smtplib.SMTP_SSL(host=self.config["smtp_host"], port=self.config["smtp_port"])
+        elif config["encryption"].lower() == "tls":
+            self.server = smtplib.SMTP(host=self.config["smtp_host"], port=self.config["smtp_port"])
+        self.server.login(self.config["email_add"], password=self.config["password"])
 
     def send_message(self, to: str, subject: str, body: str, txt_to_html: bool = True, attachments: Optional[list[Any]] = None):
         _ = attachments
@@ -95,7 +102,7 @@ encryption = ssl
         # msg = message.EmailMessage()
         msg = MIMEMultipart("alternative")
         msg["subject"] = subject
-        msg["From"] = self.config['email_add']
+        msg["From"] = self.config["email_add"]
         msg["To"] = to
         # msg['Content-Type'] = "text/html"
         # msg.set_content(body)
@@ -103,7 +110,8 @@ encryption = ssl
         # <link rel="stylesheet" href="github-markdown.css">
         # <link type="text/css" rel="stylesheet" href="https://raw.githubusercontent.com/sindresorhus/github-markdown-css/main/github-markdown-dark.css" />
 
-        if txt_to_html: body = md2html(body=body)
+        if txt_to_html:
+            body = md2html(body=body)
         msg.attach(MIMEText(body, "html"))
         # if attachments is None: attachments = []  # see: https://fedingo.com/how-to-send-html-mail-with-attachment-using-python/
         # for attachment in attachmenthrs: msg.attach(attachment.read_bytes(), filename=attachment.stem, maintype="image", subtype=attachment.suffix)
@@ -117,14 +125,19 @@ encryption = ssl
         server.starttls()
         server.login(email_add, password=pwd)
 
-    def send_email(self, to_addrs: str, msg: str): return self.server.sendmail(from_addr=self.config['email_add'], to_addrs=to_addrs, msg=msg)
-    def close(self): self.server.quit()    # Closing is vital as many servers do not allow mutiple connections.
+    def send_email(self, to_addrs: str, msg: str):
+        return self.server.sendmail(from_addr=self.config["email_add"], to_addrs=to_addrs, msg=msg)
+
+    def close(self):
+        self.server.quit()  # Closing is vital as many servers do not allow mutiple connections.
 
     @staticmethod
     def send_and_close(config_name: Optional[str], to: str, subject: str, body: str) -> Any:
         """If config_name is None, it sends from a generic email address."""
         if config_name is None:
-            raise NotImplementedError("Sending email without a config_name is not implemented. You need to create an emails.ini file in ~/dotfiles/machineconfig/ with your email configuration. See the docstring of the get_source_of_truth method for more information.")
+            raise NotImplementedError(
+                "Sending email without a config_name is not implemented. You need to create an emails.ini file in ~/dotfiles/machineconfig/ with your email configuration. See the docstring of the get_source_of_truth method for more information."
+            )
             # config = Email.get_source_of_truth()
             # try:
             #     api_key = config['resend']['api_key']
@@ -150,26 +163,27 @@ encryption = ssl
             tmp.send_message(to=to, subject=subject, body=body)
             tmp.close()
 
-    @staticmethod
-    def send_m365(to: list[str], subject: str, body: Optional[str], body_file: Optional[str], body_content_type: Literal["HTML", "Text"], attachments: Optional[list[Path]] = None) -> None:
-        if body_file is not None:
-            assert body is None, "You cannot pass both body and body_file."
-            body_file_path = Path(body_file)
-            assert body_file_path.exists(), f"File not found: {body_file_path}"
-        else:
-            body_file_path = None
-            assert body is not None, "You must pass either body or body_file."
-        from crocodile.meta import Terminal
-        to_str = ",".join(to)
-        attachments_str = " ".join([f"--attachment {str(p)}" for p in attachments]) if attachments is not None else ""
-
-        if body_file is not None:
-            body_arg = f"--bodyContents @{body_file_path}"
-        else:
-            body_arg = f'"{body}"'
-        cmd = f"""m365 outlook mail send --verbose --saveToSentItems --importance normal --bodyContentType {body_content_type} --bodyContents {body_arg} --subject "{subject}" --to {to_str} {attachments_str}"""
-        response = Terminal().run(cmd, shell="powershell")
-        response.print(desc="Email sending response")
+    # @staticmethod
+    # def send_m365(to: list[str], subject: str, body: Optional[str], body_file: Optional[str], body_content_type: Literal["HTML", "Text"], attachments: Optional[list[Path]] = None) -> None:
+    #     if body_file is not None:
+    #         assert body is None, "You cannot pass both body and body_file."
+    #         body_file_path = Path(body_file)
+    #         assert body_file_path.exists(), f"File not found: {body_file_path}"
+    #     else:
+    #         body_file_path = None
+    #         assert body is not None, "You must pass either body or body_file."
+    #     from crocodile.meta import Terminal
+
+    #     to_str = ",".join(to)
+    #     attachments_str = " ".join([f"--attachment {str(p)}" for p in attachments]) if attachments is not None else ""
+
+    #     if body_file is not None:
+    #         body_arg = f"--bodyContents @{body_file_path}"
+    #     else:
+    #         body_arg = f'"{body}"'
+    #     cmd = f"""m365 outlook mail send --verbose --saveToSentItems --importance normal --bodyContentType {body_content_type} --bodyContents {body_arg} --subject "{subject}" --to {to_str} {attachments_str}"""
+    #     response = Terminal().run(cmd, shell="powershell")
+    #     response.print(desc="Email sending response")
 
 
 # class PhoneNotification:  # security concerns: avoid using this.
@@ -193,5 +207,5 @@ encryption = ssl
 #         n.send_notification()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     pass

machineconfig/utils/options.py

@@ -9,34 +9,27 @@ from typing import Optional, Union, TypeVar, Iterable
 T = TypeVar("T")
 
 
-def check_tool_exists(tool_name: str, install_script: Optional[str] = None) -> bool:
-    if platform.system() == "Windows":
-        tool_name = tool_name.replace(".exe", "") + ".exe"
+def check_tool_exists(tool_name: str) -> bool:
+    if platform.system() == "Windows": tool_name = tool_name.replace(".exe", "") + ".exe"
+
+    from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH
 
     if platform.system() == "Windows":
         cmd = "where.exe"
+        root_path = Path(WINDOWS_INSTALL_PATH)
     elif platform.system() in ["Linux", "Darwin"]:
         cmd = "which"
-    else:
-        raise NotImplementedError(f"platform {platform.system()} not implemented")
-
-    try:
-        _tmp = subprocess.check_output([cmd, tool_name], stderr=subprocess.DEVNULL)
-        res: bool = True
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        res = False
-    if res is False and install_script is not None:
-        console = Console()
-        console.print(Panel(f"📥 INSTALLING TOOL | Installing {tool_name}...", border_style="bold blue", expand=False))
-        result = subprocess.run(install_script, shell=True, capture_output=True, text=True)
-        print(f"Command: {install_script}")
-        if result.stdout:
-            print(f"STDOUT: {result.stdout}")
-        if result.stderr:
-            print(f"STDERR: {result.stderr}")
-        print(f"Return code: {result.returncode}")
-        return check_tool_exists(tool_name=tool_name, install_script=None)
-    return res
+        root_path = Path(LINUX_INSTALL_PATH)
+    else: raise NotImplementedError(f"platform {platform.system()} not implemented")
+
+    _ = cmd
+    # try:
+    #     _tmp = subprocess.check_output([cmd, tool_name], stderr=subprocess.DEVNULL)
+    #     res: bool = True
+    # except (subprocess.CalledProcessError, FileNotFoundError):
+    #     res = False
+    # return res
+    return root_path.joinpath(tool_name).is_file()
 
 
 def choose_one_option(options: Iterable[T], header: str = "", tail: str = "", prompt: str = "", msg: str = "", default: Optional[T] = None, fzf: bool = False, custom_input: bool = False) -> T: