docassemble.AssemblyLine 3.1.0__tar.gz → 3.4.0__tar.gz

{docassemble_assemblyline-3.1.0 → docassemble_assemblyline-3.4.0}/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2023 Suffolk Legal Innovation and Technology Lab
+Copyright (c) 2025 Suffolk Legal Innovation and Technology Lab
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{docassemble_assemblyline-3.1.0/docassemble.AssemblyLine.egg-info → docassemble_assemblyline-3.4.0}/PKG-INFO

@@ -1,14 +1,22 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: docassemble.AssemblyLine
-Version: 3.1.0
+Version: 3.4.0
 Home-page: https://courtformsonline.org
 Author: Suffolk Legal Innovation and Technology Lab
 Author-email: qsteenhuis@suffolk.edu
 License: The MIT License (MIT)
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: docassemble.ALToolbox>=0.8.3
-Requires-Dist: docassemble.GithubFeedbackForm>=0.2.1
+Requires-Dist: docassemble.ALToolbox>=0.11.1
+Requires-Dist: docassemble.GithubFeedbackForm>=0.4.1.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
 
 # Suffolk LIT Lab Document Assembly Line
 

docassemble_assemblyline-3.4.0/docassemble/AssemblyLine/__init__.py

@@ -0,0 +1 @@
+__version__ = '3.4.0'

{docassemble_assemblyline-3.1.0 → docassemble_assemblyline-3.4.0}/docassemble/AssemblyLine/al_courts.py

