epstein-files 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

epstein_files/epstein_files.py

@@ -12,7 +12,8 @@ from typing import Sequence, Type, cast
 from rich.table import Table
 
 from epstein_files.documents.document import Document
-from epstein_files.documents.email import DETECT_EMAIL_REGEX, Email
+from epstein_files.documents.doj_file import DojFile
+from epstein_files.documents.email import Email
 from epstein_files.documents.json_file import JsonFile
 from epstein_files.documents.messenger_log import MSG_REGEX, MessengerLog
 from epstein_files.documents.other_file import OtherFile
@@ -21,7 +22,7 @@ from epstein_files.util.constant.strings import *
 from epstein_files.util.constants import *
 from epstein_files.util.data import flatten, json_safe, listify, uniquify
 from epstein_files.util.doc_cfg import EmailCfg, Metadata
-from epstein_files.util.env import DOCS_DIR, args, logger
+from epstein_files.util.env import DOCS_DIR, DOJ_PDFS_20260130_DIR, args, logger
 from epstein_files.util.file_helper import file_size_str
 from epstein_files.util.highlighted_group import HIGHLIGHTED_NAMES, HighlightedNames
 from epstein_files.util.search_result import SearchResult
@@ -49,14 +50,28 @@ class EpsteinFiles:
     imessage_logs: list[MessengerLog] = field(default_factory=list)
     json_files: list[JsonFile] = field(default_factory=list)
     other_files: list[OtherFile] = field(default_factory=list)
+    doj_files: list[DojFile] = field(default_factory=list)
     timer: Timer = field(default_factory=lambda: Timer())
     uninteresting_ccs: list[Name] = field(default_factory=list)
 
+    @property
+    def all_documents(self) -> Sequence[Document]:
+        return self.imessage_logs + self.emails + self.other_files + self.doj_files
+
+    @property
+    def all_doj_files(self) -> Sequence[DojFile | Email]:
+        """All files with the filename EFTAXXXXXX."""
+        return [doc for doc in self.all_documents if doc.is_doj_file]
+
     def __post_init__(self):
         """Iterate through files and build appropriate objects."""
         self.all_files = sorted([f for f in DOCS_DIR.iterdir() if f.is_file() and not f.name.startswith('.')])
-        documents = []
-        file_type_count = defaultdict(int)  # Hack used by --skip-other-files option
+
+        if DOJ_PDFS_20260130_DIR:
+            self.all_files += sorted([f for f in DOJ_PDFS_20260130_DIR.glob('**/*.txt')])
+
+        docs = []
+        file_type_count = defaultdict(int)  # Hack used by --skip-other-files option to get a few files parsed before skipping the rest
 
         # Read through and classify all the files
         for file_arg in self.all_files:
@@ -64,24 +79,25 @@ class EpsteinFiles:
             document = Document(file_arg)
             cls = document_cls(document)
 
-            if document.length() == 0:
+            if document.length == 0:
                 logger.warning(f"Skipping empty file: {document}]")
                 continue
             elif args.skip_other_files and cls == OtherFile and file_type_count[cls.__name__] > 1:
                 document.log(f"Skipping OtherFile...")
                 continue
 
-            documents.append(cls(file_arg, lines=document.lines, text=document.text))
-            logger.info(str(documents[-1]))
+            docs.append(cls(file_arg, lines=document.lines, text=document.text).printable_document())
+            logger.info(str(docs[-1]))
             file_type_count[cls.__name__] += 1
 
             if doc_timer.seconds_since_start() > SLOW_FILE_SECONDS:
-                doc_timer.print_at_checkpoint(f"Slow file: {documents[-1]} processed")
+                doc_timer.print_at_checkpoint(f"Slow file: {docs[-1]} processed")
 
