docassemble.AssemblyLine 3.5.0__tar.gz → 4.0.0__tar.gz

{docassemble_assemblyline-3.5.0/docassemble.AssemblyLine.egg-info → docassemble_assemblyline-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docassemble.AssemblyLine
-Version: 3.5.0
+Version: 4.0.0
 Home-page: https://courtformsonline.org
 Author: Suffolk Legal Innovation and Technology Lab
 Author-email: qsteenhuis@suffolk.edu

docassemble_assemblyline-4.0.0/docassemble/AssemblyLine/__init__.py

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

{docassemble_assemblyline-3.5.0 → docassemble_assemblyline-4.0.0}/docassemble/AssemblyLine/al_document.py

@@ -36,6 +36,9 @@ import subprocess
 from collections import ChainMap
 import pikepdf
 from typing import Tuple
+import secrets
+import string
+
 
 __all__ = [
     "ALAddendumField",
@@ -59,6 +62,22 @@ __all__ = [
 DEBUG_MODE = get_config("debug")
 
 
+def random_suffix(length: int = 8) -> str:
+    """Return a random string for use in unique IDs.
+
+    Note: this is powerful enough for the expected usecase of distinguishing a few
+    HTML elements from each other, but not cryptographically secure or as strong as
+    a true GUID.
+
+    Args:
+        length (int): The length of the random string to generate. Defaults to 8.
+    Returns:
+        str: A random string of lowercase letters and digits.
+    """
+    alphabet = string.ascii_lowercase + string.digits
+    return "".join(secrets.choice(alphabet) for _ in range(length))
+
+
 def base_name(filename: str) -> str:
     """
     Extracts the base name of a file without its extension.
@@ -1653,8 +1672,8 @@ class ALDocumentBundle(DAList):
         refresh: bool = True,
         pdfa: bool = False,
         title: str = "",
-        format="pdf",
-        include_pdf=True,
+        format: Optional[str] = "pdf",
+        include_pdf: Optional[bool] = True,
     ) -> DAFile:
         """
         Returns a zip file containing all enabled documents in the bundle in the specified format.
@@ -1670,6 +1689,11 @@ class ALDocumentBundle(DAList):
         Returns:
             DAFile: A zip file containing the enabled documents.
         """
+        if format is None:
+            format = "pdf"
+
+        if include_pdf is None:
+            include_pdf = True
 
         zip_key = f"{ space_to_underscore( key )}_zip"
 
@@ -1679,6 +1703,7 @@ class ALDocumentBundle(DAList):
 
         # strip out a possible '.pdf' ending then add '.zip'
         zipname = os.path.splitext(self.filename)[0]
+
         if format == "docx":
             docs = []
             for doc in self.enabled_documents(refresh=refresh):
@@ -1864,6 +1889,8 @@ class ALDocumentBundle(DAList):
         include_zip: bool = True,
         include_full_pdf: bool = False,
         append_matching_suffix: bool = True,
+        zip_include_pdf: Optional[bool] = None,
+        zip_format: Optional[str] = None,
     ) -> 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
@@ -1887,6 +1914,8 @@ class ALDocumentBundle(DAList):
             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.
+            zip_include_pdf (Optional[bool]): If True, includes a PDF version in the zip file even if original is in DOCX format.
+            zip_format (Optional[str]): Format of the primary version of each document.
 
         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
@@ -1940,9 +1969,14 @@ class ALDocumentBundle(DAList):
                 pass
             results.append(result)
 
+        if zip_format is None:
+            zip_format = "original" if original else "docx" if docx else "pdf"
+
         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"
+                key=key,
+                format=zip_format,
+                include_pdf=zip_include_pdf,
             )
         else:
             bundled_zip = None
@@ -1976,6 +2010,8 @@ class ALDocumentBundle(DAList):
         use_previously_cached_files: bool = False,
         include_full_pdf: bool = False,
         full_pdf_label: Optional[str] = None,
+        zip_include_pdf: Optional[bool] = True,
+        zip_format: Optional[str] = None,
     ) -> str:
         """
         Constructs an HTML table displaying a list of documents with 'view' and 'download' buttons.
@@ -2002,6 +2038,8 @@ class ALDocumentBundle(DAList):
             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").
+            zip_include_pdf (Optional[bool]): Flag to include PDF files in the zip archive, default is True. If `None` value of `view` will be used.
+            zip_format (Optional[str]): Format of the files in the zip archive. If None, defaults to value of "format" parameter.
 
         Returns:
             str: HTML representation of a table with documents and their associated actions.
@@ -2012,6 +2050,12 @@ class ALDocumentBundle(DAList):
         if not hasattr(self, "_cached_full_pdf_label"):
             self._cached_full_pdf_label = str(self.full_pdf_label)
 
+        if zip_format is None:
+            zip_format = format
+
+        if zip_include_pdf is None:
+            zip_include_pdf = view
+
         if use_previously_cached_files and hasattr(self, "_downloadable_files"):
             downloadable_files, bundled_zip, bundled_pdf = self._downloadable_files
         else:
@@ -2025,6 +2069,8 @@ class ALDocumentBundle(DAList):
                 include_zip=include_zip,
                 include_full_pdf=include_full_pdf,
                 append_matching_suffix=append_matching_suffix,
+                zip_include_pdf=zip_include_pdf,
+                zip_format=zip_format,
             )
 
         html = f'<div class="container al_table al_doc_table" id="{ html_safe_str(self.instanceName) }">'
@@ -2215,7 +2261,7 @@ class ALDocumentBundle(DAList):
             self._cached_include_editable_documents = str(
                 self.include_editable_documents
             )
-        name = html_safe_str(self.instanceName)
+        name = html_safe_str(self.instanceName) + random_suffix()
         al_wants_editable_input_id = "_ignore_al_wants_editable_" + name
         al_email_input_id = "_ignore_al_doc_email_" + name
         al_send_button_id = "al_send_email_button_" + name
@@ -2250,12 +2296,13 @@ class ALDocumentBundle(DAList):
     def send_button_to_html(
         self,
         email: str,
-        editable: bool = False,
+        editable: Optional[bool] = None,
         template_name: str = "",
         label: str = "Send",
         icon: str = "envelope",
         color: str = "primary",
         key: str = "final",
+        preferred_formats: Optional[Union[str, List[str]]] = None,
     ) -> str:
         """
         Generate HTML for a button that allows someone to send the bundle to a
@@ -2264,12 +2311,13 @@ class ALDocumentBundle(DAList):
 
         Args:
             email (str): The recipient's email address.
-            editable (bool, optional): Flag indicating if the bundle is editable. Defaults to False.
+            editable (bool, optional): Flag indicating if the bundle is editable. Defaults to False. (deprecated; use preferred_formats instead)
             template_name (str, optional): The name of the template to be used. Defaults to an empty string.
             label (str, optional): The label for the button. Defaults to "Send".
             icon (str, optional): The Fontawesome icon for the button. Defaults to "envelope".
             color (str, optional): The Bootstrap color of the button. Defaults to "primary".
             key (str, optional): A key used to identify which version of the ALDocument to send. Defaults to "final".
+            preferred_formats (Optional[Union[str,List[str]]], optional): A list of allowed formats for the document. Defaults to "pdf" if not specified.
 
         Returns:
             str: The generated HTML string for the button.
@@ -2278,9 +2326,16 @@ class ALDocumentBundle(DAList):
             return ""  # Don't let people email an empty set of documents
         if not hasattr(self, "_cached_get_email_copy"):
             self._cached_get_email_copy = str(self.get_email_copy)
-        name = html_safe_str(self.instanceName)
+        name = html_safe_str(self.instanceName) + random_suffix()
         al_send_button_id = "al_send_email_to_button_" + name
 
+        if isinstance(preferred_formats, (list, tuple)):
+            formats_js = "[" + ",".join(f"'{fmt}'" for fmt in preferred_formats) + "]"
+        elif preferred_formats:
+            formats_js = f"'{preferred_formats}'"
+        else:
+            formats_js = "null"
+
         javascript_string = (
             f"javascript:aldocument_send_to_action("
             f"'{self.attr_name('send_email_to_action_event')}',"
@@ -2288,7 +2343,9 @@ class ALDocumentBundle(DAList):
             f"'{email}',"
             f"'{al_send_button_id}',"
             f"'{template_name}',"
-            f"'{key}')"
+            f"'{key}',"
+            f"{formats_js}"
+            f")"
         )
         send_button = action_button_html(
             javascript_string,
@@ -2309,6 +2366,7 @@ class ALDocumentBundle(DAList):
         template_name: str = "",
         label: str = "Send",
         icon: str = "envelope",
+        preferred_formats: Optional[Union[str, List[str]]] = None,
     ) -> str:
         """
         Generate HTML for an input box and button that allows someone to send the bundle
@@ -2321,12 +2379,13 @@ class ALDocumentBundle(DAList):
             key (str, optional): A key used to identify which version of the ALDocument to send. Defaults to "final".
             show_editable_checkbox (bool, optional): Flag indicating if the checkbox
                 for deciding the inclusion of an editable (Word) copy should be displayed.
-                Defaults to True.
+                Defaults to True. If preferred_formats = ["pdf"], this will be ignored and no checkbox will be shown.
             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".
+            preferred_formats (Optional[Union[str,List[str]]], optional): A list of allowed formats for the document. Defaults to "pdf" if not specified.
 
         Returns:
             str: The generated HTML string for the input box and button.
@@ -2339,31 +2398,52 @@ class ALDocumentBundle(DAList):
             self._cached_include_editable_documents = str(
                 self.include_editable_documents
             )
-        name = html_safe_str(self.instanceName)
+
+        if isinstance(preferred_formats, str):
+            preferred_formats = [preferred_formats]
+
+        if not preferred_formats:
+            preferred_formats = ["pdf", "docx"] if show_editable_checkbox else ["pdf"]
+
+        name = html_safe_str(self.instanceName) + random_suffix()
         al_wants_editable_input_id = "_ignore_al_wants_editable_" + name
         al_email_input_id = "_ignore_al_doc_email_" + name
         al_send_button_id = "al_send_email_button_" + name
 
+        if isinstance(preferred_formats, (list, tuple)):
+            formats_js = "[" + ",".join(f"'{fmt}'" for fmt in preferred_formats) + "]"
+        elif preferred_formats:
+            formats_js = f"'{preferred_formats}'"
+        else:
+            formats_js = "null"
+
         javascript_string = (
             f"javascript:aldocument_send_action("
             f"'{self.attr_name('send_email_action_event')}',"
             f"'{al_wants_editable_input_id}',"
             f"'{al_email_input_id}',"
             f"'{template_name}',"
-            f"'{key}')"
+            f"'{key}',"
+            f"{formats_js}"
+            ")"
         )
 
         # Container of whole email section with header
         return_str = f"""
-  <fieldset class="al_send_bundle al_send_section_alone {name}" id="al_send_bundle_{name}" name="al_send_bundle_{name}">
+  <fieldset class="al_send_bundle al_send_section_alone {html_safe_str(self.instanceName)}" id="al_send_bundle_{name}" name="al_send_bundle_{name}">
     <legend class="h4 al_doc_email_header">{self._cached_get_email_copy}</legend> 
     """
         # "Editable" checkbox
-        if show_editable_checkbox:
+        if (
+            show_editable_checkbox
+            and preferred_formats
+            and isinstance(preferred_formats, list)
+            and len(preferred_formats) > 1
+        ):  # Do not need to show if only one valid format allowed
             return_str += f"""
     <div class="form-check-container">
       <div class="form-check">
-        <input class="form-check-input" type="checkbox" class="al_wants_editable" id="{al_wants_editable_input_id}">
+        <input class="form-check-input al_wants_editable" type="checkbox" id="{al_wants_editable_input_id}">
         <label class="al_wants_editable form-check-label" for="{al_wants_editable_input_id}">{self._cached_include_editable_documents}
         </label>
       </div>
@@ -2373,7 +2453,7 @@ class ALDocumentBundle(DAList):
         return_str += f"""
   <div class="al_email_container">
   
-    <span class="al_email_address {name} container form-group row da-field-container da-field-container-datatype-email">
+    <span class="al_email_address {html_safe_str(self.instanceName)} container form-group row da-field-container da-field-container-datatype-email">
       <label for="{al_email_input_id}" class="col-form-label da-form-label datext-right">Email</label>
       <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>
@@ -2389,8 +2469,9 @@ class ALDocumentBundle(DAList):
         self,
         to: Any = None,
         key: str = "final",
-        editable: bool = False,
-        template: Any = None,
+        editable: Optional[bool] = None,
+        template: Optional[Any] = None,
+        preferred_formats: Optional[Union[str, List[str]]] = "pdf",
         **kwargs,
     ) -> bool:
         """
@@ -2399,39 +2480,54 @@ class ALDocumentBundle(DAList):
         https://docassemble.org/docs/functions.html#send_email with additional parameters.
 
         Args:
-            to (Any): The email address or list of addresses to send to. It can be a string
-                or objects with such. Similar to da send_email `to`.
+            to (Any): The email address, list of email addresses, or list of Individuals with a .email attribute to send to.
             key (str, optional): Specifies which version of the document to send. Defaults to "final".
-            editable (bool, optional): If True, sends the editable documents. Defaults to False.
-            template (Any): The template variable, similar to da `send_email` `template` variable.
+            editable (bool, optional): If True, sends the editable documents. Defaults to False. (Deprecated)
+            template (Any): The template variable for the subject and body of the email, similar to da `send_email` `template` variable.
+            preferred_formats (str): Specifies the format of the files to send. Can be "pdf" or "docx", or a list of these formats. Overrides deprecated `editable` keyword.
             **kwargs: Additional parameters to pass to the da `send_email` function.
 
         Returns:
             bool: Indicates if the email was sent successfully.
         """
-        if not template:
+        if editable is not None:
+            log(
+                "The 'editable' parameter is deprecated; use 'preferred_formats' instead."
+            )
+
+        if template is None:
             template = self.send_email_template
 
-        if editable:
-            return send_email(
-                to=to,
-                template=template,
-                # Add both DOCX and PDF versions, but if it's not possible to be a DOCX don't add the PDF
-                # twice
-                attachments=list(
-                    dict.fromkeys(
-                        self.as_editable_list(key=key) + self.as_pdf_list(key=key)
-                    )
-                ),
-                **kwargs,
-            )
-        else:
-            return send_email(
-                to=to,
-                template=template,
-                attachments=self.as_pdf_list(key=key),
-                **kwargs,
-            )
+        if preferred_formats is None:
+            preferred_formats = ["docx", "pdf"] if editable else ["pdf"]
+
+        if isinstance(preferred_formats, str):
+            preferred_formats = [preferred_formats]
+
+        allowed = {fmt.lower() for fmt in preferred_formats}
+        attachments = []
+
+        for item in self.enabled_documents():
+            primary = None
+
+            if "docx" in allowed:
+                primary = item.as_docx(key=key)
+                attachments.append(primary)
+
+            if "pdf" in allowed:
+                if not (
+                    primary
+                    and hasattr(primary, "extension")
+                    and primary.extension == "pdf"
+                ):
+                    attachments.append(item.as_pdf(key=key))
+
+        return send_email(
+            to=to,
+            template=template,
+            attachments=attachments,
+            **kwargs,
+        )
 
     def _is_self_enabled(self, refresh=True) -> bool:
         """

{docassemble_assemblyline-3.5.0 → docassemble_assemblyline-4.0.0}/docassemble/AssemblyLine/al_general.py

@@ -1,5 +1,5 @@
 from copy import deepcopy
-from typing import Dict, List, Literal, Union, Optional, Any
+from typing import Callable, Dict, List, Literal, Union, Optional, Any
 from docassemble.base.util import (
     Address,
     as_datetime,
@@ -21,7 +21,6 @@ from docassemble.base.util import (
     Individual,
     IndividualName,
     its,
-    name_suffix,
     phone_number_formatted,
     phone_number_is_valid,
     showifdef,
@@ -32,8 +31,11 @@ from docassemble.base.util import (
     this_thread,
     url_action,
     validation_error,
+    value,
     word,
     your,
+    log,
+    value,
 )
 import random
 import re
@@ -1068,9 +1070,11 @@ class ALIndividual(Individual):
         person_or_business: str = "person",
         show_suffix: bool = True,
         show_title: bool = False,
-        title_options: Optional[List[str]] = None,
+        title_choices: Optional[Union[List[str], Callable]] = None,
         show_if: Union[str, Dict[str, str], None] = None,
         maxlengths: Optional[Dict[str, int]] = None,
+        suffix_choices: Optional[Union[List[str], Callable]] = None,
+        title_options: Optional[Union[List[str], Callable]] = None,
     ) -> List[Dict[str, str]]:
         """
         Generates suitable field prompts for a name based on the type of entity (person or business)
@@ -1083,11 +1087,13 @@ class ALIndividual(Individual):
                 Default is True.
             show_title: (bool, optional): Determines if the name's title (e.g., Mr., Ms.) should be included in the prompts.
                 Default is False.
-            title_options (List[str], optional): A list of title options to use in the prompts. Default is defined as a list
-                of common titles in English-speaking countries.
+            title_choices (Union[List[str], Callable], optional): A list or callable of title options to use in the prompts. Default is defined as a list
+                of common titles in English-speaking countries, or overridden by value of global `al_name_titles`.
             show_if (Union[str, Dict[str, str], None], optional): Condition to determine which fields to show.
                 It can be a string, a dictionary with conditions, or None. Default is None.
             maxlengths (Dict[str, int], optional): A dictionary of field names and their maximum lengths. Default is None.
+            suffix_choices (Union[List[str], Callable], optional): A list of suffix options or a callable to generate suffix options, or overridden by value of global `al_name_suffixes`.
+            title_options: (Union[List[str], Callable], optional): Deprecated parameter, use `title_choices` instead. If provided, it will be used to set the title choices.
 
         Returns:
             List[Dict[str, str]]: A list of dictionaries where each dictionary contains field prompt details.
@@ -1096,29 +1102,23 @@ class ALIndividual(Individual):
             If `person_or_business` is set to None, the method will offer the end user a choice
             and will set appropriate "show ifs" conditions for each type.
         """
-        if not title_options:
-            title_options = [
-                "Mr.",
-                "Mrs.",
-                "Miss",
-                "Ms.",
-                "Mx.",
-                "Dr.",
-                "Prof.",
-                "Hon.",
-                "Rev.",
-                "Sir",
-                "Lord",
-                "Lady",
-                "Dame",
-                "Maj.",
-                "Gen.",
-                "Capt.",
-                "Lt.",
-                "Sgt.",
-                "Fr.",
-                "Sr.",
-            ]
+        if title_options:
+            log(
+                "title_options parameter to name_fields() is deprecated: use title_choices instead"
+            )
+            title_choices = title_options
+
+        if not suffix_choices:
+            suffix_choices = value("al_name_suffixes")
+        if callable(suffix_choices):
+            suffix_choices = suffix_choices()
+
+        if not title_choices:
+            title_choices = value("al_name_titles")
+
+        if callable(title_choices):
+            title_choices = title_choices()
+
         if person_or_business == "person":
             fields = [
                 {
@@ -1140,7 +1140,7 @@ class ALIndividual(Individual):
                     {
                         "label": str(self.suffix_label),
                         "field": self.attr_name("name.suffix"),
-                        "choices": name_suffix(),
+                        "choices": suffix_choices,
                         "required": False,
                     }
                 )
@@ -1150,7 +1150,7 @@ class ALIndividual(Individual):
                     {
                         "label": str(self.name_title_label),
                         "field": self.attr_name("name.title"),
-                        "choices": title_options,
+                        "choices": title_choices,
                         "required": False,
                     },
                 )
@@ -1159,8 +1159,6 @@ class ALIndividual(Individual):
                     field["show if"] = show_if
             return fields
         elif person_or_business == "business":
-            # Note: we don't make use of the name.text field for simplicity
-            # TODO: this could be reconsidered`, but name.text tends to lead to developer error
             fields = [
                 {
                     "label": str(self.business_name_label),
@@ -1218,7 +1216,7 @@ class ALIndividual(Individual):
                     {
                         "label": str(self.suffix_label),
                         "field": self.attr_name("name.suffix"),
-                        "choices": name_suffix(),
+                        "choices": suffix_choices,
                         "required": False,
                         "show if": show_if_indiv,
                     }
@@ -1286,6 +1284,7 @@ class ALIndividual(Individual):
         show_help=False,
         show_if: Union[str, Dict[str, str], None] = None,
         maxlengths: Optional[Dict[str, int]] = None,
+        choices: Optional[Union[List[Dict[str, str]], Callable]] = None,
     ) -> List[Dict[str, str]]:
         """
         Generate fields for capturing gender information, including a
@@ -1295,18 +1294,26 @@ class ALIndividual(Individual):
             show_help (bool): Whether to show additional help text. Defaults to False.
             show_if (Union[str, Dict[str, str], None]): Condition to determine if the field should be shown. Defaults to None.
             maxlengths (Dict[str, int], optional): A dictionary of field names and their maximum lengths. Default is None.
+            choices (Optional[Union[List[Dict[str, str]], Callable]]): A list of choices of genders to use in the prompts, or a callable that returns such a list. Default set of choices includes male, female, nonbinary, prefer-not-to-say, self-described, and unknown.
 
         Returns:
             List[Dict[str, str]]: A list of dictionaries with field prompts for gender.
+
+        Note:
+            self-described will provide an input that overrides the value of `gender` and is not persisted.
         """
-        choices = [
-            {str(self.gender_female_label): "female"},
-            {str(self.gender_male_label): "male"},
-            {str(self.gender_nonbinary_label): "nonbinary"},
-            {str(self.gender_prefer_not_to_say_label): "prefer-not-to-say"},
-            {str(self.gender_prefer_self_described_label): "self-described"},
-            {str(self.gender_unknown_label): "unknown"},
-        ]
+        if not choices:
+            choices = [
+                {str(self.gender_female_label): "female"},
+                {str(self.gender_male_label): "male"},
+                {str(self.gender_nonbinary_label): "nonbinary"},
+                {str(self.gender_prefer_not_to_say_label): "prefer-not-to-say"},
+                {str(self.gender_prefer_self_described_label): "self-described"},
+                {str(self.gender_unknown_label): "unknown"},
+            ]
+        if callable(choices):
+            choices = choices()
+
         self_described_input = {
             "label": str(self.gender_self_described_label),
             "field": self.attr_name("gender"),
@@ -1341,6 +1348,7 @@ class ALIndividual(Individual):
         shuffle: bool = False,
         show_unknown: Optional[Union[Literal["guess"], bool]] = "guess",
         maxlengths: Optional[Dict[str, int]] = None,
+        choices: Optional[List[Dict[str, str]]] = None,
     ) -> List[Dict[str, str]]:
         """
         Generate fields for capturing pronoun information.
@@ -1352,16 +1360,15 @@ class ALIndividual(Individual):
             shuffle (bool): Whether to shuffle the order of pronouns. Defaults to False.
             show_unknown (Union[Literal["guess"], bool]): Whether to show an "unknown" option. Can be "guess", True, or False. Defaults to "guess".
             maxlengths (Dict[str, int], optional): A dictionary of field names and their maximum lengths. Default is None.
+            choices (Optional[List[Dict[str, str]]]): A list of custom pronoun choices. Defaults to None. If not provided, global magic variable `al_pronoun_choices` will be used.
 
         Returns:
             List[Dict[str, str]]: A list of dictionaries with field prompts for pronouns.
         """
-        shuffled_choices = [
-            {str(self.pronoun_she_label): "she/her/hers"},
-            {str(self.pronoun_he_label): "he/him/his"},
-            {str(self.pronoun_they_label): "they/them/theirs"},
-            {str(self.pronoun_zir_label): "ze/zir/zirs"},
-        ]
+        if choices:
+            shuffled_choices = choices
+        else:
+            shuffled_choices = value("al_pronoun_choices")
         if shuffle:
             random.shuffle(shuffled_choices)
         final_choices = [
@@ -1432,7 +1439,7 @@ class ALIndividual(Individual):
 
     def language_fields(
         self,
-        choices: Optional[List[Dict[str, str]]] = None,
+        choices: Optional[Union[List[Dict[str, str]], Callable]] = None,
         style: str = "radio",
         show_if: Union[str, Dict[str, str], None] = None,
         maxlengths: Optional[Dict[str, int]] = None,
@@ -1441,7 +1448,7 @@ class ALIndividual(Individual):
         Generate fields for capturing language preferences.
 
         Args:
-            choices (Optional[List[Dict[str, str]]]): A list of language choices. Defaults to None.
+            choices (Optional[Union[List[Dict[str, str]], Callable]]): A list or callable of language choices. Defaults to None.
             style (str): The display style of choices. Defaults to "radio".
             show_if (Union[str, Dict[str, str], None]): Condition to determine if the field should be shown. Defaults to None.
             maxlengths (Dict[str, int], optional): A dictionary of field names and their maximum lengths. Default is None.
@@ -1455,6 +1462,8 @@ class ALIndividual(Individual):
                 {"Spanish": "es"},
                 {"Other": "other"},
             ]
+        if callable(choices):
+            choices = choices()
         other = {
             "label": str(self.language_other_label),
             "field": self.attr_name("language_other"),