@@ -24,19 +24,28 @@ __all__ = [
 
 
 class ALCourt(Court):
-    """Object representing a court in Massachusetts.
-    TODO: it could be interesting to store a jurisdiction on a court. But this is non-trivial. Should it be geo boundaries?
+    """Object representing a court in Massachusetts. We use a function on the CourtList object that filters courts by
+    address and can use any of those three features of the court to do the filtering.
+
+    <!-- TODO: it could be interesting to store a jurisdiction on a court. But this is non-trivial. Should it be geo boundaries?
     A list of cities? A list of counties? Instead, we use a function on the CourtList object that filters courts by
-    address and can use any of those three features of the court to do the filtering."""
+    address and can use any of those three features of the court to do the filtering.-->
+    """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Create a new court object.
+
+        Args:
+            *pargs: Standard DAObject positional arguments
+            **kwargs: Standard DAObject keyword arguments
+        """
         super().init(*pargs, **kwargs)
         if "address" not in kwargs:
             self.initializeAttribute("address", ALAddress)
         if (
             "jurisdiction" not in kwargs
         ):  # This attribute isn't used. Could be a better way to handle court locating
-            self.jurisdiction = []
+            self.jurisdiction: list = []
         if "location" not in kwargs:
             self.initializeAttribute("location", LatitudeLongitude)
 
@@ -208,7 +217,13 @@ class ALCourtLoader(DAObject):
         converters (Dict[str, Callable]): A dictionary of functions to apply to columns in the dataframe.
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Create a new courtloader object.
+
+        Args:
+            *pargs: Standard DAObject positional arguments
+            **kwargs: Standard DAObject keyword arguments
+        """
         super().init(*pargs, **kwargs)
         self.package = docassemble.base.functions.this_thread.current_question.package
         if not hasattr(self, "filename"):
@@ -240,8 +255,9 @@ class ALCourtLoader(DAObject):
             column_name (str): The name of the column in the dataframe.
 
         Returns:
-            Set[str]: A set containing unique values from the specified column.
-                      Returns an empty set if an error occurs.
+            Set[str]:
+                - A set containing unique values from the specified column.
+                - Returns an empty set if the column does not exist or an error occurs.
         """
         df = self._load_courts()
         try:

{docassemble_assemblyline-3.1.0 → docassemble_assemblyline-3.4.0}/docassemble/AssemblyLine/al_document.py

@@ -35,6 +35,7 @@ from math import floor
 import subprocess
 from collections import ChainMap
 import pikepdf
+from typing import Tuple
 
 __all__ = [
     "ALAddendumField",
@@ -247,7 +248,13 @@ class ALAddendumField(DAObject):
         The attributes `headers` and `field_style` are planned for future releases and are not currently implemented.
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super().init(*pargs, **kwargs)
 
     def overflow_value(
@@ -751,7 +758,13 @@ class ALAddendumFieldDict(DAOrderedDict):
                      only the overflow text will be displayed.
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super(ALAddendumFieldDict, self).init(*pargs, **kwargs)
         self.object_type = ALAddendumField
         self.auto_gather = False
@@ -989,7 +1002,13 @@ class ALDocument(DADict):
         ```
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super(ALDocument, self).init(*pargs, **kwargs)
         self.initializeAttribute("overflow_fields", ALAddendumFieldDict)
         if not hasattr(self, "default_overflow_message"):
@@ -1344,7 +1363,13 @@ class ALStaticDocument(DAStaticFile):
         Consider handling files in `/data/templates` if deemed useful, potentially by copying into a DAFile using `pdf_concatenate()`.
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super().init(*pargs, **kwargs)
         self.has_addendum = False
         self.auto_gather = False
@@ -1514,7 +1539,13 @@ class ALDocumentBundle(DAList):
         ```
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super().init(*pargs, **kwargs)
         if "auto_gather" not in kwargs:
             self.auto_gather = False
@@ -1822,6 +1853,107 @@ class ALDocumentBundle(DAList):
                 editable.append(doc)
         return editable
 
+    def get_cacheable_documents(
+        self,
+        key: str = "final",
+        pdf: bool = True,
+        docx: bool = False,
+        original: bool = False,
+        refresh: bool = True,
+        pdfa: bool = False,
+        include_zip: bool = True,
+        include_full_pdf: bool = False,
+        append_matching_suffix: bool = True,
+    ) -> Tuple[List[Dict[str, DAFile]], Optional[DAFile], Optional[DAFile]]:
+        """
+        Generates a cache of all enabled documents in the bundle, and returns it in a structure that can be cached
+        and returned for use in a background process.
+
+        The result looks like this:
+
+        [
+            {"title": "Document 1", "pdf": DAFile, "docx": DAFile, download_filename: str},
+        ],
+        DAFile, # Zip of whole bundle
+        DAFile # PDF of whole bundle
+
+        Args:
+            key (str): Identifier for the document version, default is "final".
+            pdf (bool): Flag to include a PDF version of each file, default is True.
+            docx (bool): Flag to include a DOCX version of each file, default is False.
+            original (bool): Flag to include the original version of each file, default is False.
+            refresh (bool): Flag to reconsider the 'enabled' attribute, default is True.
+            pdfa (bool): Flag to return documents in PDF/A format, default is False.
+            include_zip (bool): Flag to include a zip option, default is True.
+            include_full_pdf (bool): Flag to include a PDF version of the whole bundle, default is False.
+            append_matching_suffix (bool): Flag to determine if matching suffix should be appended to file name, default is True.
+
+        Returns:
+            Tuple[List[Dict[str, DAFile]], Optional[DAFile], Optional[DAFile]]: A list of dictionaries containing the enabled documents, a zip file of the whole bundle, and a PDF of the whole
+        """
+        # reduce idempotency delays
+        enabled_docs = self.enabled_documents(refresh=refresh)
+        for doc in enabled_docs:
+            doc.title
+
+        results = []
+
+        for doc in enabled_docs:
+            result = {"title": doc.title}
+            filename_root = os.path.splitext(str(doc.filename))[0]
+            if pdf:
+                result["pdf"] = doc.as_pdf(
+                    key=key,
+                    refresh=refresh,
+                    pdfa=pdfa,
+                    append_matching_suffix=append_matching_suffix,
+                )
+                result["download_filename"] = filename_root + ".pdf"
+            if docx and doc._is_docx(key=key):
+                result["docx"] = doc.as_docx(
+                    key=key,
+                    refresh=refresh,
+                    append_matching_suffix=append_matching_suffix,
+                )
+                result["download_filename"] = filename_root + ".docx"
+            if original:
+                result["original"] = doc[key]
+                result["download_filename"] = doc.filename
+
+            try:
+                # If it's possible, set the file extension to the actual filetype
+                # This is mostly necessary if people omit the file extension in attachment block
+                # for filetype="original"
+                if original:
+                    download_doc = result["original"]
+                else:
+                    download_doc = result["docx"]
+                ext = next(
+                    iter(
+                        mimetypes.guess_all_extensions(
+                            download_doc.mimetype, strict=True
+                        )
+                    )
+                )
+                result["download_filename"] = filename_root + ext
+            except:
+                pass
+            results.append(result)
+
+        if len(enabled_docs) > 1 and include_zip:
+            bundled_zip = self.as_zip(
+                key=key, format="original" if original else "docx" if docx else "pdf"
+            )
+        else:
+            bundled_zip = None
+
+        if len(enabled_docs) > 1 and include_full_pdf:
+            bundled_pdf = self.as_pdf(key=key, pdfa=pdfa)
+        else:
+            bundled_pdf = None
+
+        return results, bundled_zip, bundled_pdf
+
     def download_list_html(
         self,
         key: str = "final",
@@ -1834,10 +1966,16 @@ class ALDocumentBundle(DAList):
         view_icon: str = "eye",
         download_label: str = "Download",
         download_icon: str = "download",
+        send_label: str = "Send",
+        send_icon: str = "envelope",
         zip_label: Optional[str] = None,
         zip_icon: str = "file-archive",
+        zip_row_label: Optional[str] = "",
         append_matching_suffix: bool = True,
         include_email: bool = False,
+        use_previously_cached_files: bool = False,
+        include_full_pdf: bool = False,
+        full_pdf_label: Optional[str] = None,
     ) -> str:
         """
         Constructs an HTML table displaying a list of documents with 'view' and 'download' buttons.
@@ -1853,10 +1991,17 @@ class ALDocumentBundle(DAList):
             view_icon (str): Icon for the 'view' button, default is "eye".
             download_label (str): Label for the 'download' button, default is "Download".
             download_icon (str): Icon for the 'download' button, default is "download".
+            send_label (str): Label for the 'send' button. Default is "Send".
+            send_icon (str): Fontawesome icon for the 'send' button. Default is "envelope".
             zip_label (Optional[str]): Label for the zip option. If not provided, uses the generic template for `self.zip_label` ("Download all").
             zip_icon (str): Icon for the zip option, default is "file-archive".
+            zip_row_label (str, optional): Text to go in the left-most column
+                of the table's zip row. Will default to the value of `self.title`.
             append_matching_suffix (bool): Flag to determine if matching suffix should be appended to file name, default is True.
-            include_email (bool): Flag to include an email option, default is False.
+            include_email (bool): Flag to include an option, default is False.
+            use_previously_cached_files (bool): Flag to use previously cached files (e.g., made in background) if defined. default is False.
+            include_full_pdf (bool): Flag to include a full PDF option, default is False.
+            full_pdf_label (Optional[str]): Label for the full PDF option. If not provided, uses the generic template for `self.full_pdf_label` ("Download all").
 
         Returns:
             str: HTML representation of a table with documents and their associated actions.
@@ -1864,52 +2009,40 @@ class ALDocumentBundle(DAList):
         if not hasattr(self, "_cached_zip_label"):
             self._cached_zip_label = str(self.zip_label)
 
-        # Trigger some variables up top to avoid idempotency issues
-        enabled_docs = self.enabled_documents(refresh=refresh)
-        for doc in enabled_docs:
-            doc.title
-            if format == "pdf":
-                doc.as_pdf(
-                    key=key,
-                    refresh=refresh,
-                    pdfa=pdfa,
-                    append_matching_suffix=append_matching_suffix,
-                )  # Generate cached file for this session
+        if not hasattr(self, "_cached_full_pdf_label"):
+            self._cached_full_pdf_label = str(self.full_pdf_label)
+
+        if use_previously_cached_files and hasattr(self, "_downloadable_files"):
+            downloadable_files, bundled_zip, bundled_pdf = self._downloadable_files
+        else:
+            downloadable_files, bundled_zip, bundled_pdf = self.get_cacheable_documents(
+                key=key,
+                pdf=(format == "pdf" or view == True),
+                docx=format == "docx",
+                original=format == "original",
+                refresh=refresh,
+                pdfa=pdfa,
+                include_zip=include_zip,
+                include_full_pdf=include_full_pdf,
+                append_matching_suffix=append_matching_suffix,
+            )
 
         html = f'<div class="container al_table al_doc_table" id="{ html_safe_str(self.instanceName) }">'
 
-        for doc in enabled_docs:
-            filename_root = os.path.splitext(str(doc.filename))[0]
-            # Do our best to use the provided filename + the extension from requested filetype
-            if format == "original":
-                download_doc = doc[key]
-                download_filename = doc.filename
-            if format == "docx" and doc._is_docx(key=key):
-                download_doc = doc.as_docx(
-                    key=key, append_matching_suffix=append_matching_suffix
-                )
-                download_filename = filename_root + ".docx"
-            else:
-                download_doc = doc.as_pdf(
-                    key=key, append_matching_suffix=append_matching_suffix
-                )
-                download_filename = filename_root + ".pdf"
+        for result in downloadable_files:
+            title = result["title"]
+            download_filename = result.get("download_filename", "document")
 
-            try:
-                # If it's possible, set the file extension to the actual filetype
-                # This is mostly necessary if people omit the file extension in attachment block
-                # for filetype="original"
-                ext = next(
-                    iter(
-                        mimetypes.guess_all_extensions(
-                            download_doc.mimetype, strict=True
-                        )
-                    )
-                )
-                download_filename = filename_root + ext
-            except:
-                pass
+            if format == "original" and "original" in result:
+                download_doc = result["original"]
+            elif format == "docx" and "docx" in result:
+                download_doc = result["docx"]
+            elif "pdf" in result:
+                download_doc = result["pdf"]
+            else:
+                continue  # Skip if the desired format is not available
 
+            # Construct the download button
             doc_download_button = action_button_html(
                 download_doc.url_for(
                     attachment=True, display_filename=download_filename
@@ -1920,12 +2053,14 @@ class ALDocumentBundle(DAList):
                 size="md",
                 classname="al_download al_button",
             )
-            if view and doc.as_pdf().url_for().endswith(".pdf"):
+
+            # Construct the view button if needed
+            if view and "pdf" in result and result["pdf"].url_for().endswith(".pdf"):
+                # Use .pdf as the filename extension
+                view_filename = os.path.splitext(download_filename)[0] + ".pdf"
                 doc_view_button = action_button_html(
-                    doc.as_pdf(key=key).url_for(
-                        attachment=False,
-                        display_filename=filename_root + ".pdf",
-                        append_matching_suffix=append_matching_suffix,
+                    result["pdf"].url_for(
+                        attachment=False, display_filename=view_filename
                     ),
                     label=view_label,
                     icon=view_icon,
@@ -1936,31 +2071,52 @@ class ALDocumentBundle(DAList):
                 buttons = [doc_view_button, doc_download_button]
             else:
                 buttons = [doc_download_button]
-            html += table_row(doc.title, buttons)
 
-        # Add a zip file row if there's more than one doc
-        filename_root = os.path.splitext(str(self.filename))[0]
-        if len(enabled_docs) > 1 and include_zip:
+            html += table_row(title, buttons)
+
+        # Add a zip file row if included
+        if include_zip and bundled_zip:
             if not zip_label:
                 zip_label = self._cached_zip_label
-            # Zip file will match the format of the download table
-            zip = self.as_zip(key=key, format=format, include_pdf=view)
+            filename_root = os.path.splitext(str(self.filename))[0]
             zip_button = action_button_html(
-                zip.url_for(attachment=False, display_filename=filename_root + ".zip"),
+                bundled_zip.url_for(
+                    attachment=False, display_filename=filename_root + ".zip"
+                ),
                 label=zip_label,
                 icon=zip_icon,
                 color="primary",
                 size="md",
                 classname="al_zip al_button",
             )
-            html += table_row(zip.title, zip_button)
+            safe_zip_row_label: str = (
+                zip_row_label or (hasattr(self, "title") and self.title) or zip_label
+            )
+            html += table_row(safe_zip_row_label, zip_button)
+
+        if include_full_pdf and bundled_pdf:
+            if not full_pdf_label:
+                full_pdf_label = self._cached_full_pdf_label
+            filename_root = os.path.splitext(str(self.filename))[0]
+            full_pdf_button = action_button_html(
+                bundled_pdf.url_for(
+                    attachment=False, display_filename=filename_root + ".pdf"
+                ),
+                label=full_pdf_label,
+                icon="file-pdf",
+                color="primary",
+                size="md",
+                classname="al_full_pdf al_button",
+            )
+            html += table_row(full_pdf_label, full_pdf_button)
 
         if include_email:
-            html += self.send_email_table_row(key=key)
+            html += self.send_email_table_row(
+                key=key, send_label=send_label, send_icon=send_icon
+            )
 
         html += "\n</div>"
 
-        # Discuss: Do we want a table with the ability to have a merged pdf row?
         return html
 
     def download_html(
@@ -2036,13 +2192,17 @@ class ALDocumentBundle(DAList):
 
         return html
 
-    def send_email_table_row(self, key: str = "final") -> str:
+    def send_email_table_row(
+        self, key: str = "final", send_label: str = "Send", send_icon: str = "envelope"
+    ) -> str:
         """
         Generate HTML doc table row for an input box and button that allows
         someone to send the bundle to the specified email address.
 
         Args:
             key (str): A key used to identify which version of the ALDocument to send. Defaults to "final".
+            send_label (str): Label for the 'send' button. Default is "Send".
+            send_icon (str): Icon for the 'send' button. Default is "envelope".
 
         Returns:
             str: The generated HTML string for the table row.
@@ -2075,7 +2235,7 @@ class ALDocumentBundle(DAList):
         """
 
         # "Send" button for the 2nd column of the table row
-        send_button = f'{action_button_html(javascript_string, label="Send", icon="envelope", color="primary", size="md", classname="al_send_email_button al_button", id_tag=al_send_button_id)}'
+        send_button = f'{action_button_html(javascript_string, label=send_label, icon=send_icon, color="primary", size="md", classname="al_send_email_button al_button", id_tag=al_send_button_id)}'
 
         # Whole row put together
         html = f"""
@@ -2147,6 +2307,8 @@ class ALDocumentBundle(DAList):
         key: str = "final",
         show_editable_checkbox: bool = True,
         template_name: str = "",
+        label: str = "Send",
+        icon: str = "envelope",
     ) -> str:
         """
         Generate HTML for an input box and button that allows someone to send the bundle
@@ -2162,6 +2324,9 @@ class ALDocumentBundle(DAList):
                 Defaults to True.
             template_name (str, optional): Name of the template variable that is used to fill
                 the email contents. By default, the `x.send_email_template` template will be used.
+            label (str, optional): The label for the button. Defaults to "Send".
+            icon (str, optional): The Fontawesome icon for the button. Defaults
+                to "envelope".
 
         Returns:
             str: The generated HTML string for the input box and button.
@@ -2213,7 +2378,7 @@ class ALDocumentBundle(DAList):
       <input value="{user_info().email if user_logged_in() else ''}" alt="Email address for document" class="form-control" type="email" size="35" name="{al_email_input_id}" id="{al_email_input_id}">
     </span>
     
-    {action_button_html(javascript_string, label="Send", icon="envelope", color="primary", size="md", classname="al_send_email_button", id_tag=al_send_button_id)}
+    {action_button_html(javascript_string, label=label, icon=icon, color="primary", size="md", classname="al_send_email_button", id_tag=al_send_button_id)}
 
   </div>
   """
@@ -2382,7 +2547,13 @@ class ALExhibit(DAObject):
         starting_page (int): first page number to use in table of contents
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super().init(*pargs, **kwargs)
         self.initializeAttribute("_cache", DALazyAttribute)
         self.object_type = DAFileList
@@ -2602,7 +2773,13 @@ class ALExhibitList(DAList):
         auto_ocr (bool): If True, automatically starts OCR processing for uploaded exhibits. Defaults to True.
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super().init(*pargs, **kwargs)
         if not hasattr(self, "auto_label"):
             self.auto_label = True
@@ -2780,7 +2957,25 @@ class ALExhibitDocument(ALDocument):
     ```
     """
 
-    def init(self, *pargs, **kwargs):
+    include_exhibit_cover_pages: bool
+    include_table_of_contents: bool
+    add_page_numbers: bool
+    has_addendum: bool
+    auto_labeler: Callable
+    auto_ocr: bool
+    bates_prefix: str
+    maximum_size: int
+    suffix_to_append: str
+    exhibits: ALExhibitList
+    table_of_contents: DAFile
+
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super().init(*pargs, **kwargs)
         self.initializeAttribute("exhibits", ALExhibitList)
         if hasattr(self, "auto_labeler"):
@@ -2931,7 +3126,13 @@ class ALTableDocument(ALDocument):
         table (???): Represents the actual table data. Type and attributes need more context to document.
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super().init(*pargs, **kwargs)
         self.has_addendum = False
         if not hasattr(self, "suffix_to_append"):
@@ -3042,7 +3243,13 @@ class ALUntransformedDocument(ALDocument):
         suffix_to_append (str): Suffix that can be appended to file names, defaulting to "preview".
     """
 
-    def init(self, *pargs, **kwargs):
+    def init(self, *pargs, **kwargs) -> None:
+        """Standard DAObject init method.
+
+        Args:
+            *pargs: Positional arguments
+            **kwargs: Keyword arguments
+        """
         super().init(*pargs, **kwargs)
         self.has_addendum = False
         if not hasattr(self, "suffix_to_append"):