-        self.emails = Document.sort_by_timestamp([d for d in documents if isinstance(d, Email)])
-        self.imessage_logs = Document.sort_by_timestamp([d for d in documents if isinstance(d, MessengerLog)])
-        self.other_files = Document.sort_by_timestamp([d for d in documents if isinstance(d, (JsonFile, OtherFile))])
-        self.json_files = [doc for doc in self.other_files if isinstance(doc, JsonFile)]
+        self.doj_files = Document.sort_by_timestamp([d for d in docs if isinstance(d, DojFile)])
+        self.emails = Document.sort_by_timestamp([d for d in docs if isinstance(d, Email)])
+        self.imessage_logs = Document.sort_by_timestamp([d for d in docs if isinstance(d, MessengerLog)])
+        self.json_files = Document.sort_by_timestamp([d for d in docs if isinstance(d, JsonFile)])
+        self.other_files = Document.sort_by_timestamp([d for d in docs if isinstance(d, OtherFile) and not isinstance(d, DojFile)])
         self._set_uninteresting_ccs()
         self._copy_duplicate_email_properties()
         self._find_email_attachments_and_set_is_first_for_user()
@@ -111,14 +127,11 @@ class EpsteinFiles:
         timer.print_at_checkpoint(f'Processed {len(epstein_files.all_files):,} documents')
         return epstein_files
 
-    def all_documents(self) -> Sequence[Document]:
-        return self.imessage_logs + self.emails + self.other_files
-
     def docs_matching(self, pattern: re.Pattern | str, names: list[Name] | None = None) -> list[SearchResult]:
         """Find documents whose text matches a pattern (file_type and names args limit the documents searched)."""
         results: list[SearchResult] = []
 
-        for doc in self.all_documents():
+        for doc in self.all_documents:
             if names and doc.author not in names:
                 continue
 
@@ -140,15 +153,15 @@ class EpsteinFiles:
 
     def email_author_counts(self) -> dict[Name, int]:
         return {
-            person.name: len(person.unique_emails_by())
-            for person in self.emailers() if len(person.unique_emails_by()) > 0
+            person.name: len(person.unique_emails_by)
+            for person in self.emailers() if len(person.unique_emails_by) > 0
         }
 
     def email_authors_to_device_signatures(self) -> dict[str, set[str]]:
         signatures = defaultdict(set)
 
         for email in [e for e in self.non_duplicate_emails() if e.sent_from_device]:
-            signatures[email.author_or_unknown()].add(email.sent_from_device)
+            signatures[email.author_or_unknown].add(email.sent_from_device)
 
         return signatures
 
@@ -156,14 +169,14 @@ class EpsteinFiles:
         signatures = defaultdict(set)
 
         for email in [e for e in self.non_duplicate_emails() if e.sent_from_device]:
-            signatures[email.sent_from_device].add(email.author_or_unknown())
+            signatures[email.sent_from_device].add(email.author_or_unknown)
 
         return signatures
 
     def email_recipient_counts(self) -> dict[Name, int]:
         return {
-            person.name: len(person.unique_emails_to())
-            for person in self.emailers() if len(person.unique_emails_to()) > 0
+            person.name: len(person.unique_emails_to)
+            for person in self.emailers() if len(person.unique_emails_to) > 0
         }
 
     def email_signature_substitution_counts(self) -> dict[str, int]:
@@ -212,7 +225,7 @@ class EpsteinFiles:
 
     def for_ids(self, file_ids: str | list[str]) -> list[Document]:
         file_ids = listify(file_ids)
-        docs = [doc for doc in self.all_documents() if doc.file_id in file_ids]
+        docs = [doc for doc in (list(self.all_documents) + self.doj_files) if doc.file_id in file_ids]
 
         if len(docs) != len(file_ids):
             logger.warning(f"{len(file_ids)} file IDs provided but only {len(docs)} Epstein files found!")
@@ -281,11 +294,17 @@ class EpsteinFiles:
         return self._uninteresting_emailers
 
     def _find_email_attachments_and_set_is_first_for_user(self) -> None:
-        for file in self.other_files:
-            if file.config and file.config.attached_to_email_id:
-                email = self.email_for_id(file.config.attached_to_email_id)
-                file.warn(f"Attaching to {email}")
-                email.attached_docs.append(file)
+        for other_file in self.other_files:
+            if other_file.config and other_file.config.attached_to_email_id:
+                email = self.email_for_id(other_file.config.attached_to_email_id)
+                email.attached_docs.append(other_file)
+
+                if other_file.timestamp \
+                        and other_file.timestamp != email.timestamp \
+                        and not other_file.config_timestamp:
+                    other_file.warn(f"Overwriting '{other_file.timestamp}' with {email}'s timestamp {email.timestamp}")
+
+                other_file.timestamp = email.timestamp
 
         for emailer in self.emailers():
             first_email = emailer.emails[0]
