ds-caselaw-marklogic-api-client 17.2.0__tar.gz → 18.0.0__tar.gz

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ds-caselaw-marklogic-api-client
-Version: 17.2.0
+Version: 18.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
@@ -14,7 +14,7 @@ Requires-Dist: boto3 (>=1.26.112,<2.0.0)
 Requires-Dist: certifi (>=2022.12.7,<2024.0.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.0.0,<2.0.0)
+Requires-Dist: ds-caselaw-utils (>=1.3.3,<2.0.0)
 Requires-Dist: idna (>=3.4,<4.0)
 Requires-Dist: lxml (>=4.9.2,<5.0.0)
 Requires-Dist: memoization (>=0.4.0,<0.5.0)

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ds-caselaw-marklogic-api-client"
-version = "17.2.0"
+version = "18.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"
@@ -21,7 +21,7 @@ requests-toolbelt = ">=0.10.1,<1.1.0"
 urllib3 = "^1.26.15"
 memoization = "^0.4.0"
 lxml = "^4.9.2"
-ds-caselaw-utils = "^1.0.0"
+ds-caselaw-utils = "^1.3.3"
 boto3 = "^1.26.112"
 typing-extensions = "^4.7.1"
 mypy-boto3-s3 = "^1.26.104"
@@ -47,3 +47,5 @@ build-backend = "poetry.core.masonry.api"
 markers = [
     "write: the test deliberately changes the Marklogic DB')",
 ]
+
+filterwarnings = ["ignore::DeprecationWarning"]

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/Client.py

@@ -951,17 +951,3 @@ class MarklogicApiClient:
         )
 
         return results
-
-
-api_client = MarklogicApiClient(
-    host=env("MARKLOGIC_HOST", default=None),
-    username=env("MARKLOGIC_USER", default=None),
-    password=env("MARKLOGIC_PASSWORD", default=None),
-    use_https=env("MARKLOGIC_USE_HTTPS", default=False),
-)
-"""
-An instance of the API client which is automatically initialised on importing the library.
-
-.. deprecated:: 13.0.1
-   You should instead initialise your own instance of `MarklogicApiClient`
-"""

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/__init__.py

