ds-caselaw-marklogic-api-client 24.0.1__tar.gz → 26.0.0__tar.gz

{ds_caselaw_marklogic_api_client-24.0.1 → ds_caselaw_marklogic_api_client-26.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ds-caselaw-marklogic-api-client
-Version: 24.0.1
+Version: 26.0.0
 Summary: An API client for interacting with the underlying data in Find Caselaw.
 Home-page: https://github.com/nationalarchives/ds-caselaw-custom-api-client
 Keywords: national archives,caselaw
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: boto3 (>=1.26.112,<2.0.0)
-Requires-Dist: certifi (>=2024.7.4,<2024.8.0)
+Requires-Dist: certifi (>=2024.8.30,<2024.9.0)
 Requires-Dist: charset-normalizer (>=3.0.0,<4.0.0)
 Requires-Dist: django-environ (>=0.11.0,<0.12.0)
 Requires-Dist: ds-caselaw-utils (>=1.4.1,<2.0.0)

{ds_caselaw_marklogic_api_client-24.0.1 → ds_caselaw_marklogic_api_client-26.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ds-caselaw-marklogic-api-client"
-version = "24.0.1"
+version = "26.0.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.9"
-certifi = ">=2024.7.4,<2024.8.0"
+certifi = ">=2024.8.30,<2024.9.0"
 charset-normalizer = "^3.0.0"
 django-environ = "^0.11.0"
 idna = "^3.4"
@@ -42,6 +42,13 @@ optional = true
 [tool.poetry.group.docs.dependencies]
 pdoc = "^14.0.0"
 
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+tag_format = "v$version"
+version_scheme = "semver2"
+version_provider = "poetry"
+update_changelog_on_bump = true
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
@@ -56,12 +63,17 @@ filterwarnings = ["ignore::DeprecationWarning"]
 line-length = 120
 
 [tool.ruff.lint]
-ignore = ["E501", "G004", "PLR2004", "RUF005", "RUF012", "UP040"] # long lines, fstrings in logs, magic values, consider not concat, mutable classbits, type instead of TypeAlias
-extend-select = ["W", "B", "Q", "C90", "I", "UP", "YTT", "ASYNC", "S", "BLE", "A", "COM", "C4", "DTZ", "T10", "DJ", "EM", "EXE", "FA",
-                 "ISC", "ICN", "G", "INP", "PIE", "T20", "PYI", "PT", "Q", "RSE", "RET", "SLF", "SLOT", "SIM", "TID", "TCH", "INT", "PTH",
-                 "FIX", "PGH", "PL", "TRY", "FLY", "PERF", "RUF"]
+ignore = ["E501", "G004", "PLR2004", "RUF005", "RUF012", "UP040"] # longlines, fstrings in logs, magic values, consider not concat, mutable classbits, type instead of TypeAlias
+extend-select = ["W", "I", "SLF"]
+# extend-select = [ "B", "Q", "C90", "I", "UP", "YTT", "ASYNC", "S", "BLE", "A", "COM", "C4", "DTZ", "T10", "DJ", "EM", "EXE", "FA",
+#                  "ISC", "ICN", "G", "INP", "PIE", "T20", "PYI", "PT", "Q", "RSE", "RET", "SLOT", "SIM", "TID", "TCH", "INT", "PTH",
+#                  "FIX", "PGH", "PL", "TRY", "FLY", "PERF", "RUF"]
 unfixable = ["ERA"]
 
+[tool.ruff.lint.extend-per-file-ignores]
+"tests/*" = ["S101"]  # `assert` is fine in tests
+"tests/client/test_client.py" = ["SLF001"]  # TODO: This really shouldn't be the case, but it's not important to fix right now.
+
 # things skipped:
 # N: naming, possibly good
 # D: docstrings missing throughout

{ds_caselaw_marklogic_api_client-24.0.1 → ds_caselaw_marklogic_api_client-26.0.0}/src/caselawclient/Client.py

@@ -8,7 +8,7 @@ from datetime import datetime, time, timedelta
 from pathlib import Path
 from typing import Any, Optional, Type, Union
 from xml.etree import ElementTree
-from xml.etree.ElementTree import Element
+from xml.etree.ElementTree import Element, ParseError, fromstring
 
 import environ
 import requests
@@ -34,7 +34,6 @@ from caselawclient.xquery_type_dicts import (
     MarkLogicPrivilegeURIString,
 )
 
-from . import xml_tools
 from .content_hash import validate_content_hash
 from .errors import (
     DocumentNotFoundError,
@@ -129,7 +128,7 @@ def get_single_string_from_marklogic_response(
         # relies on "" being falsy.
         return ""
 
-    elif part_count > 1:
+    if part_count > 1:
         raise MultipartResponseLongerThanExpected(
             f"Response returned {part_count} multipart items, expected 1",
         )
@@ -148,7 +147,7 @@ def get_single_bytestring_from_marklogic_response(
         # relies on "" being falsy.
         return b""
 
-    elif part_count > 1:
+    if part_count > 1:
         raise MultipartResponseLongerThanExpected(
             f"Response returned {part_count} multipart items, expected 1",
         )
@@ -231,12 +230,11 @@ class MarklogicApiClient:
 
         if DOCUMENT_COLLECTION_URI_JUDGMENT in collections:
             return Judgment
-        elif DOCUMENT_COLLECTION_URI_PRESS_SUMMARY in collections:
+        if DOCUMENT_COLLECTION_URI_PRESS_SUMMARY in collections:
             return PressSummary
-        else:
-            raise DocumentHasNoTypeCollection(
-                f"The document at URI {uri} is not part of a valid document type collection.",
-            )
+        raise DocumentHasNoTypeCollection(
+            f"The document at URI {uri} is not part of a valid document type collection.",
+        )
 
     def _get_error_code_class(self, error_code: str) -> Type[MarklogicAPIError]:
         """
@@ -251,6 +249,23 @@ class MarklogicApiClient:
     def _path_to_request_url(self, path: str) -> str:
         return f"{self.base_url}/{path.lstrip('/')}"
 
+    @classmethod
+    def _get_error_code(cls, content_as_xml: Optional[str]) -> str:
+        logging.warning(
+            "XMLTools is deprecated and will be removed in later versions. "
+            "Use methods from MarklogicApiClient.Client instead.",
+        )
+        if not content_as_xml:
+            return "Unknown error, Marklogic returned a null or empty response"
+        try:
+            xml = fromstring(content_as_xml)
+            return xml.find(
+                "message-code",
+                namespaces={"": "http://marklogic.com/xdmp/error"},
+            ).text  # type: ignore
+        except (ParseError, TypeError, AttributeError):
+            return "Unknown error, Marklogic returned a null or empty response"
+
     def _raise_for_status(self, response: requests.Response) -> None:
         try:
             response.raise_for_status()
@@ -269,7 +284,8 @@ class MarklogicApiClient:
 
             if new_error_class == self.default_http_error_class:
                 # Attempt to decode the error code from the response
-                error_code = xml_tools.get_error_code(response.content.decode("utf-8"))
+
+                error_code = self._get_error_code(response.content.decode("utf-8"))
 
                 new_error_class = self._get_error_code_class(error_code)
 
@@ -498,9 +514,8 @@ class MarklogicApiClient:
             court, jurisdiction = re.split("\\s*/\\s*", content)
             self.set_document_court(document_uri, court)
             return self.set_document_jurisdiction(document_uri, jurisdiction)
-        else:
-            self.set_document_court(document_uri, content)
-            return self.set_document_jurisdiction(document_uri, "")
+        self.set_document_court(document_uri, content)
+        return self.set_document_jurisdiction(document_uri, "")
 
     def set_judgment_this_uri(
         self,

ds_caselaw_marklogic_api_client-24.0.1/src/caselawclient/models/documents.py → ds_caselaw_marklogic_api_client-26.0.0/src/caselawclient/models/documents/__init__.py

@@ -1,27 +1,21 @@
 import datetime
 import warnings
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Dict, NewType, Optional
+from typing import TYPE_CHECKING, Any, NewType, Optional
 
-import pytz
 from ds_caselaw_utils import courts
 from ds_caselaw_utils.courts import CourtNotFoundException
-from lxml import etree
 from lxml import html as html_parser
 from requests_toolbelt.multipart import decoder
 
-from caselawclient.models.utilities import extract_version
-from caselawclient.models.utilities.dates import parse_string_date_as_utc
-
-from ..errors import (
+from caselawclient.errors import (
     DocumentNotFoundError,
     GatewayTimeoutError,
     NotSupportedOnVersion,
     OnlySupportedOnVersion,
 )
-from ..xml_helpers import get_xpath_match_string, get_xpath_match_strings
-from .utilities import VersionsDict, render_versions
-from .utilities.aws import (
+from caselawclient.models.utilities import VersionsDict, extract_version, render_versions
+from caselawclient.models.utilities.aws import (
     ParserInstructionsDict,
     announce_document_event,
     check_docx_exists,
@@ -34,31 +28,17 @@ from .utilities.aws import (
     uri_for_s3,
 )
 
-MINIMUM_ENRICHMENT_TIME = datetime.timedelta(minutes=20)
-
+from .body import DocumentBody
+from .exceptions import CannotPublishUnpublishableDocument, DocumentNotSafeForDeletion
+from .statuses import DOCUMENT_STATUS_HOLD, DOCUMENT_STATUS_IN_PROGRESS, DOCUMENT_STATUS_NEW, DOCUMENT_STATUS_PUBLISHED
 
-class UnparsableDate(Warning):
-    pass
+MINIMUM_ENRICHMENT_TIME = datetime.timedelta(minutes=20)
 
 
 class GatewayTimeoutGettingHTMLWithQuery(RuntimeWarning):
     pass
 
 
-DOCUMENT_STATUS_HOLD = "On hold"
-""" This document has been placed on hold to actively prevent publication. """
-
-DOCUMENT_STATUS_PUBLISHED = "Published"
-""" This document has been published and should be considered publicly visible. """
-
-DOCUMENT_STATUS_IN_PROGRESS = "In progress"
-""" This document has not been published or put on hold, and has been picked up by an editor and
-    should be progressing through the document pipeline. """
-
-DOCUMENT_STATUS_NEW = "New"
-""" This document isn't published, on hold, or assigned, and can be picked up by an editor in the future. """
-
-
 DOCUMENT_COLLECTION_URI_JUDGMENT = "judgment"
 DOCUMENT_COLLECTION_URI_PRESS_SUMMARY = "press-summary"
 
@@ -67,19 +47,6 @@ if TYPE_CHECKING:
 
 
 DocumentURIString = NewType("DocumentURIString", str)
-CourtIdentifierString = NewType("CourtIdentifierString", str)
-
-
-class CannotPublishUnpublishableDocument(Exception):
-    """A document which has failed publication safety checks in `Document.is_publishable` cannot be published."""
-
-
-class DocumentNotSafeForDeletion(Exception):
-    """A document which is not safe for deletion cannot be deleted."""
-
-
-class NonXMLDocumentError(Exception):
-    """A document cannot be parsed as XML."""
 
 
 class Document:
@@ -96,7 +63,7 @@ class Document:
 
     attributes_to_validate: list[tuple[str, bool, str]] = [
         (
-            "failed_to_parse",
+            "is_failure",
             False,
             "This document failed to parse",
         ),
@@ -143,20 +110,18 @@ class Document:
 
         :raises DocumentNotFoundError: The document does not exist within MarkLogic
         """
-        self.uri = DocumentURIString(uri.strip("/"))
-        self.api_client = api_client
+        self.uri: DocumentURIString = DocumentURIString(uri.strip("/"))
+        self.api_client: MarklogicApiClient = api_client
         if not self.document_exists():
             raise DocumentNotFoundError(f"Document {self.uri} does not exist")
 
-        self.xml = self.XML(
-            xml_bytestring=self.api_client.get_judgment_xml_bytestring(
-                self.uri,
-                show_unpublished=True,
-            ),
+        self.body: DocumentBody = DocumentBody(
+            xml_bytestring=self.api_client.get_judgment_xml_bytestring(self.uri, show_unpublished=True),
         )
+        """ `Document.body` represents the XML of the document itself, without any information such as version tracking or properties. """
 
     def __repr__(self) -> str:
-        name = self.name or "un-named"
+        name = self.body.name or "un-named"
         return f"<{self.document_noun} {self.uri}: {name}>"
 
     def document_exists(self) -> bool:
@@ -186,106 +151,6 @@ class Document:
         """
         return f"https://caselaw.nationalarchives.gov.uk/{self.uri}"
 
-    @cached_property
-    def name(self) -> str:
-        return self.xml.get_xpath_match_string(
-            "/akn:akomaNtoso/akn:*/akn:meta/akn:identification/akn:FRBRWork/akn:FRBRname/@value",
-            {"akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0"},
-        )
-
-    @cached_property
-    def court(self) -> str:
-        return self.xml.get_xpath_match_string(
-            "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:court/text()",
-            {
-                "uk": "https://caselaw.nationalarchives.gov.uk/akn",
-                "akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0",
-            },
-        )
-
-    @cached_property
-    def jurisdiction(self) -> str:
-        return self.xml.get_xpath_match_string(
-            "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:jurisdiction/text()",
-            {
-                "uk": "https://caselaw.nationalarchives.gov.uk/akn",
-                "akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0",
-            },
-        )
-
-    @property
-    def court_and_jurisdiction_identifier_string(self) -> CourtIdentifierString:
-        if self.jurisdiction != "":
-            return CourtIdentifierString("/".join((self.court, self.jurisdiction)))
-        else:
-            return CourtIdentifierString(self.court)
-
-    @cached_property
-    def document_date_as_string(self) -> str:
-        return self.xml.get_xpath_match_string(
-            "/akn:akomaNtoso/akn:*/akn:meta/akn:identification/akn:FRBRWork/akn:FRBRdate/@date",
-            {"akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0"},
-        )
-
-    @cached_property
-    def document_date_as_date(self) -> Optional[datetime.date]:
-        if not self.document_date_as_string:
-            return None
-        try:
-            return datetime.datetime.strptime(
-                self.document_date_as_string,
-                "%Y-%m-%d",
-            ).date()
-        except ValueError:
-            warnings.warn(
-                f"Unparsable date encountered: {self.document_date_as_string}",
-                UnparsableDate,
-            )
-            return None
-
-    def get_manifestation_datetimes(
-        self,
-        name: Optional[str] = None,
-    ) -> list[datetime.datetime]:
-        name_filter = f"[@name='{name}']" if name else ""
-        iso_datetimes = self.xml.get_xpath_match_strings(
-            "/akn:akomaNtoso/akn:*/akn:meta/akn:identification/akn:FRBRManifestation"
-            f"/akn:FRBRdate{name_filter}/@date",
-            {"akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0"},
-        )
-
-        return [parse_string_date_as_utc(event, pytz.UTC) for event in iso_datetimes]
-
-    def get_latest_manifestation_datetime(
-        self,
-        name: Optional[str] = None,
-    ) -> Optional[datetime.datetime]:
-        events = self.get_manifestation_datetimes(name)
-        if not events:
-            return None
-        else:
-            return max(events)
-
-    def get_latest_manifestation_type(self) -> Optional[str]:
-        return max(
-            (
-                (type, time)
-                for type in ["transform", "tna-enriched"]
-                if (time := self.get_latest_manifestation_datetime(type))
-            ),
-            key=lambda x: x[1],
-        )[0]
-
-    @cached_property
-    def transformation_datetime(self) -> Optional[datetime.datetime]:
-        """When was this document successfully parsed or reparsed (date from XML)"""
-        return self.get_latest_manifestation_datetime("transform")
-
-    @cached_property
-    def enrichment_datetime(self) -> Optional[datetime.datetime]:
-        """When was this document successfully enriched (date from XML)"""
-        return self.get_latest_manifestation_datetime("tna-enriched")
-
     @cached_property
     def is_published(self) -> bool:
         return self.api_client.get_published(self.uri)
@@ -374,10 +239,6 @@ class Document:
         "Is this document a potentially historic version of a document, or is it the main document itself?"
         return extract_version(self.uri) != 0
 
-    @cached_property
-    def content_as_xml(self) -> str:
-        return self.xml.xml_as_string
-
     def content_as_html(
         self,
         version_uri: Optional[DocumentURIString] = None,
@@ -404,8 +265,7 @@ class Document:
                     GatewayTimeoutGettingHTMLWithQuery,
                 )
                 return self.content_as_html(version_uri)
-            else:
-                raise e
+            raise e
 
     def number_of_mentions(self, query: str) -> int:
         html = self.content_as_html(query=query)
@@ -421,7 +281,7 @@ class Document:
 
         :return: `True` if this document is in a 'failure' state, otherwise `False`
         """
-        if self.failed_to_parse:
+        if self.body.failed_to_parse:
             return True
         return False
 
@@ -431,20 +291,9 @@ class Document:
             return True
         return False
 
-    @cached_property
-    def failed_to_parse(self) -> bool:
-        """
-        Did this document entirely fail to parse?
-
-        :return: `True` if there was a complete parser failure, otherwise `False`
-        """
-        if "error" in self.xml.root_element:
-            return True
-        return False
-
     @cached_property
     def has_name(self) -> bool:
-        if not self.name:
+        if not self.body.name:
             return False
 
         return True
@@ -453,7 +302,7 @@ class Document:
     def has_valid_court(self) -> bool:
         try:
             return bool(
-                courts.get_by_code(self.court_and_jurisdiction_identifier_string),
+                courts.get_by_code(self.body.court_and_jurisdiction_identifier_string),
             )
         except CourtNotFoundException:
             return False
@@ -534,7 +383,7 @@ class Document:
         Has this document been enriched recently?
         """
 
-        last_enrichment = self.enrichment_datetime
+        last_enrichment = self.body.enrichment_datetime
         if not last_enrichment:
             return False
 
@@ -615,7 +464,11 @@ class Document:
         self.api_client.set_property(self.uri, "last_sent_to_parser", now.isoformat())
 
         parser_type_noun = {"judgment": "judgment", "press summary": "pressSummary"}[self.document_noun]
-        checked_date = self.document_date_as_string if self.document_date_as_string > "1001" else None
+        checked_date: Optional[str] = (
+            self.body.document_date_as_date.isoformat()
+            if self.body.document_date_as_date and self.body.document_date_as_date > datetime.date(1001, 1, 1)
+            else None
+        )
 
         # the keys of parser_instructions should exactly match the parser output
         # in the *-metadata.json files by the parser. Whilst typically empty
@@ -624,9 +477,9 @@ class Document:
         parser_instructions: ParserInstructionsDict = {
             "documentType": parser_type_noun,
             "metadata": {
-                "name": self.name or None,
+                "name": self.body.name or None,
                 "cite": self.best_human_identifier or None,
-                "court": self.court or None,
+                "court": self.body.court or None,
                 "date": checked_date,
                 "uri": self.uri,
             },
@@ -656,38 +509,3 @@ class Document:
         if self.docx_exists():
             return True
         return False
-
-    class XML:
-        """
-        Represents the XML of a document, and should contain all methods for interacting with it.
-        """
-
-        def __init__(self, xml_bytestring: bytes):
-            """
-            :raises NonXMLDocumentError: This document is not valid XML
-            """
-            try:
-                self.xml_as_tree: etree.Element = etree.fromstring(xml_bytestring)
-            except etree.XMLSyntaxError:
-                raise NonXMLDocumentError
-
-        @property
-        def xml_as_string(self) -> str:
-            """
-            :return: A string representation of this document's XML tree.
-            """
-            return str(etree.tostring(self.xml_as_tree).decode(encoding="utf-8"))
-
-        @property
-        def root_element(self) -> str:
-            return str(self.xml_as_tree.tag)
-
-        def get_xpath_match_string(self, xpath: str, namespaces: Dict[str, str]) -> str:
-            return get_xpath_match_string(self.xml_as_tree, xpath, namespaces)
-
-        def get_xpath_match_strings(
-            self,
-            xpath: str,
-            namespaces: Dict[str, str],
-        ) -> list[str]:
-            return get_xpath_match_strings(self.xml_as_tree, xpath, namespaces)

ds_caselaw_marklogic_api_client-26.0.0/src/caselawclient/models/documents/body.py

@@ -0,0 +1,142 @@
+import datetime
+import warnings
+from functools import cached_property
+from typing import NewType, Optional
+
+import pytz
+
+from caselawclient.models.utilities.dates import parse_string_date_as_utc
+
+from .xml import XML
+
+CourtIdentifierString = NewType("CourtIdentifierString", str)
+
+
+class UnparsableDate(Warning):
+    pass
+
+
+class DocumentBody:
+    """
+    A class for abstracting out interactions with the body of a document.
+    """
+
+    def __init__(self, xml_bytestring: bytes):
+        self._xml = XML(xml_bytestring=xml_bytestring)
+        """ This is an instance of the `Document.XML` class for manipulation of the XML document itself. """
+
+    def get_xpath_match_string(self, xpath: str, namespaces: dict[str, str]) -> str:
+        return self._xml.get_xpath_match_string(xpath, namespaces)
+
+    @cached_property
+    def name(self) -> str:
+        return self._xml.get_xpath_match_string(
+            "/akn:akomaNtoso/akn:*/akn:meta/akn:identification/akn:FRBRWork/akn:FRBRname/@value",
+            {"akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0"},
+        )
+
+    @cached_property
+    def court(self) -> str:
+        return self._xml.get_xpath_match_string(
+            "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:court/text()",
+            {
+                "uk": "https://caselaw.nationalarchives.gov.uk/akn",
+                "akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0",
+            },
+        )
+
+    @cached_property
+    def jurisdiction(self) -> str:
+        return self._xml.get_xpath_match_string(
+            "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:jurisdiction/text()",
+            {
+                "uk": "https://caselaw.nationalarchives.gov.uk/akn",
+                "akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0",
+            },
+        )
+
+    @property
+    def court_and_jurisdiction_identifier_string(self) -> CourtIdentifierString:
+        if self.jurisdiction != "":
+            return CourtIdentifierString("/".join((self.court, self.jurisdiction)))
+        return CourtIdentifierString(self.court)
+
+    @cached_property
+    def document_date_as_string(self) -> str:
+        return self._xml.get_xpath_match_string(
+            "/akn:akomaNtoso/akn:*/akn:meta/akn:identification/akn:FRBRWork/akn:FRBRdate/@date",
+            {"akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0"},
+        )
+
+    @cached_property
+    def document_date_as_date(self) -> Optional[datetime.date]:
+        if not self.document_date_as_string:
+            return None
+        try:
+            return datetime.datetime.strptime(
+                self.document_date_as_string,
+                "%Y-%m-%d",
+            ).date()
+        except ValueError:
+            warnings.warn(
+                f"Unparsable date encountered: {self.document_date_as_string}",
+                UnparsableDate,
+            )
+            return None
+
+    def get_manifestation_datetimes(
+        self,
+        name: Optional[str] = None,
+    ) -> list[datetime.datetime]:
+        name_filter = f"[@name='{name}']" if name else ""
+        iso_datetimes = self._xml.get_xpath_match_strings(
+            "/akn:akomaNtoso/akn:*/akn:meta/akn:identification/akn:FRBRManifestation"
+            f"/akn:FRBRdate{name_filter}/@date",
+            {"akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0"},
+        )
+
+        return [parse_string_date_as_utc(event, pytz.UTC) for event in iso_datetimes]
+
+    def get_latest_manifestation_datetime(
+        self,
+        name: Optional[str] = None,
+    ) -> Optional[datetime.datetime]:
+        events = self.get_manifestation_datetimes(name)
+        if not events:
+            return None
+        return max(events)
+
+    def get_latest_manifestation_type(self) -> Optional[str]:
+        return max(
+            (
+                (type, time)
+                for type in ["transform", "tna-enriched"]
+                if (time := self.get_latest_manifestation_datetime(type))
+            ),
+            key=lambda x: x[1],
+        )[0]
+
+    @cached_property
+    def transformation_datetime(self) -> Optional[datetime.datetime]:
+        """When was this document successfully parsed or reparsed (date from XML)"""
+        return self.get_latest_manifestation_datetime("transform")
+
+    @cached_property
+    def enrichment_datetime(self) -> Optional[datetime.datetime]:
+        """When was this document successfully enriched (date from XML)"""
+        return self.get_latest_manifestation_datetime("tna-enriched")
+
+    @cached_property
+    def content_as_xml(self) -> str:
+        return self._xml.xml_as_string
+
+    @cached_property
+    def failed_to_parse(self) -> bool:
+        """
+        Did this document entirely fail to parse?
+
+        :return: `True` if there was a complete parser failure, otherwise `False`
+        """
+        if "error" in self._xml.root_element:
+            return True
+        return False

ds_caselaw_marklogic_api_client-26.0.0/src/caselawclient/models/documents/exceptions.py

@@ -0,0 +1,6 @@
+class CannotPublishUnpublishableDocument(Exception):
+    """A document which has failed publication safety checks in `Document.is_publishable` cannot be published."""
+
+
+class DocumentNotSafeForDeletion(Exception):
+    """A document which is not safe for deletion cannot be deleted."""

ds_caselaw_marklogic_api_client-26.0.0/src/caselawclient/models/documents/statuses.py

@@ -0,0 +1,12 @@
+DOCUMENT_STATUS_HOLD = "On hold"
+""" This document has been placed on hold to actively prevent publication. """
+
+DOCUMENT_STATUS_PUBLISHED = "Published"
+""" This document has been published and should be considered publicly visible. """
+
+DOCUMENT_STATUS_IN_PROGRESS = "In progress"
+""" This document has not been published or put on hold, and has been picked up by an editor and
+    should be progressing through the document pipeline. """
+
+DOCUMENT_STATUS_NEW = "New"
+""" This document isn't published, on hold, or assigned, and can be picked up by an editor in the future. """

ds_caselaw_marklogic_api_client-26.0.0/src/caselawclient/models/documents/xml.py

@@ -0,0 +1,43 @@
+from lxml import etree
+
+from caselawclient.xml_helpers import get_xpath_match_string, get_xpath_match_strings
+
+
+class NonXMLDocumentError(Exception):
+    """A document cannot be parsed as XML."""
+
+
+class XML:
+    """
+    A class for interacting with the raw XML of a document.
+    """
+
+    def __init__(self, xml_bytestring: bytes):
+        """
+        :raises NonXMLDocumentError: This document is not valid XML
+        """
+        try:
+            self.xml_as_tree: etree.Element = etree.fromstring(xml_bytestring)
+        except etree.XMLSyntaxError:
+            raise NonXMLDocumentError
+
+    @property
+    def xml_as_string(self) -> str:
+        """
+        :return: A string representation of this document's XML tree.
+        """
+        return str(etree.tostring(self.xml_as_tree).decode(encoding="utf-8"))
+
+    @property
+    def root_element(self) -> str:
+        return str(self.xml_as_tree.tag)
+
+    def get_xpath_match_string(self, xpath: str, namespaces: dict[str, str]) -> str:
+        return get_xpath_match_string(self.xml_as_tree, xpath, namespaces)
+
+    def get_xpath_match_strings(
+        self,
+        xpath: str,
+        namespaces: dict[str, str],
+    ) -> list[str]:
+        return get_xpath_match_strings(self.xml_as_tree, xpath, namespaces)

{ds_caselaw_marklogic_api_client-24.0.1 → ds_caselaw_marklogic_api_client-26.0.0}/src/caselawclient/models/judgments.py

@@ -8,7 +8,6 @@ from caselawclient.models.neutral_citation_mixin import NeutralCitationMixin
 if TYPE_CHECKING:
     from caselawclient.models.press_summaries import PressSummary
 
-from ..xml_helpers import get_xpath_match_string
 from .documents import Document
 
 
@@ -25,8 +24,7 @@ class Judgment(NeutralCitationMixin, Document):
 
     @cached_property
     def neutral_citation(self) -> str:
-        return get_xpath_match_string(
-            self.xml.xml_as_tree,
+        return self.body.get_xpath_match_string(
             "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:cite/text()",
             {
                 "uk": "https://caselaw.nationalarchives.gov.uk/akn",

{ds_caselaw_marklogic_api_client-24.0.1 → ds_caselaw_marklogic_api_client-26.0.0}/src/caselawclient/models/press_summaries.py

@@ -6,7 +6,6 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from caselawclient.errors import DocumentNotFoundError
 from caselawclient.models.neutral_citation_mixin import NeutralCitationMixin
-from caselawclient.xml_helpers import get_xpath_match_string
 
 from .documents import Document
 
@@ -27,8 +26,7 @@ class PressSummary(NeutralCitationMixin, Document):
 
     @cached_property
     def neutral_citation(self) -> str:
-        return get_xpath_match_string(
-            self.xml.xml_as_tree,
+        return self.body.get_xpath_match_string(
             "/akn:akomaNtoso/akn:doc/akn:preface/akn:p/akn:neutralCitation/text()",
             {
                 "akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0",

{ds_caselaw_marklogic_api_client-24.0.1 → ds_caselaw_marklogic_api_client-26.0.0}/src/caselawclient/models/utilities/aws.py

@@ -218,8 +218,7 @@ def build_new_key(old_key: str, new_uri: str) -> str:
     if old_filename.endswith(".docx") or old_filename.endswith(".pdf"):
         new_filename = new_uri.replace("/", "_")
         return f"{new_uri}/{new_filename}.{old_filename.split('.')[-1]}"
-    else:
-        return f"{new_uri}/{old_filename}"
+    return f"{new_uri}/{old_filename}"
 
 
 def request_parse(
@@ -250,6 +249,8 @@ def request_parse(
         },
     }
 
+    # breakpoint()
+
     client.publish(
         TopicArn=env("REPARSE_SNS_TOPIC"),
         Message=json.dumps(message_to_send),

ds_caselaw_marklogic_api_client-24.0.1/src/caselawclient/xml_tools.py

@@ -1,129 +0,0 @@
-import logging
-from typing import List, Optional
-from xml.etree.ElementTree import (
-    Element,
-    ElementTree,
-    ParseError,
-    QName,
-    fromstring,
-    tostring,
-)
-
-akn_uk_namespaces = {
-    "akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0",
-    "uk": "https://caselaw.nationalarchives.gov.uk/akn",
-}
-akn_namespace_uri = "http://docs.oasis-open.org/legaldocml/ns/akn/3.0"
-uk_namespace_uri = "https://caselaw.nationalarchives.gov.uk/akn"
-search_namespace = {"search": "http://marklogic.com/appservices/search"}
-
-
-class JudgmentMissingMetadataError(IndexError):
-    pass
-
-
-def get_element(
-    xml: ElementTree,
-    xpath: str,
-    element_name: str = "FRBRname",
-    element_namespace: str = akn_namespace_uri,
-    has_value_attribute: bool = True,
-) -> Element:
-    logging.warning(
-        "XMLTools is deprecated and will be removed in later versions. "
-        "Use methods from MarklogicApiClient.Client instead.",
-    )
-    name = xml.find(
-        xpath,
-        namespaces=akn_uk_namespaces,
-    )
-
-    if name is None:
-        element = Element(QName(element_namespace, element_name))  # type: ignore
-        if has_value_attribute:
-            element.set("value", "")
-        return element
-
-    return name
-
-
-def get_neutral_citation_element(xml: ElementTree) -> Element:
-    return get_element(xml, ".//uk:cite", "cite", uk_namespace_uri, False)
-
-
-def get_neutral_citation_name_value(xml: ElementTree) -> Optional[str]:
-    return get_neutral_citation_element(xml).text
-
-
-def get_judgment_date_element(xml: ElementTree) -> Element:
-    logging.warning(
-        "XMLTools is deprecated and will be removed in later versions. "
-        "Use methods from MarklogicApiClient.Client instead.",
-    )
-    name = xml.find(
-        ".//akn:FRBRWork/akn:FRBRdate",
-        namespaces=akn_uk_namespaces,
-    )
-
-    if name is None:
-        element = Element(QName(akn_namespace_uri, "FRBRdate"))  # type: ignore
-        element.set("date", "")
-        element.set("name", "judgment")
-
-        return element
-
-    return name
-
-
-def get_judgment_date_value(xml: ElementTree) -> str:
-    return get_judgment_date_element(xml).attrib["date"]
-
-
-def get_court_element(xml: ElementTree) -> Element:
-    return get_element(xml, ".//uk:court", "court", uk_namespace_uri, False)
-
-
-def get_court_value(xml: ElementTree) -> Optional[str]:
-    return get_court_element(xml).text
-
-
-def get_metadata_name_element(xml: ElementTree) -> Element:
-    return get_element(xml, ".//akn:FRBRname", "FRBRname", akn_namespace_uri, True)
-
-
-def get_metadata_name_value(xml: ElementTree) -> str:
-    name = get_metadata_name_element(xml)
-    value = name.attrib["value"]
-    if value is None:
-        return ""
-    return value
-
-
-def get_search_matches(element: ElementTree) -> List[str]:
-    logging.warning(
-        "XMLTools is deprecated and will be removed in later versions. "
-        "Use methods from MarklogicApiClient.Client instead.",
-    )
-    nodes = element.findall(".//search:match", namespaces=search_namespace)
-    results = []
-    for node in nodes:
-        text = tostring(node, method="text", encoding="UTF-8")
-        results.append(text.decode("UTF-8").strip())
-    return results
-
-
-def get_error_code(content_as_xml: Optional[str]) -> str:
-    logging.warning(
-        "XMLTools is deprecated and will be removed in later versions. "
-        "Use methods from MarklogicApiClient.Client instead.",
-    )
-    if not content_as_xml:
-        return "Unknown error, Marklogic returned a null or empty response"
-    try:
-        xml = fromstring(content_as_xml)
-        return xml.find(
-            "message-code",
-            namespaces={"": "http://marklogic.com/xdmp/error"},
-        ).text  # type: ignore
-    except (ParseError, TypeError, AttributeError):
-        return "Unknown error, Marklogic returned a null or empty response"