@@ -294,10 +313,10 @@ class EpsteinFiles:
     def _copy_duplicate_email_properties(self) -> None:
         """Ensure dupe emails have the properties of the emails they duplicate to capture any repairs, config etc."""
         for email in self.emails:
-            if not email.is_duplicate():
+            if not email.is_duplicate:
                 continue
 
-            original = self.email_for_id(email.duplicate_of_id())
+            original = self.email_for_id(email.duplicate_of_id)
 
             for field_name in DUPLICATE_PROPS_TO_COPY:
                 original_prop = getattr(original, field_name)
@@ -336,11 +355,13 @@ def count_by_month(docs: Sequence[Document]) -> dict[str | None, int]:
 def document_cls(doc: Document) -> Type[Document]:
     search_area = doc.text[0:5000]  # Limit search area to avoid pointless scans of huge files
 
-    if doc.length() == 0:
+    if doc.length == 0:
         return Document
+    elif doc.is_doj_file:
+        return DojFile
     if doc.text[0] == '{':
         return JsonFile
-    elif isinstance(doc.config, EmailCfg) or (DETECT_EMAIL_REGEX.match(search_area) and doc.config is None):
+    elif Document.is_email(doc):  # TODO: right now we setup the DojFile which makes an Email obj only later at print time
         return Email
     elif MSG_REGEX.search(search_area):
         return MessengerLog
@@ -349,4 +370,4 @@ def document_cls(doc: Document) -> Type[Document]:
 
 
 def _sorted_metadata(docs: Sequence[Document]) -> list[Metadata]:
-    return [json_safe(d.metadata()) for d in Document.sort_by_id(docs)]
+    return [json_safe(d.metadata) for d in Document.sort_by_id(docs)]

epstein_files/person.py

@@ -19,7 +19,8 @@ from epstein_files.util.data import days_between, flatten, uniquify, without_fal
 from epstein_files.util.env import args
 from epstein_files.util.highlighted_group import (QUESTION_MARKS_TXT, HighlightedNames,
      get_highlight_group_for_name, get_style_for_name, styled_category, styled_name)
-from epstein_files.util.rich import GREY_NUMBERS, TABLE_TITLE_STYLE, build_table, console, join_texts, print_centered
+from epstein_files.util.rich import (GREY_NUMBERS, SKIPPED_FILE_MSG_PADDING, TABLE_TITLE_STYLE, build_table,
+     console, join_texts, print_centered)
 
 ALT_INFO_STYLE = 'medium_purple4'
 CC = 'cc:'
@@ -48,8 +49,9 @@ class Person:
         self.emails = Document.sort_by_timestamp(self.emails)
         self.imessage_logs = Document.sort_by_timestamp(self.imessage_logs)
 
+    @property
     def category(self) -> str | None:
-        highlight_group = self.highlight_group()
+        highlight_group = self.highlight_group
 
         if highlight_group and isinstance(highlight_group, HighlightedNames):
             category = highlight_group.category or highlight_group.label
@@ -57,60 +59,63 @@ class Person:
             if category != self.name and category != 'paula':  # TODO: this sucks
                 return category
 
+    @property
     def category_txt(self) -> Text | None:
         if self.name is None:
             return None
-        elif self.category():
-            return styled_category(self.category())
-        elif self.is_a_mystery() or self.is_uninteresting:
+        elif self.category:
+            return styled_category(self.category)
+        elif self.is_a_mystery or self.is_uninteresting:
             return QUESTION_MARKS_TXT
 
+    @property
     def email_conversation_length_in_days(self) -> int:
         return days_between(self.emails[0].timestamp, self.emails[-1].timestamp)
 
+    @property
     def earliest_email_at(self) -> datetime:
         return self.emails[0].timestamp
 
+    @property
     def earliest_email_date(self) -> date:
-        return self.earliest_email_at().date()
+        return self.earliest_email_at.date()
 