@@ -37,24 +37,4 @@ client = MarklogicApiClient(
 
 ```
 
-## (Deprecated) Use in-library client instance
-
-This library will automatically initialise an instance of the client. This functionality is deprecated, and will be
-removed.
-
-The client expects the following environment variables to be set or defined in a `.env` file:
-
-```bash
-MARKLOGIC_HOST
-MARKLOGIC_USER
-MARKLOGIC_PASSWORD
-MARKLOGIC_USE_HTTPS # Optional, defaults to False
-```
-
-Then import `api_client` from `caselawclient.Client`:
-
-```python
-from caselawclient.Client import api_client
-```
-
 """

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/client_helpers/search_helpers.py

@@ -1,3 +1,5 @@
+from lxml import etree
+
 from caselawclient.Client import MarklogicApiClient
 from caselawclient.responses.search_response import SearchResponse
 from caselawclient.search_parameters import SearchParameters
@@ -14,8 +16,11 @@ def search_judgments_and_parse_response(
 
     :return: The parsed search response as a SearchResponse object
     """
-    return SearchResponse.from_response_string(
-        api_client.search_judgments_and_decode_response(search_parameters)
+    return SearchResponse(
+        etree.fromstring(
+            api_client.search_judgments_and_decode_response(search_parameters)
+        ),
+        api_client,
     )
 
 
@@ -30,6 +35,7 @@ def search_and_parse_response(
 
     :return: The parsed search response as a SearchResponse object
     """
-    return SearchResponse.from_response_string(
-        api_client.search_and_decode_response(search_parameters)
+    return SearchResponse(
+        etree.fromstring(api_client.search_and_decode_response(search_parameters)),
+        api_client,
     )

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/models/documents.py

@@ -18,13 +18,15 @@ from ..errors import (
     OnlySupportedOnVersion,
 )
 from ..xml_helpers import get_xpath_match_string, get_xpath_match_strings
-from .utilities import VersionsDict, get_judgment_root, render_versions
+from .utilities import VersionsDict, render_versions
 from .utilities.aws import (
+    ParserInstructionsDict,
+    announce_document_event,
     delete_documents_from_private_bucket,
     generate_docx_url,
     generate_pdf_url,
-    notify_changed,
     publish_documents,
+    request_parse,
     unpublish_documents,
     uri_for_s3,
 )
@@ -74,6 +76,12 @@ class DocumentNotSafeForDeletion(Exception):
     pass
 
 
+class NonXMLDocumentError(Exception):
+    """A document cannot be parsed as XML."""
+
+    pass
+
+
 class Document:
     """
     A base class from which all other document types are extensions. This class includes the essential methods for
@@ -140,6 +148,12 @@ class Document:
         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
+            )
+        )
+
     def document_exists(self) -> bool:
         """Helper method to verify the existence of a document within MarkLogic.
 
@@ -165,14 +179,14 @@ class Document:
 
     @cached_property
     def name(self) -> str:
-        return self._get_xpath_match_string(
+        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._get_xpath_match_string(
+        return self.xml.get_xpath_match_string(
             "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:court/text()",
             {
                 "uk": "https://caselaw.nationalarchives.gov.uk/akn",
@@ -182,7 +196,7 @@ class Document:
 
     @cached_property
     def document_date_as_string(self) -> str:
-        return self._get_xpath_match_string(
+        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"},
         )
@@ -206,7 +220,7 @@ class Document:
         self, name: Optional[str] = None
     ) -> list[datetime.datetime]:
         name_filter = f"[@name='{name}']" if name else ""
-        iso_datetimes = self._get_xpath_match_strings(
+        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"},
@@ -248,6 +262,14 @@ class Document:
     def is_held(self) -> bool:
         return self.api_client.get_property(self.uri, "editor-hold") == "true"
 
+    @cached_property
+    def is_locked(self) -> bool:
+        return self.checkout_message is not None
+
+    @cached_property
+    def checkout_message(self) -> Optional[str]:
+        return self.api_client.get_judgment_checkout_status_message(self.uri)
+
     @cached_property
     def source_name(self) -> str:
         return self.api_client.get_property(self.uri, "source-name")
@@ -322,17 +344,7 @@ class Document:
 
     @cached_property
     def content_as_xml(self) -> str:
-        return self.api_client.get_judgment_xml(self.uri, show_unpublished=True)
-
-    @cached_property
-    def content_as_xml_bytestring(self) -> bytes:
-        return self.api_client.get_judgment_xml_bytestring(
-            self.uri, show_unpublished=True
-        )
-
-    @cached_property
-    def content_as_xml_tree(self) -> Any:
-        return etree.fromstring(self.content_as_xml_bytestring)
+        return self.xml.xml_as_string
 
     def content_as_html(
         self,
@@ -391,13 +403,10 @@ class Document:
 
         :return: `True` if there was a complete parser failure, otherwise `False`
         """
-        if "error" in self._get_root():
+        if "error" in self.xml.root_element:
             return True
         return False
 
-    def _get_root(self) -> str:
-        return get_judgment_root(self.content_as_xml_bytestring)
-
     @cached_property
     def has_name(self) -> bool:
         if not self.name:
@@ -448,9 +457,12 @@ class Document:
         return DOCUMENT_STATUS_NEW
 
     def enrich(self) -> None:
-        notify_changed(
+        """
+        Announces to the ANNOUNCE SNS that the document is waiting to be enriched.
+        """
+        announce_document_event(
             uri=self.uri,
-            status="published",
+            status="enrich",
             enrich=True,
         )
 
@@ -464,20 +476,19 @@ class Document:
 
         publish_documents(uri_for_s3(self.uri))
         self.api_client.set_published(self.uri, True)
-        notify_changed(
+        announce_document_event(
             uri=self.uri,
-            status="published",
-            enrich=True,
+            status="publish",
         )
+        self.enrich()
 
     def unpublish(self) -> None:
         self.api_client.break_checkout(self.uri)
         unpublish_documents(uri_for_s3(self.uri))
         self.api_client.set_published(self.uri, False)
-        notify_changed(
+        announce_document_event(
             uri=self.uri,
-            status="not published",
-            enrich=False,
+            status="unpublish",
         )
 
     def hold(self) -> None:
@@ -507,16 +518,73 @@ class Document:
         else:
             raise DocumentNotSafeForDeletion()
 
-    def _get_xpath_match_string(self, xpath: str, namespaces: Dict[str, str]) -> str:
-        return get_xpath_match_string(self.content_as_xml_tree, xpath, namespaces)
-
-    def _get_xpath_match_strings(
-        self, xpath: str, namespaces: Dict[str, str]
-    ) -> list[str]:
-        return get_xpath_match_strings(self.content_as_xml_tree, xpath, namespaces)
-
     def overwrite(self, new_citation: str) -> None:
         self.api_client.overwrite_document(self.uri, new_citation)
 
     def move(self, new_citation: str) -> None:
         self.api_client.update_document_uri(self.uri, new_citation)
+
+    def reparse(self) -> None:
+        "Send an SNS notification that triggers reparsing, also sending all editor-modifiable metadata and URI"
+
+        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
+        )
+
+        # the keys of parser_instructions should exactly match the parser output
+        # in the *-metadata.json files by the parser. Whilst typically empty
+        # values are "" from the API, we should pass None instead in this case.
+
+        parser_instructions: ParserInstructionsDict = {
+            "name": self.name or None,
+            "cite": self.best_human_identifier or None,
+            "court": self.court or None,
+            "date": checked_date,
+            "uri": self.uri,
+            "documentType": parser_type_noun,
+            "published": self.is_published,
+        }
+
+        request_parse(
+            uri=self.uri,
+            reference=self.consignment_reference,
+            parser_instructions=parser_instructions,
+        )
+
+    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-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/models/judgments.py

@@ -21,7 +21,7 @@ class Judgment(NeutralCitationMixin, Document):
     @cached_property
     def neutral_citation(self) -> str:
         return get_xpath_match_string(
-            self.content_as_xml_tree,
+            self.xml.xml_as_tree,
             "/akn:akomaNtoso/akn:*/akn:meta/akn:proprietary/uk:cite/text()",
             {
                 "uk": "https://caselaw.nationalarchives.gov.uk/akn",

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/models/press_summaries.py

@@ -21,7 +21,7 @@ class PressSummary(NeutralCitationMixin, Document):
     @cached_property
     def neutral_citation(self) -> str:
         return get_xpath_match_string(
-            self.content_as_xml_tree,
+            self.xml.xml_as_tree,
             "/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-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/models/utilities/__init__.py

@@ -1,5 +1,4 @@
 import re
-import xml.etree.ElementTree as ET
 from typing import TypedDict
 
 from requests_toolbelt.multipart.decoder import BodyPart
@@ -12,14 +11,6 @@ akn_namespace = {"akn": "http://docs.oasis-open.org/legaldocml/ns/akn/3.0"}
 uk_namespace = {"uk": "https://caselaw.nationalarchives.gov.uk/akn"}
 
 
-def get_judgment_root(judgment_xml: bytes) -> str:
-    try:
-        parsed_xml = ET.XML(judgment_xml)
-        return parsed_xml.tag
-    except ET.ParseError:
-        return "error"
-
-
 class VersionsDict(TypedDict):
     uri: str
     version: int

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/models/utilities/aws.py

@@ -1,6 +1,8 @@
+import datetime
 import json
 import logging
-from typing import Any, Literal, Union, overload
+import uuid
+from typing import Any, Literal, Optional, TypedDict, Union, overload
 
 import boto3
 import botocore.client
@@ -9,10 +11,21 @@ from mypy_boto3_s3.client import S3Client
 from mypy_boto3_s3.type_defs import CopySourceTypeDef, ObjectIdentifierTypeDef
 from mypy_boto3_sns.client import SNSClient
 from mypy_boto3_sns.type_defs import MessageAttributeValueTypeDef
+from typing_extensions import NotRequired
 
 env = environ.Env()
 
 
+class ParserInstructionsDict(TypedDict):
+    name: NotRequired[Optional[str]]
+    cite: NotRequired[Optional[str]]
+    court: NotRequired[Optional[str]]
+    date: NotRequired[Optional[str]]
+    uri: NotRequired[Optional[str]]
+    documentType: NotRequired[Optional[str]]
+    published: NotRequired[bool]
+
+
 @overload
 def create_aws_client(service: Literal["s3"]) -> S3Client:
     ...
@@ -64,10 +77,14 @@ def generate_signed_asset_url(key: str) -> str:
     )
 
 
-def generate_docx_url(uri: str) -> str:
-    key = f'{uri}/{uri.replace("/", "_")}.docx'
+def generate_docx_key(uri: str) -> str:
+    """from a canonical caselaw URI (eat/2022/1) return the S3 key of the associated docx"""
+    return f'{uri}/{uri.replace("/", "_")}.docx'
 
-    return generate_signed_asset_url(key)
+
+def generate_docx_url(uri: str) -> str:
+    """from a canonical caselaw URI (eat/2022/1) return a signed S3 link for the front end"""
+    return generate_signed_asset_url(generate_docx_key(uri))
 
 
 def generate_pdf_url(uri: str) -> str:
@@ -110,7 +127,7 @@ def publish_documents(uri: str) -> None:
 
         if not key.endswith("parser.log") and not key.endswith(".tar.gz"):
             source: CopySourceTypeDef = {"Bucket": private_bucket, "Key": key}
-            extra_args = {"ACL": "public-read"}
+            extra_args: dict[str, str] = {}
             try:
                 client.copy(source, public_bucket, key, extra_args)
             except botocore.client.ClientError as e:
@@ -127,7 +144,7 @@ def delete_documents_from_private_bucket(uri: str) -> None:
     delete_from_bucket(uri, env("PRIVATE_ASSET_BUCKET"))
 
 
-def notify_changed(uri: str, status: str, enrich: bool = False) -> None:
+def announce_document_event(uri: str, status: str, enrich: bool = False) -> None:
     client = create_sns_client()
 
     message_attributes: dict[str, MessageAttributeValueTypeDef] = {}
@@ -146,7 +163,7 @@ def notify_changed(uri: str, status: str, enrich: bool = False) -> None:
         }
 
     client.publish(
-        TopicArn=env("SNS_TOPIC"),
+        TopicArn=env("SNS_TOPIC"),  # this is the ANNOUNCE SNS topic
         Message=json.dumps({"uri_reference": uri, "status": status}),
         Subject=f"Updated: {uri} {status}",
         MessageAttributes=message_attributes,
@@ -189,3 +206,40 @@ def build_new_key(old_key: str, new_uri: str) -> str:
         return f"{new_uri}/{new_filename}.{old_filename.split('.')[-1]}"
     else:
         return f"{new_uri}/{old_filename}"
+
+
+def request_parse(
+    uri: str,
+    reference: Optional[str],
+    parser_instructions: Optional[ParserInstructionsDict] = None,
+) -> None:
+    client = create_sns_client()
+
+    if parser_instructions is None:
+        parser_instructions = ParserInstructionsDict({})
+
+    message_to_send = {
+        "properties": {
+            "messageType": "uk.gov.nationalarchives.da.messages.request.courtdocument.parse.RequestCourtDocumentParse",
+            "timestamp": datetime.datetime.now(datetime.timezone.utc)
+            .isoformat()
+            .replace("+00:00", "Z"),
+            "function": "fcl-judgment-parse-request",
+            "producer": "FCL",
+            "executionId": f"fcl_ex_id_{uuid.uuid4()}",
+            "parentExecutionId": None,
+        },
+        "parameters": {
+            "s3Bucket": env("PRIVATE_ASSET_BUCKET"),
+            "s3Key": generate_docx_key(uri),
+            "reference": reference or f"FCL-{uuid.uuid4()}",
+            "originator": "FCL",
+            "parserInstructions": parser_instructions,
+        },
+    }
+
+    client.publish(
+        TopicArn=env("REPARSE_SNS_TOPIC"),
+        Message=json.dumps(message_to_send),
+        Subject=f"Reparse request: {uri}",
+    )

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/responses/search_response.py

@@ -2,6 +2,7 @@ from typing import List
 
 from lxml import etree
 
+from caselawclient.Client import MarklogicApiClient
 from caselawclient.responses.search_result import SearchResult
 
 
@@ -13,22 +14,14 @@ class SearchResponse:
     NAMESPACES = {"search": "http://marklogic.com/appservices/search"}
     """ Namespaces used in XPath expressions."""
 
-    def __init__(self, node: etree._Element) -> None:
+    def __init__(self, node: etree._Element, client: MarklogicApiClient) -> None:
         """
         Initializes a SearchResponse instance from an xml node.
 
         :param node: The XML data as an etree element
         """
         self.node = node
-
-    @staticmethod
-    def from_response_string(xml: str) -> "SearchResponse":
-        """
-        Constructs a SearchResponse instance from an xml response string.
-
-        :param xml: The XML data as a string
-        """
-        return SearchResponse(etree.fromstring(xml))
+        self.client = client
 
     @property
     def total(self) -> str:
@@ -51,9 +44,4 @@ class SearchResponse:
         results = self.node.xpath(
             "//search:response/search:result", namespaces=self.NAMESPACES
         )
-        return [
-            SearchResult(
-                result,
-            )
-            for result in results
-        ]
+        return [SearchResult(result, self.client) for result in results]

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/responses/search_result.py

@@ -2,6 +2,7 @@ import logging
 import os
 from datetime import datetime
 from enum import Enum
+from functools import cached_property
 from typing import Dict, Optional
 
 from dateutil import parser as dateparser
@@ -9,7 +10,7 @@ from dateutil.parser import ParserError
 from ds_caselaw_utils.courts import Court, CourtNotFoundException, courts
 from lxml import etree
 
-from caselawclient.Client import api_client
+from caselawclient.Client import MarklogicApiClient
 from caselawclient.models.documents import DocumentURIString
 from caselawclient.xml_helpers import get_xpath_match_string
 
@@ -44,20 +45,6 @@ class SearchResultMetadata:
         self.node = node
         self.last_modified = last_modified
 
-    @staticmethod
-    def create_from_uri(uri: DocumentURIString) -> "SearchResultMetadata":
-        """
-        Create a SearchResultMetadata instance from a search result URI.
-
-        :param uri: The URI of the search result
-
-        :return: The created SearchResultMetadata instance
-        """
-        response_text = api_client.get_properties_for_search_results([uri])
-        last_modified = api_client.get_last_modified(uri)
-        root = etree.fromstring(response_text)
-        return SearchResultMetadata(root, last_modified)
-
     @property
     def author(self) -> str:
         """
@@ -162,12 +149,13 @@ class SearchResult:
     }
     """ Namespace mappings used in XPath expressions. """
 
-    def __init__(self, node: etree._Element):
+    def __init__(self, node: etree._Element, client: MarklogicApiClient):
         """
         :param node: The XML element representing the search result
         """
 
         self.node = node
+        self.client = client
 
     @property
     def uri(self) -> DocumentURIString:
@@ -259,15 +247,15 @@ class SearchResult:
         xslt_transform = etree.XSLT(etree.parse(file_path))
         return str(xslt_transform(self.node))
 
-    @property
+    @cached_property
     def metadata(self) -> SearchResultMetadata:
         """
-        :return: The metadata of the search result
+        :return: A `SearchResultMetadata` instance representing the metadata of this result
         """
-
-        return SearchResultMetadata.create_from_uri(
-            self.uri,
-        )
+        response_text = self.client.get_properties_for_search_results([self.uri])
+        last_modified = self.client.get_last_modified(self.uri)
+        root = etree.fromstring(response_text)
+        return SearchResultMetadata(root, last_modified)
 
     def _get_xpath_match_string(self, path: str) -> str:
         return get_xpath_match_string(self.node, path, namespaces=self.NAMESPACES)

{ds_caselaw_marklogic_api_client-17.2.0 → ds_caselaw_marklogic_api_client-18.0.0}/src/caselawclient/search_parameters.py

@@ -73,6 +73,8 @@ class SearchParameters:
             "ewhc/kb": "ewhc/qb",
             "ewhc/scco": "ewhc/costs",
             "ewhc/costs": "ewhc/scco",
+            "ukait": "ukut/iac",
+            "ukut/iac": "ukait",
         }
         alternative_court_names = set()
         for primary_name, secondary_name in ALTERNATIVE_COURT_NAMES_MAP.items():