More reasonable filenames, and creating messages de novo (#9)

* feat: rename files so that they are human readably ID'd

* feat: Name files based upon a human readable string

* feat: Allow creation of emails de novo

Author: j6k4m8

epistolary/mailbox_manager/mailbox_manager.py

@@ -34,6 +34,18 @@ def get_email(self, uid: EmailID) -> EmailMessage:
         """
         ...
 
+    def get_email_address_and_subject(self, uid: EmailID) -> tuple[str, str]:
+        """Get the email address and subject of an email.
+
+        Arguments:
+            uid: The ID of the email to get.
+
+        Returns:
+            The email address and subject of the email.
+
+        """
+        ...
+
     def get_email_subject_and_text(self, uid: EmailID) -> tuple[str, str]:
         """Get the subject and text of an email.
 

epistolary/mailbox_manager/smtpimap_mailbox_manager.py

@@ -1,27 +1,28 @@
 import pathlib
+from urllib.parse import quote
+from urllib.parse import unquote
 from redbox import EmailBox
 from redbox.models import EmailMessage
-from redmail import EmailSender
+from redmail.email.sender import EmailSender
 
 from ..epiconfig import EpistolaryConfig
 from ..types import EmailID
 from .mailbox_manager import MailboxManager
 
 
-def _get_msgid_from_header_dict(header_dict: dict[str, str]) -> EmailID:
-    _possible_message_id_keys = [
-        "Message-ID",
-        "Message-Id",
-        "Message-id",
-        "message-id",
-        "message_id",
-        "messageid",
-    ]
-    for possible_key in _possible_message_id_keys:
-        if possible_key in header_dict:
-            return EmailID(header_dict[possible_key])
+def sanitize_fname(fname: str) -> str:
+    return quote(fname, safe="-_.@")
 
-    raise ValueError("No message ID found in header dict")
+
+def desanitize_fname(fname: str) -> str:
+    return unquote(fname)
+
+
+def _get_mail_filename(header_dict: dict[str, str]) -> EmailID:
+    sender = sanitize_fname(header_dict.get("From", "unknown"))
+    subject = header_dict.get("Subject", "no subject")
+    combined = f"{sender}:::{subject}"
+    return EmailID(combined)
 
 
 class SMTPIMAPMailboxManager(MailboxManager):
@@ -108,7 +109,7 @@ def get_emails(
         messages = self._box[folder].search(unseen=True)
         result = {}
         for message in messages:
-            result[EmailID(_get_msgid_from_header_dict(message.headers))] = message
+            result[_get_mail_filename(message.headers)] = message
             if limit is not None and len(result) >= limit:
                 break
         return result
@@ -127,6 +128,27 @@ def get_email(self, email_id: EmailID) -> EmailMessage:
         # every time we want to get a single email.
         return self.get_emails()[email_id]
 
+    def get_email_address_and_subject(
+        self, uid: EmailID, append_re: bool = True
+    ) -> tuple[str, str]:
+        """
+        Get the email address and subject of the email with the specified ID.
+
+        Arguments:
+            uid (EmailID): The email ID.
+
+        Returns:
+            tuple[str, str]: The email address and subject of the email.
+        """
+        try:
+            email = self.get_email(uid)
+            return email.from_, ("Re: " + email.subject) if append_re else email.subject
+        except KeyError:
+            # Luckily the email ID is literally the address and subject through
+            # our sanitization function.
+            dest, subject = uid.split(":::")
+            return desanitize_fname(dest).strip(), subject.strip()
+
     def get_email_subject_and_text(self, uid: EmailID) -> tuple[str, str]:
         """
         Get the subject and text of the email with the specified ID.
@@ -144,6 +166,10 @@ def send_message(
         self, to: str, subject: str, body: str, in_reply_to: EmailID | None = None
     ) -> bool:
         """Send a message."""
+        # print(f"Sending email to {to} with subject {subject} and body:\n{body}")
+        # conf = input("Is this correct? (y/n) ")
+        # if conf.lower() != "y":
+        #     return False
         self._sender.send(
             subject=subject,
             receivers=[to],

epistolary/orchestrator.py

@@ -165,10 +165,10 @@ def send_outbox(self) -> list[EmailID]:
         sent_emails = []
         for did, doc in outbox.items():
             outgoing_text = self.get_last_page_ocr_text_for_document(doc)
-            relevant_received_email = self.mailbox_manager.get_email(did)
+            addr, subj = self.mailbox_manager.get_email_address_and_subject(did)
             result = self.mailbox_manager.send_message(
-                to=relevant_received_email.from_,
-                subject="Re: " + relevant_received_email.subject,
+                to=addr,
+                subject=subj,
                 body=outgoing_text,
                 in_reply_to=did,
             )

epistolary/remarkable/__init__.py

@@ -1,7 +1,6 @@
 import enum
 import pathlib
 import tempfile
-
 import subprocess
 
 
@@ -82,16 +81,41 @@ def download(self, remote_path: str, local_path: pathlib.Path):
         # Create the local path if it doesn't exist
         local_path.parent.mkdir(parents=True, exist_ok=True)
         self._run_rmapi("get", remote_path)
+        # print("DEBUG: Listing files in cache directory:")
+        # for f in self._cache_dir.iterdir():
+        #     print("DEBUG: file in cache:", f)
         base_fname = pathlib.Path(remote_path).name
-        pathlib.Path(str(self._cache_dir / base_fname) + ".zip").rename(
-            str(local_path) + ".zip"
-        )
-
-    def upload(self, local_path: pathlib.Path, remote_path: str):
+        # print(f"DEBUG: Cache directory: {self._cache_dir}")
+        # print(f"DEBUG: Base file name: {base_fname}")
+        matching_zips = list(self._cache_dir.rglob(f"*{base_fname}*.zip"))
+        if not matching_zips:
+            matching_rmdocs = list(self._cache_dir.rglob(f"*{base_fname}*.rmdoc"))
+            if matching_rmdocs:
+                print(f"DEBUG: Found rmdoc file: {matching_rmdocs[0]}, renaming to zip")
+                matching_rmdocs[0].rename(pathlib.Path(str(local_path) + ".zip"))
+            else:
+                return
+                # all_zips = list(self._cache_dir.rglob("*.zip"))
+                # if len(all_zips) == 1:
+                #     print(
+                #         f"DEBUG: Fallback: using the only zip file found: {all_zips[0]}"
+                #     )
+                #     all_zips[0].rename(pathlib.Path(str(local_path) + ".zip"))
+                # else:
+                #     print(
+                #         f"ERROR: No matching zip or rmdoc file found in {self._cache_dir} for base name {base_fname}"
+                #     )
+                #     return
+        else:
+            zip_file = matching_zips[0]
+            print(f"DEBUG: Found zip file: {zip_file}")
+            zip_file.rename(pathlib.Path(str(local_path) + ".zip"))
+
+    def upload(self, local_path: pathlib.Path, remote: str):
         """
         Upload a file to the reMarkable.
         """
-        self._run_rmapi("put", str(local_path), remote_path)
+        self._run_rmapi("put", str(local_path), remote)
 
     def delete(self, remote_path: str):
         """
@@ -142,7 +166,6 @@ def _run_remarks(self, *args):
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 check=True,
-                # shell=True
             )
         except subprocess.CalledProcessError as e:
             raise Exception(e.stderr.decode("utf-8")) from e
@@ -164,7 +187,7 @@ def rm_to_pdf(
         """
         input_path = pathlib.Path(input_path)
         output_path = pathlib.Path(output_path)
-        # Create outputpath.parent if it doesn't exist
+        # Create output path parent if it doesn't exist
         output_path.parent.mkdir(parents=True, exist_ok=True)
         output_path_without_extension = output_path.with_suffix("")
         # If input path is a .zip, extract it
@@ -180,8 +203,3 @@ def rm_to_pdf(
         list(output_path_without_extension.glob("*.pdf"))[0].rename(
             str(output_path.parent / output_path.name)
         )
-        # # Delete the temp file
-        # (output_path.parent / output_path.name).rmdir()
-        # list(output_path.parent.glob("*.this-is-a-tempfile"))[0].rename(
-        #     str(output_path)
-        # )