+    @property
     def last_email_at(self) -> datetime:
         return self.emails[-1].timestamp
 
+    @property
     def last_email_date(self) -> date:
-        return self.last_email_at().date()
+        return self.last_email_at.date()
 
+    @property
     def emails_by(self) -> list[Email]:
         return [e for e in self.emails if self.name == e.author]
 
+    @property
     def emails_to(self) -> list[Email]:
         return [
             e for e in self.emails
             if self.name in e.recipients or (self.name is None and len(e.recipients) == 0)
         ]
 
-    def external_link(self, site: ExternalSite = EPSTEINIFY) -> str:
-        return PERSON_LINK_BUILDERS[site](self.name_str())
-
-    def external_link_txt(self, site: ExternalSite = EPSTEINIFY, link_str: str | None = None) -> Text:
-        if self.name is None:
-            return Text('')
-
-        return link_text_obj(self.external_link(site), link_str or site, style=self.style())
-
+    @property
     def external_links_line(self) -> Text:
         links = [self.external_link_txt(site) for site in PERSON_LINK_BUILDERS]
         return Text('', justify='center', style='dim').append(join_texts(links, join=' / '))  #, encloser='()'))#, encloser='‹›'))
 
+    @property
     def has_any_epstein_emails(self) -> bool:
         contacts = [e.author for e in self.emails] + flatten([e.recipients for e in self.emails])
         return JEFFREY_EPSTEIN in contacts
 
+    @property
     def highlight_group(self) -> HighlightedNames | None:
         return get_highlight_group_for_name(self.name)
 
+    @property
     def info_panel(self) -> Padding:
-        """Print a panel with the name of an emailer and a few tidbits of information about them."""
+        """Return a `Panel` with the name of an emailer and a few tidbits of information about them."""
         style = 'white' if (not self.style() or self.style() == DEFAULT) else self.style()
         panel_style = f"black on {style} bold"
 
@@ -118,22 +123,23 @@ class Person:
             email_count = len(self._printable_emails())
             title_suffix = f"sent by {JEFFREY_EPSTEIN} to himself"
         else:
-            email_count = len(self.unique_emails())
-            num_days = self.email_conversation_length_in_days()
-            title_suffix = f"{TO_FROM} {self.name_str()} starting {self.earliest_email_date()} covering {num_days:,} days"
+            email_count = len(self.unique_emails)
+            num_days = self.email_conversation_length_in_days
+            title_suffix = f"{TO_FROM} {self.name_str} starting {self.earliest_email_date} covering {num_days:,} days"
 
         title = f"Found {email_count} emails {title_suffix}"
-        width = max(MIN_AUTHOR_PANEL_WIDTH, len(title) + 4, len(self.info_with_category()) + 8)
+        width = max(MIN_AUTHOR_PANEL_WIDTH, len(title) + 4, len(self.info_with_category) + 8)
         panel = Panel(Text(title, justify='center'), width=width, style=panel_style)
         elements: list[RenderableType] = [panel]
 
-        if self.info_with_category():
-            elements.append(Text(f"({self.info_with_category()})", justify='center', style=f"{style} italic"))
+        if self.info_with_category:
+            elements.append(Text(f"({self.info_with_category})", justify='center', style=f"{style} italic"))
 
         return Padding(Group(*elements), (2, 0, 1, 0))
 
+    @property
     def info_str(self) -> str | None:
-        highlight_group = self.highlight_group()
+        highlight_group = self.highlight_group
 
         if highlight_group and isinstance(highlight_group, HighlightedNames) and self.name:
             info = highlight_group.info_for(self.name)
@@ -141,111 +147,161 @@ class Person:
             if info:
                 return info
 
-        if self.is_uninteresting and len(self.emails_by()) == 0:
-            if self.has_any_epstein_emails():
+        if self.is_uninteresting and len(self.emails_by) == 0:
+            if self.has_any_epstein_emails:
                 return UNINTERESTING_CC_INFO
             else:
                 return UNINTERESTING_CC_INFO_NO_CONTACT
 
