ds-caselaw-marklogic-api-client 27.0.0__tar.gz → 43.0.0__tar.gz

{ds_caselaw_marklogic_api_client-27.0.0 → ds_caselaw_marklogic_api_client-43.0.0}/PKG-INFO

@@ -1,30 +1,33 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: ds-caselaw-marklogic-api-client
-Version: 27.0.0
+Version: 43.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
 Author: The National Archives
-Requires-Python: >=3.9,<4.0
+Requires-Python: >=3.12.0,<4.0.0
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: boto3 (>=1.26.112,<2.0.0)
-Requires-Dist: certifi (>=2024.8.30,<2024.9.0)
+Requires-Dist: certifi (>=2025.10.5,<2025.11.0)
 Requires-Dist: charset-normalizer (>=3.0.0,<4.0.0)
-Requires-Dist: django-environ (>=0.11.0,<0.12.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: idna (>=3.4,<4.0)
-Requires-Dist: lxml (>=5.0.0,<6.0.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.1,<2025.0)
+Requires-Dist: pytz (>2024)
 Requires-Dist: requests (>=2.28.2,<3.0.0)
 Requires-Dist: requests-toolbelt (>=0.10.1,<1.1.0)
+Requires-Dist: saxonche (>=12.5.0,<13.0.0)
+Requires-Dist: sqids (>=0.5.0,<0.6.0)
 Requires-Dist: typing-extensions (>=4.7.1,<5.0.0)
+Project-URL: Homepage, https://github.com/nationalarchives/ds-caselaw-custom-api-client
 Description-Content-Type: text/markdown
 
 # The National Archives: Find Case Law
@@ -33,7 +36,9 @@ This repository is part of the [Find Case Law](https://caselaw.nationalarchives.
 
 # MarkLogic API Client
 
-[![PyPI](https://img.shields.io/pypi/v/ds-caselaw-marklogic-api-client)](https://pypi.org/project/ds-caselaw-marklogic-api-client/) ![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/pypi/ds-caselaw-marklogic-api-client)
+[![PyPI](https://img.shields.io/pypi/v/ds-caselaw-marklogic-api-client)](https://pypi.org/project/ds-caselaw-marklogic-api-client/)
+![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/pypi/ds-caselaw-marklogic-api-client)
+![Code Coverage](https://img.shields.io/codecov/c/github/nationalarchives/ds-caselaw-custom-api-client)
 
 This is an API Client for connecting to Marklogic for The National Archive's Caselaw site.
 

{ds_caselaw_marklogic_api_client-27.0.0 → ds_caselaw_marklogic_api_client-43.0.0}/README.md

@@ -4,7 +4,9 @@ This repository is part of the [Find Case Law](https://caselaw.nationalarchives.
 
 # MarkLogic API Client
 
-[![PyPI](https://img.shields.io/pypi/v/ds-caselaw-marklogic-api-client)](https://pypi.org/project/ds-caselaw-marklogic-api-client/) ![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/pypi/ds-caselaw-marklogic-api-client)
+[![PyPI](https://img.shields.io/pypi/v/ds-caselaw-marklogic-api-client)](https://pypi.org/project/ds-caselaw-marklogic-api-client/)
+![Libraries.io dependency status for latest release](https://img.shields.io/librariesio/release/pypi/ds-caselaw-marklogic-api-client)
+![Code Coverage](https://img.shields.io/codecov/c/github/nationalarchives/ds-caselaw-custom-api-client)
 
 This is an API Client for connecting to Marklogic for The National Archive's Caselaw site.
 

{ds_caselaw_marklogic_api_client-27.0.0 → ds_caselaw_marklogic_api_client-43.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ds-caselaw-marklogic-api-client"
-version = "27.0.0"
+version = "43.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"
@@ -11,36 +11,42 @@ packages = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.9"
-certifi = ">=2024.8.30,<2024.9.0"
+python = "^3.12.0"
+certifi = ">=2025.10.5,<2025.11.0"
 charset-normalizer = "^3.0.0"
-django-environ = "^0.11.0"
+django-environ = ">=0.12.0"
 idna = "^3.4"
 requests = "^2.28.2"
 requests-toolbelt = ">=0.10.1,<1.1.0"
 memoization = "^0.4.0"
-lxml = "^5.0.0"
+lxml = "^6.0.0"
 ds-caselaw-utils = "^2.0.0"
 boto3 = "^1.26.112"
 typing-extensions = "^4.7.1"
 mypy-boto3-s3 = "^1.26.104"
 mypy-boto3-sns = "^1.26.69"
-pytz = "^2024.1"
+pytz = ">2024"
 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.2.3"
-pytest = "^8.0.0"
-responses = "^0.25.0"
-python-dotenv = "^1.0.0"
-time-machine = "^2.13.0"
-moto = {version = "^5.0.1", extras = ["all"]}
+coverage = "7.11.0"
+pytest = "8.4.2"
+pytest-cov = "7.0.0"
+beautifulsoup4 = "4.14.2"
+responses = "0.25.8"
+python-dotenv = "1.2.1"
+time-machine = "2.19.0"
+moto = {version = "5.1.15", extras = ["all"]}
 
 [tool.poetry.group.docs]
 optional = true
 
 [tool.poetry.group.docs.dependencies]
-pdoc = "^14.0.0"
+pdoc = "^15.0.0"
 
 
 [tool.commitizen]
@@ -49,6 +55,8 @@ tag_format = "v$version"
 version_scheme = "semver2"
 version_provider = "poetry"
 update_changelog_on_bump = true
+changelog_incremental = true
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
@@ -64,14 +72,15 @@ line-length = 120
 
 [tool.ruff.lint]
 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", "SIM"]
-# extend-select = [ "B", "Q", "C90", "I", "UP", "YTT", "ASYNC", "S", "BLE", "A", "COM", "C4", "DTZ", "T10", "DJ", "EM", "EXE", "FA",
+extend-select = ["W", "I", "SLF", "SIM", "C90", "S"]
+# extend-select = [ "B", "Q", "I", "UP", "YTT", "ASYNC", "BLE", "A", "COM", "C4", "DTZ", "T10", "DJ", "EM", "EXE", "FA",
 #                  "ISC", "ICN", "G", "INP", "PIE", "T20", "PYI", "PT", "Q", "RSE", "RET", "SLOT", "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/*" = ["S101"] # `assert` is fine in tests
+"smoketest/*" = ["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:

{ds_caselaw_marklogic_api_client-27.0.0 → ds_caselaw_marklogic_api_client-43.0.0}/src/caselawclient/Client.py

@@ -7,29 +7,34 @@ import warnings
 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, ParseError, fromstring
+from xml.etree.ElementTree import Element
 
 import environ
 import requests
+from dateutil.parser import isoparse
+from defusedxml import ElementTree
+from defusedxml.ElementTree import ParseError, fromstring
 from ds_caselaw_utils.types import NeutralCitationString
+from lxml import etree
 from requests.auth import HTTPBasicAuth
 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,
-    DocumentURIString,
 )
+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.xquery_type_dicts import (
+    CheckContentHashUniqueByUriDict,
     MarkLogicDocumentURIString,
     MarkLogicDocumentVersionURIString,
     MarkLogicPrivilegeURIString,
@@ -53,6 +58,11 @@ from .errors import (
 )
 
 env = environ.Env()
+
+# Requests timeouts: https://requests.readthedocs.io/en/latest/user/advanced/
+CONNECT_TIMEOUT = float(os.environ.get("CONNECT_TIMEOUT", "3.05"))
+READ_TIMEOUT = float(os.environ.get("READ_TIMEOUT", "10.0"))
+
 ROOT_DIR = os.path.dirname(os.path.realpath(__file__))
 DEFAULT_XSL_TRANSFORM = "accessible-html.xsl"
 
@@ -62,6 +72,8 @@ except importlib.metadata.PackageNotFoundError:
     VERSION = "0"
 DEFAULT_USER_AGENT = f"ds-caselaw-marklogic-api-client/{VERSION}"
 
+DEBUG: bool = bool(os.getenv("DEBUG", default=False))
+
 
 class NoResponse(Exception):
     """A requests HTTPError has no response. We expect this will never happen."""
@@ -73,12 +85,6 @@ class MultipartResponseLongerThanExpected(Exception):
     """
 
 
-class DocumentHasNoTypeCollection(Exception):
-    """
-    A MarkLogic document is not part of a collection which identifies its document type.
-    """
-
-
 def get_multipart_strings_from_marklogic_response(
     response: requests.Response,
 ) -> list[str]:
@@ -171,6 +177,7 @@ class MarklogicApiClient:
     error_code_classes: dict[str, Type[MarklogicAPIError]] = {
         "XDMP-DOCNOTFOUND": MarklogicResourceNotFoundError,
         "XDMP-LOCKCONFLICT": MarklogicResourceLockedError,
+        "XDMP-LOCKED": MarklogicResourceLockedError,
         "DLS-UNMANAGED": MarklogicResourceUnmanagedError,
         "DLS-NOTCHECKEDOUT": MarklogicResourceNotCheckedOutError,
         "DLS-CHECKOUTCONFLICT": MarklogicCheckoutConflictError,
@@ -207,20 +214,22 @@ class MarklogicApiClient:
         Returns a list of PressSummary objects associated with a given Document URI
         """
         vars: query_dicts.GetComponentsForDocumentDict = {
-            "parent_uri": DocumentURIString(uri if uri.startswith("/") else "/" + uri),
+            "parent_uri": uri,
             "component": "pressSummary",
         }
         response = self._send_to_eval(vars, "get_components_for_document.xqy")
         uris = get_multipart_strings_from_marklogic_response(response)
-        return [PressSummary(uri.strip(".xml"), self) for uri in uris]
+        return [
+            PressSummary(DocumentURIString(uri.strip("/").strip(".xml")), self) for uri in uris
+        ]  # TODO: Migrate this strip behaviour into proper manipulation of a MarkLogicURIString
 
     def get_document_by_uri(
         self,
         uri: DocumentURIString,
-        query: Optional[str] = None,
+        search_query: Optional[str] = None,
     ) -> Document:
         document_type_class = self.get_document_type_from_uri(uri)
-        return document_type_class(uri, self)
+        return document_type_class(uri, self, search_query=search_query)
 
     def get_document_type_from_uri(self, uri: DocumentURIString) -> Type[Document]:
         vars: query_dicts.DocumentCollectionsDict = {
@@ -233,9 +242,7 @@ class MarklogicApiClient:
             return Judgment
         if DOCUMENT_COLLECTION_URI_PRESS_SUMMARY in collections:
             return PressSummary
-        raise DocumentHasNoTypeCollection(
-            f"The document at URI {uri} is not part of a valid document type collection.",
-        )
+        return Document
 
     def _get_error_code_class(self, error_code: str) -> Type[MarklogicAPIError]:
         """
@@ -260,10 +267,12 @@ class MarklogicApiClient:
             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
+            return str(
+                xml.find(
+                    "message-code",
+                    namespaces={"": "http://marklogic.com/xdmp/error"},
+                ).text
+            )
         except (ParseError, TypeError, AttributeError):
             return "Unknown error, Marklogic returned a null or empty response"
 
@@ -316,11 +325,13 @@ class MarklogicApiClient:
         self,
         vars: query_dicts.MarkLogicAPIDict,
         xquery_file_name: str,
+        timeout: tuple[float, float] = (CONNECT_TIMEOUT, READ_TIMEOUT),
     ) -> requests.Response:
         return self.eval(
             self._xquery_path(xquery_file_name),
             vars=json.dumps(vars),
             accept_header="application/xml",
+            timeout=timeout,
         )
 
     def _eval_and_decode(
@@ -403,6 +414,7 @@ class MarklogicApiClient:
         judgment_uri: DocumentURIString,
         version_uri: Optional[DocumentURIString] = None,
         show_unpublished: bool = False,
+        search_query: Optional[str] = None,
     ) -> bytes:
         marklogic_document_uri = self._format_uri_for_marklogic(judgment_uri)
         marklogic_document_version_uri = (
@@ -418,6 +430,7 @@ class MarklogicApiClient:
             "uri": marklogic_document_uri,
             "version_uri": marklogic_document_version_uri,
             "show_unpublished": show_unpublished,
+            "search_query": search_query,
         }
 
         response = self._eval_as_bytes(vars, "get_judgment.xqy")
@@ -433,11 +446,13 @@ class MarklogicApiClient:
         judgment_uri: DocumentURIString,
         version_uri: Optional[DocumentURIString] = None,
         show_unpublished: bool = False,
+        search_query: Optional[str] = None,
     ) -> str:
         return self.get_judgment_xml_bytestring(
             judgment_uri,
             version_uri,
             show_unpublished,
+            search_query=search_query,
         ).decode(encoding="utf-8")
 
     def set_document_name(
@@ -562,6 +577,7 @@ class MarklogicApiClient:
         self,
         document_uri: DocumentURIString,
         document_xml: Element,
+        document_type: type[Document],
         annotation: VersionAnnotation,
     ) -> requests.Response:
         """
@@ -569,6 +585,7 @@ class MarklogicApiClient:
 
         :param document_uri: The URI to insert the document at
         :param document_xml: The XML of the document to insert
+        :param document_type: The type class of the document
         :param annotation: Annotations to record alongside this version
 
         :return: The response object from MarkLogic
@@ -582,6 +599,7 @@ class MarklogicApiClient:
 
         vars: query_dicts.InsertDocumentDict = {
             "uri": uri,
+            "type_collection": document_type.type_collection_name,
             "document": xml.decode("utf-8"),
             "annotation": annotation.as_json,
         }
@@ -634,12 +652,14 @@ class MarklogicApiClient:
         judgment_uri: DocumentURIString,
         annotation: str = "",
         expires_at_midnight: bool = False,
+        timeout_seconds: int = -1,
     ) -> requests.Response:
+        """If timeout_seconds is -1, the lock never times out"""
         uri = self._format_uri_for_marklogic(judgment_uri)
         vars: query_dicts.CheckoutJudgmentDict = {
             "uri": uri,
             "annotation": annotation,
-            "timeout": -1,
+            "timeout": timeout_seconds,
         }
 
         if expires_at_midnight:
@@ -675,10 +695,12 @@ class MarklogicApiClient:
         if content == "":
             return None
         response_xml = ElementTree.fromstring(content)
-        return response_xml.find(
-            "dls:annotation",
-            namespaces={"dls": "http://marklogic.com/xdmp/dls"},
-        ).text  # type: ignore
+        return str(
+            response_xml.find(
+                "dls:annotation",
+                namespaces={"dls": "http://marklogic.com/xdmp/dls"},
+            ).text
+        )
 
     def get_judgment_version(
         self,
@@ -707,11 +729,20 @@ 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,
         vars: str,
         accept_header: str = "multipart/mixed",
+        timeout: tuple[float, float] = (CONNECT_TIMEOUT, READ_TIMEOUT),
     ) -> requests.Response:
         headers = {
             "Content-type": "application/x-www-form-urlencoded",
@@ -722,11 +753,16 @@ class MarklogicApiClient:
             "vars": vars,
         }
         path = "LATEST/eval"
+
+        if DEBUG:
+            print(f"Sending {vars} to {xquery_path}")
+
         response = self.session.request(
             "POST",
             url=self._path_to_request_url(path),
             headers=headers,
             data=data,
+            timeout=timeout,
         )
         # Raise relevant exception for an erroneous response
         self._raise_for_status(response)
@@ -766,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:
@@ -850,6 +888,17 @@ class MarklogicApiClient:
         }
         return self._eval_and_decode(vars, "get_property.xqy")
 
+    def get_property_as_node(self, judgment_uri: DocumentURIString, name: str) -> Optional[etree._Element]:
+        uri = self._format_uri_for_marklogic(judgment_uri)
+        vars: query_dicts.GetPropertyAsNodeDict = {
+            "uri": uri,
+            "name": name,
+        }
+        value = self._eval_and_decode(vars, "get_property_as_node.xqy")
+        if not value:
+            return None
+        return etree.fromstring(value)
+
     def get_version_annotation(self, judgment_uri: DocumentURIString) -> str:
         uri = self._format_uri_for_marklogic(judgment_uri)
         vars: query_dicts.GetVersionAnnotationDict = {
@@ -882,6 +931,22 @@ class MarklogicApiClient:
 
         return self._send_to_eval(vars, "set_property.xqy")
 
+    def set_property_as_node(
+        self,
+        judgment_uri: DocumentURIString,
+        name: str,
+        value: etree._Element,
+    ) -> requests.Response:
+        """Given a root node, set the value of the MarkLogic property for a document to the _contents_ of that root node. The root node itself is discarded."""
+        uri = self._format_uri_for_marklogic(judgment_uri)
+        vars: query_dicts.SetPropertyAsNodeDict = {
+            "uri": uri,
+            "value": etree.tostring(value).decode(),
+            "name": name,
+        }
+
+        return self._send_to_eval(vars, "set_property_as_node.xqy")
+
     def set_boolean_property(
         self,
         judgment_uri: DocumentURIString,
@@ -895,12 +960,50 @@ class MarklogicApiClient:
             "value": string_value,
             "name": name,
         }
+        """
+        Set a property within MarkLogic which is specifically a boolean.
+
+        Since XML has no concept of boolean, the actual value in the database is set to `"true"` or `"false"`.
+        """
         return self._send_to_eval(vars, "set_boolean_property.xqy")
 
     def get_boolean_property(self, judgment_uri: DocumentURIString, name: str) -> bool:
+        """
+        Get a property from MarkLogic which is specifically a boolean.
+
+        :return: `True` if the property exists and has a value of `"true"`, otherwise `False`
+        """
         content = self.get_property(judgment_uri, name)
         return content == "true"
 
+    def set_datetime_property(
+        self,
+        judgment_uri: DocumentURIString,
+        name: str,
+        value: datetime,
+    ) -> requests.Response:
+        """Set a property within MarkLogic which is specifically a datetime."""
+        uri = self._format_uri_for_marklogic(judgment_uri)
+        vars: query_dicts.SetDatetimePropertyDict = {
+            "uri": uri,
+            "value": value.isoformat(),
+            "name": name,
+        }
+        return self._send_to_eval(vars, "set_datetime_property.xqy")
+
+    def get_datetime_property(self, judgment_uri: DocumentURIString, name: str) -> Optional[datetime]:
+        """
+        Get a property from MarkLogic which is specifically a datetime.
+
+        :return: A datetime with the value of the property, or `None` if it does not exist
+        """
+        content = self.get_property(judgment_uri, name)
+
+        if content:
+            return isoparse(content)
+
+        return None
+
     def set_published(
         self,
         judgment_uri: DocumentURIString,
@@ -1009,10 +1112,6 @@ class MarklogicApiClient:
         if show_unpublished and not self.user_can_view_unpublished_judgments(
             self.username,
         ):
-            # The user cannot view unpublished judgments but is requesting to see them
-            logging.warning(
-                f"User {self.username} is attempting to view unpublished judgments but does not have that privilege.",
-            )
             return False
         return show_unpublished
 
@@ -1025,14 +1124,14 @@ class MarklogicApiClient:
         response = self._send_to_eval(vars, "get_properties_for_search_results.xqy")
         return get_single_string_from_marklogic_response(response)
 
-    def search_and_decode_response(self, search_parameters: SearchParameters) -> str:
+    def search_and_decode_response(self, search_parameters: SearchParameters) -> bytes:
         response = self.advanced_search(search_parameters)
-        return get_single_string_from_marklogic_response(response)
+        return get_single_bytestring_from_marklogic_response(response)
 
     def search_judgments_and_decode_response(
         self,
         search_parameters: SearchParameters,
-    ) -> str:
+    ) -> bytes:
         search_parameters.collections = [DOCUMENT_COLLECTION_URI_JUDGMENT]
         return self.search_and_decode_response(search_parameters)
 
@@ -1074,6 +1173,7 @@ class MarklogicApiClient:
         self,
         target_enrichment_version: tuple[int, int],
         target_parser_version: tuple[int, int],
+        maximum_records: int = 1000,
     ) -> list[list[Any]]:
         """Retrieve documents which are not yet enriched with a given version."""
         vars: query_dicts.GetPendingEnrichmentForVersionDict = {
@@ -1081,6 +1181,7 @@ class MarklogicApiClient:
             "target_enrichment_minor_version": target_enrichment_version[1],
             "target_parser_major_version": target_parser_version[0],
             "target_parser_minor_version": target_parser_version[1],
+            "maximum_records": maximum_records,
         }
         results: list[list[Any]] = json.loads(
             get_single_string_from_marklogic_response(
@@ -1093,6 +1194,21 @@ class MarklogicApiClient:
 
         return results
 
+    def get_recently_enriched(
+        self,
+    ) -> list[list[Any]]:
+        """Retrieve documents which are not yet enriched with a given version."""
+        results: list[list[Any]] = json.loads(
+            get_single_string_from_marklogic_response(
+                self._send_to_eval(
+                    {},
+                    "get_recently_enriched.xqy",
+                ),
+            ),
+        )
+
+        return results
+
     def get_highest_parser_version(self) -> tuple[int, int]:
         """This gets the highest parser version in the database, so if nothing has been parsed with the most recent version of the parser, this won't reflect that change."""
         table = json.loads(
@@ -1109,11 +1225,13 @@ class MarklogicApiClient:
     def get_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 = {
             "target_major_version": target_version[0],
             "target_minor_version": target_version[1],
+            "maximum_records": maximum_records,
         }
         results: list[list[Any]] = json.loads(
             get_single_string_from_marklogic_response(
@@ -1125,3 +1243,74 @@ class MarklogicApiClient:
         )
 
         return results
+
+    def get_recently_parsed(
+        self,
+    ) -> list[list[Any]]:
+        """Retrieve documents which are not yet enriched with a given version."""
+        results: list[list[Any]] = json.loads(
+            get_single_string_from_marklogic_response(
+                self._send_to_eval(
+                    {},
+                    "get_recently_parsed.xqy",
+                ),
+            ),
+        )
+
+        return results
+
+    def get_missing_fclid(
+        self,
+        maximum_records: int = 50,
+    ) -> list[str]:
+        """Retrieve the URIs of published documents which do not have an identifier in the `fclid` schema."""
+        vars: query_dicts.GetMissingFclidDict = {
+            "maximum_records": maximum_records,
+        }
+
+        results: list[str] = get_multipart_strings_from_marklogic_response(
+            self._send_to_eval(
+                vars,
+                "get_missing_fclid.xqy",
+            )
+        )
+
+        return results
+
+    def resolve_from_identifier_slug(
+        self, identifier_slug: DocumentIdentifierSlug, published_only: bool = True
+    ) -> IdentifierResolutions:
+        """Given a PUI/EUI url, look up the precomputed slug and return the
+        MarkLogic document URIs which match that slug. Multiple returns should be anticipated"""
+        vars: query_dicts.ResolveFromIdentifierSlugDict = {
+            "identifier_slug": identifier_slug,
+            "published_only": int(published_only),
+        }
+        raw_results: list[str] = get_multipart_strings_from_marklogic_response(
+            self._send_to_eval(
+                vars,
+                "resolve_from_identifier_slug.xqy",
+            ),
+        )
+        return IdentifierResolutions.from_marklogic_output(raw_results)
+
+    def resolve_from_identifier_value(
+        self, identifier_value: DocumentIdentifierValue, published_only: bool = True
+    ) -> IdentifierResolutions:
+        """Given a PUI/EUI url, look up the precomputed slug and return the
+        MarkLogic document URIs which match that slug. Multiple returns should be anticipated"""
+        vars: query_dicts.ResolveFromIdentifierValueDict = {
+            "identifier_value": identifier_value,
+            "published_only": int(published_only),
+        }
+        raw_results: list[str] = get_multipart_strings_from_marklogic_response(
+            self._send_to_eval(
+                vars,
+                "resolve_from_identifier_value.xqy",
+            ),
+        )
+        return IdentifierResolutions.from_marklogic_output(raw_results)
+
+    def get_next_document_sequence_number(self) -> int:
+        """Increment the MarkLogic sequence number by one and return the value."""
+        return int(self._eval_and_decode({}, "get_next_document_sequence_number.xqy"))