ds-caselaw-marklogic-api-client 40.0.0__tar.gz → 44.3.0__tar.gz

{ds_caselaw_marklogic_api_client-40.0.0 → ds_caselaw_marklogic_api_client-44.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ds-caselaw-marklogic-api-client
-Version: 40.0.0
+Version: 44.3.0
 Summary: An API client for interacting with the underlying data in Find Caselaw.
 Keywords: national archives,caselaw
 Author: The National Archives
@@ -9,16 +9,17 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: boto3 (>=1.26.112,<2.0.0)
-Requires-Dist: certifi (>=2025.8.3,<2025.9.0)
+Requires-Dist: certifi (>=2025.11.12,<2025.12.0)
 Requires-Dist: charset-normalizer (>=3.0.0,<4.0.0)
 Requires-Dist: defusedxml (>=0.7.1,<0.8.0)
 Requires-Dist: django-environ (>=0.12.0)
-Requires-Dist: ds-caselaw-utils (>=2.0.0,<3.0.0)
+Requires-Dist: ds-caselaw-utils (>=2.10.0,<3.0.0)
 Requires-Dist: idna (>=3.4,<4.0)
 Requires-Dist: lxml (>=6.0.0,<7.0.0)
 Requires-Dist: memoization (>=0.4.0,<0.5.0)
 Requires-Dist: mypy-boto3-s3 (>=1.26.104,<2.0.0)
 Requires-Dist: mypy-boto3-sns (>=1.26.69,<2.0.0)
+Requires-Dist: pydantic (>=2.12.3,<3.0.0)
 Requires-Dist: python-dateutil (>=2.9.0-post.0,<3.0.0)
 Requires-Dist: pytz (>2024)
 Requires-Dist: requests (>=2.28.2,<3.0.0)

{ds_caselaw_marklogic_api_client-40.0.0 → ds_caselaw_marklogic_api_client-44.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ds-caselaw-marklogic-api-client"
-version = "40.0.0"
+version = "44.3.0"
 description = "An API client for interacting with the underlying data in Find Caselaw."
 authors = ["The National Archives"]
 homepage = "https://github.com/nationalarchives/ds-caselaw-custom-api-client"
@@ -12,7 +12,7 @@ packages = [
 
 [tool.poetry.dependencies]
 python = "^3.12.0"
-certifi = ">=2025.8.3,<2025.9.0"
+certifi = ">=2025.11.12,<2025.12.0"
 charset-normalizer = "^3.0.0"
 django-environ = ">=0.12.0"
 idna = "^3.4"
@@ -20,7 +20,7 @@ requests = "^2.28.2"
 requests-toolbelt = ">=0.10.1,<1.1.0"
 memoization = "^0.4.0"
 lxml = "^6.0.0"
-ds-caselaw-utils = "^2.0.0"
+ds-caselaw-utils = "^2.10.0"
 boto3 = "^1.26.112"
 typing-extensions = "^4.7.1"
 mypy-boto3-s3 = "^1.26.104"
@@ -30,22 +30,23 @@ python-dateutil = "^2.9.0-post.0"
 saxonche = "^12.5.0"
 sqids = "^0.5.0"
 defusedxml = "^0.7.1"
+pydantic = "^2.12.3"
 
 [tool.poetry.group.dev.dependencies]
-coverage = "7.10.4"
-pytest = "8.4.1"
-pytest-cov = "6.2.1"
-beautifulsoup4 = "4.13.4"
+coverage = "7.13.0"
+pytest = "9.0.2"
+pytest-cov = "7.0.0"
+beautifulsoup4 = "4.14.3"
 responses = "0.25.8"
-python-dotenv = "1.1.1"
-time-machine = "2.17.0"
-moto = {version = "5.1.10", extras = ["all"]}
+python-dotenv = "1.2.1"
+time-machine = "3.1.0"
+moto = {version = "5.1.18", extras = ["all"]}
 
 [tool.poetry.group.docs]
 optional = true
 
 [tool.poetry.group.docs.dependencies]
-pdoc = "^15.0.0"
+pdoc = "^16.0.0"
 
 
 [tool.commitizen]

{ds_caselaw_marklogic_api_client-40.0.0 → ds_caselaw_marklogic_api_client-44.3.0}/src/caselawclient/Client.py

@@ -21,19 +21,20 @@ from requests.structures import CaseInsensitiveDict
 from requests_toolbelt.multipart import decoder
 
 from caselawclient import xquery_type_dicts as query_dicts
-from caselawclient.client_helpers import VersionAnnotation
 from caselawclient.identifier_resolution import IdentifierResolutions
 from caselawclient.models.documents import (
     DOCUMENT_COLLECTION_URI_JUDGMENT,
     DOCUMENT_COLLECTION_URI_PRESS_SUMMARY,
     Document,
 )
+from caselawclient.models.documents.versions import VersionAnnotation
 from caselawclient.models.judgments import Judgment
 from caselawclient.models.press_summaries import PressSummary
 from caselawclient.models.utilities import move
 from caselawclient.search_parameters import SearchParameters
-from caselawclient.types import DocumentIdentifierSlug, DocumentIdentifierValue, DocumentURIString
+from caselawclient.types import DocumentIdentifierSlug, DocumentIdentifierValue, DocumentLock, DocumentURIString
 from caselawclient.xquery_type_dicts import (
+    CheckContentHashUniqueByUriDict,
     MarkLogicDocumentURIString,
     MarkLogicDocumentVersionURIString,
     MarkLogicPrivilegeURIString,
@@ -728,6 +729,14 @@ class MarklogicApiClient:
             == 0
         )
 
+    def has_unique_content_hash(self, judgment_uri: DocumentURIString) -> bool:
+        """
+        Returns True if the content hash for this document is unique (not shared with other documents).
+        """
+        uri = self._format_uri_for_marklogic(judgment_uri)
+        vars: CheckContentHashUniqueByUriDict = {"uri": uri}
+        return self._eval_and_decode(vars, "check_content_hash_unique_by_uri.xqy") == "true"
+
     def eval(
         self,
         xquery_path: str,
@@ -793,6 +802,8 @@ class MarklogicApiClient:
         :param judge:
         :param party:
         :param neutral_citation:
+        :param document_name:
+        :param consignment_number:
         :param specific_keyword:
         :param order:
         :param date_from:
@@ -1211,13 +1222,13 @@ class MarklogicApiClient:
 
         return (int(table[1][1]), int(table[1][2]))
 
-    def get_pending_parse_for_version(
+    def get_documents_pending_parse_for_version(
         self,
         target_version: tuple[int, int],
         maximum_records: int = 1000,
     ) -> list[list[Any]]:
-        """Retrieve documents which are not yet parsed with a given version."""
-        vars: query_dicts.GetPendingParseForVersionDict = {
+        """Retrieve a list of documents which are not yet parsed with a given version."""
+        vars: query_dicts.GetPendingParseForVersionDocumentsDict = {
             "target_major_version": target_version[0],
             "target_minor_version": target_version[1],
             "maximum_records": maximum_records,
@@ -1226,13 +1237,33 @@ class MarklogicApiClient:
             get_single_string_from_marklogic_response(
                 self._send_to_eval(
                     vars,
-                    "get_pending_parse_for_version.xqy",
+                    "get_pending_parse_for_version_documents.xqy",
                 ),
             ),
         )
 
         return results
 
+    def get_count_pending_parse_for_version(
+        self,
+        target_version: tuple[int, int],
+    ) -> int:
+        """Get the total number of documents which are not yet parsed with a given version."""
+        vars: query_dicts.GetPendingParseForVersionCountDict = {
+            "target_major_version": target_version[0],
+            "target_minor_version": target_version[1],
+        }
+        results = json.loads(
+            get_single_string_from_marklogic_response(
+                self._send_to_eval(
+                    vars,
+                    "get_pending_parse_for_version_count.xqy",
+                ),
+            ),
+        )
+
+        return int(results[1][0])
+
     def get_recently_parsed(
         self,
     ) -> list[list[Any]]:
@@ -1248,6 +1279,19 @@ class MarklogicApiClient:
 
         return results
 
+    def get_locked_documents(
+        self,
+    ) -> list[DocumentLock]:
+        """Retrieve all currently locked documents."""
+        results = [
+            DocumentLock.from_string(lock)
+            for lock in get_multipart_strings_from_marklogic_response(
+                self._send_to_eval({}, "get_locked_documents.xqy")
+            )
+        ]
+
+        return sorted(results, key=lambda lock: lock.timestamp)
+
     def get_missing_fclid(
         self,
         maximum_records: int = 50,

ds_caselaw_marklogic_api_client-44.3.0/src/caselawclient/client_helpers/__init__.py

@@ -0,0 +1,35 @@
+from lxml import etree
+
+from caselawclient.xml_helpers import DEFAULT_NAMESPACES
+
+from ..models.documents import Document
+from ..models.judgments import Judgment
+from ..models.parser_logs import ParserLog
+from ..models.press_summaries import PressSummary
+
+
+class CannotDetermineDocumentType(Exception):
+    pass
+
+
+def get_document_type_class(xml: bytes) -> type[Document]:
+    """Attempt to get the type of the document based on the top-level structure of the XML document."""
+
+    node = etree.fromstring(xml)
+
+    # If the main node is `<judgment>`, it's a judgment
+    if node.xpath("/akn:akomaNtoso/akn:judgment", namespaces=DEFAULT_NAMESPACES):
+        return Judgment
+
+    # If the main node is `<doc name='pressSummary'>`, it's a press summary
+    if node.xpath("/akn:akomaNtoso/akn:doc[@name='pressSummary']", namespaces=DEFAULT_NAMESPACES):
+        return PressSummary
+
+    # If the document is a parser error with a root element of `error`, it's not of a special type.
+    if node.xpath("/error", namespaces=DEFAULT_NAMESPACES):
+        return ParserLog
+
+    # Otherwise, we don't know for sure. Fail out.
+    raise CannotDetermineDocumentType(
+        "Unable to determine the Document type by its XML",
+    )

{ds_caselaw_marklogic_api_client-40.0.0 → ds_caselaw_marklogic_api_client-44.3.0}/src/caselawclient/factories.py

@@ -20,7 +20,7 @@ T = TypeVar("T")
 
 DEFAULT_DOCUMENT_BODY_XML = """<akomaNtoso xmlns="http://docs.oasis-open.org/legaldocml/ns/akn/3.0" xmlns:uk="https://caselaw.nationalarchives.gov.uk/akn">
             <judgment name="decision">
-                <meta/><header/>
+                <meta/><header><p>Header contains text</p></header>
                 <judgmentBody>
                 <decision>
                 <p>This is a document.</p>
@@ -61,6 +61,8 @@ class DocumentFactory:
         "source_name": "Example Uploader",
         "source_email": "uploader@example.com",
         "consignment_reference": "TDR-12345",
+        "first_published_datetime": None,
+        "has_ever_been_published": False,
         "assigned_to": "",
         "versions": [],
     }

ds_caselaw_marklogic_api_client-44.3.0/src/caselawclient/managers/merge/__init__.py

@@ -0,0 +1,51 @@
+import caselawclient.managers.merge.checks as checks
+from caselawclient.models.documents import Document
+from caselawclient.types import SuccessFailureMessageTuple
+
+
+def _combine_list_of_successfailure_results(
+    validations: list[SuccessFailureMessageTuple],
+) -> SuccessFailureMessageTuple:
+    """Given a list of SuccessFailureMessageTuples, combine the success/failure states and any messages into a single new object representing the overall success/failure state."""
+    success = True
+    messages: list[str] = []
+
+    for validation in validations:
+        if validation.success is False:
+            success = False
+
+        messages += validation.messages
+
+    return SuccessFailureMessageTuple(success, messages)
+
+
+class MergeManager:
+    @classmethod
+    def check_document_is_safe_as_merge_source(cls, source_document: Document) -> SuccessFailureMessageTuple:
+        """
+        Is the given document safe to be considered as a merge source?
+        """
+
+        return _combine_list_of_successfailure_results(
+            [
+                checks.check_document_is_not_version(source_document),
+                checks.check_document_has_only_one_version(source_document),
+                checks.check_document_has_never_been_published(source_document),
+                checks.check_document_is_safe_to_delete(source_document),
+            ]
+        )
+
+    @classmethod
+    def check_source_document_is_safe_to_merge_into_target(
+        cls, source_document: Document, target_document: Document
+    ) -> SuccessFailureMessageTuple:
+        """Is the given source document safe to merge into a given target?"""
+
+        return _combine_list_of_successfailure_results(
+            [
+                checks.check_documents_are_not_same_document(source_document, target_document),
+                checks.check_document_is_not_version(target_document),
+                checks.check_documents_are_same_type(source_document, target_document),
+                checks.check_source_document_is_newer_than_target(source_document, target_document),
+            ]
+        )

ds_caselaw_marklogic_api_client-44.3.0/src/caselawclient/managers/merge/checks.py

@@ -0,0 +1,79 @@
+from caselawclient.models.documents import Document
+from caselawclient.types import SuccessFailureMessageTuple
+
+
+def check_document_is_not_version(document: Document) -> SuccessFailureMessageTuple:
+    """Check that the document URI isn't a specific version"""
+    if document.is_version:
+        return SuccessFailureMessageTuple(
+            False,
+            ["This document is a specific version, and cannot be used as a merge source"],
+        )
+
+    return SuccessFailureMessageTuple(True, [])
+
+
+def check_document_has_only_one_version(document: Document) -> SuccessFailureMessageTuple:
+    """Make sure the document has exactly one version."""
+    if len(document.versions) > 1:
+        return SuccessFailureMessageTuple(
+            False,
+            ["This document has more than one version"],
+        )
+
+    return SuccessFailureMessageTuple(True, [])
+
+
+def check_document_has_never_been_published(document: Document) -> SuccessFailureMessageTuple:
+    """Make sure the document has never been published."""
+    if document.has_ever_been_published:
+        return SuccessFailureMessageTuple(
+            False,
+            ["This document has previously been published"],
+        )
+
+    return SuccessFailureMessageTuple(True, [])
+
+
+def check_document_is_safe_to_delete(document: Document) -> SuccessFailureMessageTuple:
+    """Make sure the document is safe to delete."""
+    if not document.safe_to_delete:
+        return SuccessFailureMessageTuple(
+            False,
+            ["This document cannot be deleted because it is published"],
+        )
+
+    return SuccessFailureMessageTuple(True, [])
+
+
+def check_documents_are_not_same_document(document_one: Document, document_two: Document) -> SuccessFailureMessageTuple:
+    """Check that two documents aren't actually the same"""
+    if document_one.uri == document_two.uri:
+        return SuccessFailureMessageTuple(
+            False,
+            ["You cannot merge a document with itself"],
+        )
+    return SuccessFailureMessageTuple(True, [])
+
+
+def check_documents_are_same_type(document_one: Document, document_two: Document) -> SuccessFailureMessageTuple:
+    """Check to see if this document is the same type as a target document."""
+    if type(document_one) is not type(document_two):
+        return SuccessFailureMessageTuple(
+            False,
+            [
+                f"The type of {document_one.uri} ({type(document_one).document_noun}) does not match the type of {document_two.uri} ({type(document_two).document_noun})"
+            ],
+        )
+    return SuccessFailureMessageTuple(True, [])
+
+
+def check_source_document_is_newer_than_target(
+    source_document: Document, target_document: Document
+) -> SuccessFailureMessageTuple:
+    """Check to see if the created datetime of the latest version of this document is newer than the created datetime of the latest version of a target document."""
+    if source_document.version_created_datetime < target_document.version_created_datetime:
+        return SuccessFailureMessageTuple(
+            False, [f"The document at {source_document.uri} is older than the latest version of {target_document.uri}"]
+        )
+    return SuccessFailureMessageTuple(True, [])

{ds_caselaw_marklogic_api_client-40.0.0 → ds_caselaw_marklogic_api_client-44.3.0}/src/caselawclient/models/documents/__init__.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any, Optional
 from ds_caselaw_utils import courts
 from ds_caselaw_utils.courts import CourtNotFoundException
 from ds_caselaw_utils.types import NeutralCitationString
+from pydantic import TypeAdapter
 from requests_toolbelt.multipart import decoder
 
 import caselawclient.models.documents.comparison as comparison
@@ -16,6 +17,7 @@ from caselawclient.errors import (
     OnlySupportedOnVersion,
 )
 from caselawclient.identifier_resolution import IdentifierResolutions
+from caselawclient.models.documents.versions import AnnotationDataDict
 from caselawclient.models.identifiers import Identifier
 from caselawclient.models.identifiers.exceptions import IdentifierValidationException
 from caselawclient.models.identifiers.fclid import FindCaseLawIdentifier, FindCaseLawIdentifierSchema
@@ -24,6 +26,7 @@ from caselawclient.models.utilities import VersionsDict, extract_version, render
 from caselawclient.models.utilities.aws import (
     ParserInstructionsDict,
     announce_document_event,
+    are_unpublished_assets_clean,
     check_docx_exists,
     delete_documents_from_private_bucket,
     generate_docx_url,
@@ -95,6 +98,16 @@ class Document:
             True,
             "The court for this {document_noun} is not valid",
         ),
+        (
+            "has_unique_content_hash",
+            True,
+            "There is another document with identical content",
+        ),
+        (
+            "has_only_clean_assets",
+            True,
+            "An uncleaned asset exists for this document",
+        ),
     ]
     """
     A list of tuples in the form:
@@ -245,7 +258,7 @@ class Document:
         """
         if self.is_version:
             raise NotSupportedOnVersion(
-                "Cannot get versions of a version for {self.uri}",
+                f"Cannot get versions of a version for {self.uri}",
             )
         docs = []
         for version in self.versions:
@@ -307,10 +320,37 @@ class Document:
 
     @cached_property
     def first_published_datetime(self) -> Optional[datetime.datetime]:
+        """
+        Return the database value for the date and time this document was first published.
+
+        :return: The datetime value in the database for "first published".
+        """
         return self.api_client.get_datetime_property(self.uri, "first_published_datetime")
 
+    @cached_property
+    def first_published_datetime_display(self) -> Optional[datetime.datetime]:
+        """
+        Return the display value for the date and time this document was first published.
+
+        A value of 1970-01-01 00:00 indicates that the document has been published previously, but the exact date and time is unknown. In this case, return `None`. This can be used alongside `has_ever_been_published` to indicate an "unknown" state.
+
+        :return: The datetime value to be displayed to end users for "first published".
+        """
+
+        if self.first_published_datetime == datetime.datetime(1970, 1, 1, 0, 0, tzinfo=datetime.timezone.utc):
+            return None
+
+        return self.first_published_datetime
+
     @cached_property
     def has_ever_been_published(self) -> bool:
+        """
+        Do we consider this document to have ever been published?
+
+        This is `True` if either the document is currently published, or if `first_published_datetime` has any value (including the sentinel value).
+
+        :return: A boolean indicating if the document has ever been published.
+        """
         return self.is_published or self.first_published_datetime is not None
 
     @cached_property
@@ -325,6 +365,23 @@ class Document:
     def annotation(self) -> str:
         return self.api_client.get_version_annotation(self.uri)
 
+    @cached_property
+    def structured_annotation(self) -> AnnotationDataDict:
+        annotation_data_dict_loader = TypeAdapter(AnnotationDataDict)
+
+        return annotation_data_dict_loader.validate_json(self.annotation)
+
+    @cached_property
+    def has_unique_content_hash(self) -> bool:
+        """Check if the content hash of this document is unique compared to all other documents in MarkLogic."""
+        return self.api_client.has_unique_content_hash(self.uri)
+
+    @cached_property
+    def has_only_clean_assets(self) -> bool:
+        """False if any non-tar.gz assets associated with this document have not been cleaned."""
+        return True  # TODO: Remove this once we have enabled the asset cleaning pipeline.
+        return are_unpublished_assets_clean(self.uri)
+
     @cached_property
     def version_created_datetime(self) -> datetime.datetime:
         return self.api_client.get_version_created_datetime(self.uri)
@@ -540,14 +597,14 @@ class Document:
         """
         Is it sensible to reparse this document?
         """
-        return self.docx_exists()
+        return self.docx_exists() and not self.body.has_external_data
 
     @cached_property
     def can_enrich(self) -> bool:
         """
         Is it possible to enrich this document?
         """
-        return self.body.has_content
+        return self.body.has_content and not self.body.has_external_data
 
     def validate_identifiers(self) -> SuccessFailureMessageTuple:
         return self.identifiers.perform_all_validations(document_type=type(self), api_client=self.api_client)

{ds_caselaw_marklogic_api_client-40.0.0 → ds_caselaw_marklogic_api_client-44.3.0}/src/caselawclient/models/documents/body.py

@@ -6,9 +6,11 @@ from typing import Optional
 
 import pytz
 from ds_caselaw_utils.types import CourtCode
+from lxml import etree
 from saxonche import PySaxonProcessor
 
 from caselawclient.models.utilities.dates import parse_string_date_as_utc
+from caselawclient.types import DocumentCategory
 
 from .xml import XML
 
@@ -37,6 +39,9 @@ class DocumentBody:
     def get_xpath_match_strings(self, xpath: str, namespaces: dict[str, str] = DEFAULT_NAMESPACES) -> list[str]:
         return self._xml.get_xpath_match_strings(xpath, namespaces)
 
+    def get_xpath_nodes(self, xpath: str, namespaces: dict[str, str] = DEFAULT_NAMESPACES) -> list[etree._Element]:
+        return self._xml.get_xpath_nodes(xpath, namespaces)
+
     @cached_property
     def name(self) -> str:
         return self.get_xpath_match_string(
@@ -51,9 +56,46 @@ class DocumentBody:
     def jurisdiction(self) -> str:
         return self.get_xpath_match_string("/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:jurisdiction/text()")
 
+    @cached_property
+    def categories(self) -> list[DocumentCategory]:
+        xpath = "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:category"
+        nodes = self.get_xpath_nodes(xpath, DEFAULT_NAMESPACES)
+
+        categories: dict[str, DocumentCategory] = {}
+        children_map: dict[str, list[DocumentCategory]] = {}
+
+        for node in nodes:
+            name = node.text
+            if name is None or not name.strip():
+                continue
+
+            category = DocumentCategory(name=name)
+            categories[name] = category
+
+            parent = node.get("parent")
+
+            if parent:
+                children_map.setdefault(parent, []).append(category)
+
+        for parent, subcategories in children_map.items():
+            if parent in categories:
+                categories[parent].subcategories.extend(subcategories)
+
+        top_level_categories = [
+            categories[name]
+            for node in nodes
+            if node.get("parent") is None
+            if (name := node.text) and name in categories
+        ]
+
+        return top_level_categories
+
+    # NOTE: Deprecated - use categories function
     @cached_property
     def category(self) -> Optional[str]:
-        return self.get_xpath_match_string("/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:category/text()")
+        return self.get_xpath_match_string(
+            "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:category[not(@parent)][1]/text()"
+        )
 
     @cached_property
     def case_number(self) -> Optional[str]:
@@ -134,15 +176,18 @@ class DocumentBody:
     @cached_property
     def has_content(self) -> bool:
         """If we do not have a word document, the XML will not contain
-        the contents of the judgment, but will contain a preamble."""
-        trailing_tags = self._xml.xml_as_tree.xpath("//*[preceding::akn:meta]", namespaces=DEFAULT_NAMESPACES)
-        for tag in trailing_tags:
-            if tag.tail and tag.tail.strip():
-                return True
-            if tag.text and tag.text.strip():
-                return True
-
-        return False
+        the contents of the judgment, but will contain a preamble (a header if a judgment or a preface if a press summary)"""
+        return bool(
+            self._xml.xml_as_tree.xpath("//akn:header[normalize-space(string(.))]", namespaces=DEFAULT_NAMESPACES)
+            or self._xml.xml_as_tree.xpath("//akn:preface[normalize-space(string(.))]", namespaces=DEFAULT_NAMESPACES)
+        )
+
+    @cached_property
+    def has_external_data(self) -> bool:
+        """Is there data which is not present within the source document:
+        is there a spreadsheet which has populated some fields. The current implementation
+        "is there a uk:party tag" is intended as a stopgap whilst we're not importing that data."""
+        return bool(self._xml.xml_as_tree.xpath("//uk:party", namespaces=DEFAULT_NAMESPACES))
 
     @cache
     def content_html(self, image_prefix: str) -> Optional[str]:

ds_caselaw_marklogic_api_client-44.3.0/src/caselawclient/models/documents/stub.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+from typing import Literal
+
+from ds_caselaw_utils.courts import courts
+from ds_caselaw_utils.types import CourtCode
+from jinja2 import StrictUndefined, Template
+from typing_extensions import TypedDict
+
+
+class PartyData(TypedDict):
+    role: Literal["Claimant", "Defendant"]
+    name: str
+
+
+class EditorStubData(TypedDict):
+    decision_date: str  # day precision
+    transform_datetime: str  # second precision
+    court_code: str
+    title: str
+    year: str
+    case_numbers: list[str]  # can be none
+    parties: list[PartyData]  # (type (claimant|defendant), name)
+
+
+class RendererStubData(EditorStubData):
+    court_url: str  # should be populated from utils/courts.cs
+    court_full_name: str  # ditto
+
+
+def add_other_stub_fields(editor_data: EditorStubData) -> RendererStubData:
+    court = courts.get_court_by_code(CourtCode(editor_data["court_code"].upper()))
+    return {
+        **editor_data,
+        "court_url": court.identifier_iri,
+        "court_full_name": court.long_name,
+    }
+
+
+def render_stub_xml(editor_data: EditorStubData) -> bytes:
+    render_data = add_other_stub_fields(editor_data)
+    from caselawclient.Client import ROOT_DIR
+
+    judgment_path = Path(ROOT_DIR) / "models" / "documents" / "templates" / "judgment.xml"
+
+    with (judgment_path).open("r") as f:
+        template = f.read()
+
+    rendered = bytes(Template(template, undefined=StrictUndefined).render(render_data).encode("utf-8"))
+
+    return rendered