-    def info_with_category(self) -> str:
-        return ', '.join(without_falsey([self.category(), self.info_str()]))
-
+    @property
     def info_txt(self) -> Text | None:
         if self.name == JEFFREY_EPSTEIN:
             return Text('(emails sent by Epstein to himself are here)', style=ALT_INFO_STYLE)
         elif self.name is None:
             return Text('(emails whose author or recipient could not be determined)', style=ALT_INFO_STYLE)
-        elif self.category() == JUNK:
+        elif self.category == JUNK:
             return Text(f"({JUNK} mail)", style='bright_black dim')
-        elif self.is_uninteresting and (self.info_str() or '').startswith(UNINTERESTING_CC_INFO):
-            if self.sole_cc():
-                return Text(f"(cc: from {self.sole_cc()} only)", style='wheat4 dim')
-            elif self.info_str() == UNINTERESTING_CC_INFO:
-                return Text(f"({self.info_str()})", style='wheat4 dim')
+        elif self.is_uninteresting and (self.info_str or '').startswith(UNINTERESTING_CC_INFO):
+            if self.sole_cc:
+                return Text(f"(cc: from {self.sole_cc} only)", style='wheat4 dim')
+            elif self.info_str == UNINTERESTING_CC_INFO:
+                return Text(f"({self.info_str})", style='wheat4 dim')
             else:
-                return Text(f"({self.info_str()})", style='plum4 dim')
-        elif self.is_a_mystery():
+                return Text(f"({self.info_str})", style='plum4 dim')
+        elif self.is_a_mystery:
             return Text(QUESTION_MARKS, style='honeydew2 bold')
-        elif self.info_str() is None:
+        elif self.info_str is None:
             if self.name in MAILING_LISTS:
                 return Text('(mailing list)', style=f"pale_turquoise4 dim")
-            elif self.category():
+            elif self.category:
                 return Text(QUESTION_MARKS, style=self.style())
             else:
                 return None
         else:
-            return Text(self.info_str(), style=self.style(allow_bold=False))
+            return Text(self.info_str, style=self.style(allow_bold=False))
+
+    @property
+    def info_with_category(self) -> str:
+        return ', '.join(without_falsey([self.category, self.info_str]))
 
+    @property
     def internal_link(self) -> Text:
         """Kind of like an anchor link to the section of the page containing these emails."""
-        return link_text_obj(internal_link_to_emails(self.name_str()), self.name_str(), style=self.style())
+        return link_text_obj(internal_link_to_emails(self.name_str), self.name_str, style=self.style())
 
+    @property
     def is_a_mystery(self) -> bool:
         """Return True if this is someone we theroetically could know more about."""
-        return self.is_unstyled() and not (self.is_email_address() or self.info_str() or self.is_uninteresting)
-
-    def sole_cc(self) -> str | None:
-        """Return name if this person sent 0 emails and received CC from only one that name."""
-        email_authors = uniquify([e.author for e in self.emails_to()])
-
-        if len(self.unique_emails()) == 1 and len(email_authors) > 0:
-            logger.info(f"sole author of email to '{self.name}' is '{email_authors[0]}'")
-        else:
-            logger.info(f"'{self.name}' email_authors '{email_authors[0]}'")
-
-        if len(self.unique_emails_by()) > 0:
-            return None
-
-        if len(email_authors) == 1:
-            return email_authors[0]
+        return self.is_unstyled and not (self.is_email_address or self.info_str or self.is_uninteresting)
 
+    @property
     def is_email_address(self) -> bool:
         return '@' in (self.name or '')
 
+    @property
     def is_linkable(self) -> bool:
         """Return True if it's likely that EpsteinWeb has a page for this name."""
         if self.name is None or ' ' not in self.name:
             return False
-        elif self.is_email_address() or '/' in self.name or QUESTION_MARKS in self.name:
+        elif self.is_email_address or '/' in self.name or QUESTION_MARKS in self.name:
             return False
         elif self.name in INVALID_FOR_EPSTEIN_WEB:
             return False
 
         return True
 
-    def should_always_truncate(self) -> bool:
-        """True if we want to truncate all emails to/from this user."""
-        return self.name in TRUNCATE_EMAILS_FROM or self.is_uninteresting
-
+    @property
     def is_unstyled(self) -> bool:
         """True if there's no highlight group for this name."""
         return self.style() == DEFAULT_NAME_STYLE
 
-    def name_str(self) -> str:
-        return self.name or UNKNOWN
-
+    @property
     def name_link(self) -> Text:
         """Will only link if it's worth linking, otherwise just a Text object."""
-        if not self.is_linkable():
-            return self.name_txt()
+        if not self.is_linkable:
+            return self.name_txt
         else:
-            return Text.from_markup(link_markup(self.external_link(), self.name_str(), self.style()))
+            return Text.from_markup(link_markup(self.external_link(), self.name_str, self.style()))
+
+    @property
+    def name_str(self) -> str:
+        return self.name or UNKNOWN
 
+    @property
     def name_txt(self) -> Text:
         return styled_name(self.name)
 
+    @property  # TODO: unused?
+    def should_always_truncate(self) -> bool:
+        """True if we want to truncate all emails to/from this user."""
+        return self.name in TRUNCATE_EMAILS_FROM or self.is_uninteresting
+
+    @property
+    def sole_cc(self) -> str | None:
+        """Return name if this person sent 0 emails and received CC from only one that name."""
+        email_authors = uniquify([e.author for e in self.emails_to])
+
+        if len(self.unique_emails) == 1 and len(email_authors) > 0:
+            logger.info(f"sole author of email to '{self.name}' is '{email_authors[0]}'")
+        else:
+            logger.info(f"'{self.name}' email_authors '{email_authors[0]}'")
+
+        if len(self.unique_emails_by) > 0:
+            return None
+
+        if len(email_authors) == 1:
+            return email_authors[0]
+
+    @property
+    def sort_key(self) -> list[int | str]:
+        """Key used to sort `Person` objects by the number of emails sent/received."""
+        counts = [
+            len(self.unique_emails),
+            -1 * int((self.info_str or '') == UNINTERESTING_CC_INFO_NO_CONTACT),
+            -1 * int((self.info_str or '') == UNINTERESTING_CC_INFO),
+            int(self.has_any_epstein_emails),
+        ]
+
+        counts = [-1 * count for count in counts]
+
+        if args.sort_alphabetical:
+            return [self.name_str] + counts
+        else:
+            return counts + [self.name_str]
+
+    @property
+    def unique_emails(self) -> Sequence[Email]:
+        return Document.without_dupes(self.emails)
+
+    @property
+    def unique_emails_by(self) -> list[Email]:
+        return Document.without_dupes(self.emails_by)
+
+    @property
+    def unique_emails_to(self) -> list[Email]:
+        return Document.without_dupes(self.emails_to)
+
+    def external_link(self, site: ExternalSite = EPSTEINIFY) -> str:
+        return PERSON_LINK_BUILDERS[site](self.name_str)
+
+    def external_link_txt(self, site: ExternalSite = EPSTEINIFY, link_str: str | None = None) -> Text:
+        if self.name is None:
+            return Text('')
+
+        return link_text_obj(self.external_link(site), link_str or site, style=self.style())
+
     def print_emails(self) -> list[Email]:
         """Print complete emails to or from a particular 'author'. Returns the Emails that were printed."""
-        print_centered(self.info_panel())
+        print_centered(self.info_panel)
         self.print_emails_table()
         last_printed_email_was_duplicate = False
 
-        if self.category() == JUNK:
+        if self.category == JUNK:
             logger.warning(f"Not printing junk emailer '{self.name}'")
         else:
             for email in self._printable_emails():
-                if email.is_duplicate():
-                    console.print(Padding(email.duplicate_file_txt().append('...'), (0, 0, 0, 4)))
+                if email.is_duplicate:
+                    console.print(Padding(email.duplicate_file_txt.append('...'), SKIPPED_FILE_MSG_PADDING))
                     last_printed_email_was_duplicate = True
                 else:
                     if last_printed_email_was_duplicate:
@@ -260,42 +316,18 @@ class Person:
         table = Email.build_emails_table(self._unique_printable_emails(), self.name)
         print_centered(Padding(table, (0, 5, 0, 5)))
 
-        if self.is_linkable():
-            print_centered(self.external_links_line())
+        if self.is_linkable:
+            print_centered(self.external_links_line)
 
         console.line()
 
-    def sort_key(self) -> list[int | str]:
-        counts = [
-            len(self.unique_emails()),
-            -1 * int((self.info_str() or '') == UNINTERESTING_CC_INFO_NO_CONTACT),
-            -1 * int((self.info_str() or '') == UNINTERESTING_CC_INFO),
-            int(self.has_any_epstein_emails()),
-        ]
-
-        counts = [-1 * count for count in counts]
-
-        if args.sort_alphabetical:
-            return [self.name_str()] + counts
-        else:
-            return counts + [self.name_str()]
-
     def style(self, allow_bold: bool = True) -> str:
         return get_style_for_name(self.name, allow_bold=allow_bold)
 
-    def unique_emails(self) -> Sequence[Email]:
-        return Document.without_dupes(self.emails)
-
-    def unique_emails_by(self) -> list[Email]:
-        return Document.without_dupes(self.emails_by())
-
-    def unique_emails_to(self) -> list[Email]:
-        return Document.without_dupes(self.emails_to())
-
     def _printable_emails(self):
         """For Epstein we only want to print emails he sent to himself."""
         if self.name == JEFFREY_EPSTEIN:
-            return [e for e in self.emails if e.is_note_to_self()]
+            return [e for e in self.emails if e.is_note_to_self]
         else:
             return self.emails
 
@@ -303,7 +335,7 @@ class Person:
         return Document.without_dupes(self._printable_emails())
 
     def __str__(self):
-        return f"{self.name_str()}"
+        return f"{self.name_str}"
 
     @staticmethod
     def emailer_info_table(people: list['Person'], highlighted: list['Person'] | None = None, show_epstein_total: bool = False) -> Table:
@@ -312,7 +344,7 @@ class Person:
         highlighted_names = [p.name for p in highlighted]
         is_selection = len(people) != len(highlighted) or args.emailers_info
         all_emails = Person.emails_from_people(people)
-        email_authors = [p for p in people if p.emails_by() and p.name]
+        email_authors = [p for p in people if p.emails_by and p.name]
         attributed_emails = [email for email in all_emails if email.author]
         footer = f"(identified {len(email_authors)} authors of {len(attributed_emails):,}" \
                  f" out of {len(all_emails):,} emails, {len(all_emails) - len(attributed_emails)} still unknown)"
@@ -337,7 +369,7 @@ class Person:
         grey_idx = 0
 
         for person in people:
-            earliest_email_date = person.earliest_email_date()
+            earliest_email_date = person.earliest_email_date
             is_on_page = False if show_epstein_total else person.name in highlighted_names
             year_months = (earliest_email_date.year * 12) + earliest_email_date.month
 
@@ -352,13 +384,13 @@ class Person:
 
             table.add_row(
                 Text(str(earliest_email_date), style=f"grey{GREY_NUMBERS[0 if is_selection else grey_idx]}"),
-                person.internal_link() if is_on_page and not person.is_uninteresting else person.name_txt(),
-                person.category_txt(),
-                f"{len(person.unique_emails() if show_epstein_total else person._unique_printable_emails())}",
-                str(len(person.unique_emails_by())) if len(person.unique_emails_by()) > 0 else '',
-                str(len(person.unique_emails_to())) if len(person.unique_emails_to()) > 0 else '',
-                f"{person.email_conversation_length_in_days()}",
-                person.info_txt() or '',
+                person.internal_link if is_on_page and not person.is_uninteresting else person.name_txt,
+                person.category_txt,
+                f"{len(person.unique_emails if show_epstein_total else person._unique_printable_emails())}",
+                str(len(person.unique_emails_by)) if len(person.unique_emails_by) > 0 else '',
+                str(len(person.unique_emails_to)) if len(person.unique_emails_to) > 0 else '',
+                f"{person.email_conversation_length_in_days}",
+                person.info_txt or '',
                 style='' if show_epstein_total or is_on_page else 'dim',
             )
 
@@ -366,4 +398,4 @@ class Person:
 
     @staticmethod
     def emails_from_people(people: list['Person']) -> Sequence[Email]:
-        return Document.uniquify(flatten([list(p.unique_emails()) for p in people]))
+        return Document.uniquify(flatten([list(p.unique_emails) for p in people]))