cellar-extractor 2.0.2__tar.gz → 2.0.4__tar.gz

{cellar_extractor-2.0.2/cellar_extractor.egg-info → cellar_extractor-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellar-extractor
-Version: 2.0.2
+Version: 2.0.4
 Summary: Library for extracting CELLAR case law data from EUR-Lex
 Author-email: LawTech Lab <law-techlab@maastrichtuniversity.nl>
 License: Apache-2.0
@@ -127,6 +127,11 @@ df = cell.get_cellar(
 
 Returns a dataframe with base metadata such as CELEX, ECLI, type, dates, and subject-matter-related fields.
 
+For direct manifestation access, use
+`get_cellar_manifestations_by_celex()`. It canonicalizes composite and
+`_SUM`/`_RES`/`_INF` identifiers to the base work before querying, preventing
+derived summaries or notices from being returned as judgment full text.
+
 You can also save explicitly to a custom path instead of the default `data/` location:
 
 ```python
@@ -153,6 +158,20 @@ extra_df, fulltext = cell.get_cellar_extra(
 )
 ```
 
+For targeted CELEX repair or supplementation, use the public CELLAR
+manifestation API. It unions every CELLAR work sharing the CELEX before choosing
+the best downloadable item per language:
+
+```python
+import cellar_extractor as cell
+
+_, manifestations = cell.get_cellar_manifestations_by_celex(
+    "62020CJ0414", sector="6"
+)
+english = [m for m in manifestations if m["language"] == "EN"]
+fulltexts = cell.extract_cellar_fulltexts(english)
+```
+
 Returns:
 
 - `extra_df`: enriched dataframe
@@ -303,6 +322,8 @@ Imported from [`cellar_extractor/__init__.py`](/Users/davidwickerhf/Projects/wor
 | `get_cellar(...)` | Fetch base CELLAR metadata (case law only) |
 | `get_cellar_extra(...)` | Fetch enriched metadata + full text (case law only) |
 | `get_legislation_by_celex_id(celex, language="EN")` | Fetch sector 3 / sector 0 legislation XHTML by CELEX |
+| `get_cellar_manifestations_by_celex(celex, sector="8")` | Resolve every CELLAR work for a CELEX and return their deduplicated manifestation union |
+| `extract_cellar_fulltexts(manifestations, source_label="CELLAR_ITEM")` | Download the best manifestation per language as fulltext records |
 | `get_nodes_and_edges_lists(df, only_local=False)` | Build citation graph lists |
 | `filter_subject_matter(df, phrase)` | Filter dataframe by subject phrase |
 | `FetchOperativePart` | Extract operative part from a single case document |

{cellar_extractor-2.0.2 → cellar_extractor-2.0.4}/README.md

@@ -92,6 +92,11 @@ df = cell.get_cellar(
 
 Returns a dataframe with base metadata such as CELEX, ECLI, type, dates, and subject-matter-related fields.
 
+For direct manifestation access, use
+`get_cellar_manifestations_by_celex()`. It canonicalizes composite and
+`_SUM`/`_RES`/`_INF` identifiers to the base work before querying, preventing
+derived summaries or notices from being returned as judgment full text.
+
 You can also save explicitly to a custom path instead of the default `data/` location:
 
 ```python
@@ -118,6 +123,20 @@ extra_df, fulltext = cell.get_cellar_extra(
 )
 ```
 
+For targeted CELEX repair or supplementation, use the public CELLAR
+manifestation API. It unions every CELLAR work sharing the CELEX before choosing
+the best downloadable item per language:
+
+```python
+import cellar_extractor as cell
+
+_, manifestations = cell.get_cellar_manifestations_by_celex(
+    "62020CJ0414", sector="6"
+)
+english = [m for m in manifestations if m["language"] == "EN"]
+fulltexts = cell.extract_cellar_fulltexts(english)
+```
+
 Returns:
 
 - `extra_df`: enriched dataframe
@@ -268,6 +287,8 @@ Imported from [`cellar_extractor/__init__.py`](/Users/davidwickerhf/Projects/wor
 | `get_cellar(...)` | Fetch base CELLAR metadata (case law only) |
 | `get_cellar_extra(...)` | Fetch enriched metadata + full text (case law only) |
 | `get_legislation_by_celex_id(celex, language="EN")` | Fetch sector 3 / sector 0 legislation XHTML by CELEX |
+| `get_cellar_manifestations_by_celex(celex, sector="8")` | Resolve every CELLAR work for a CELEX and return their deduplicated manifestation union |
+| `extract_cellar_fulltexts(manifestations, source_label="CELLAR_ITEM")` | Download the best manifestation per language as fulltext records |
 | `get_nodes_and_edges_lists(df, only_local=False)` | Build citation graph lists |
 | `filter_subject_matter(df, phrase)` | Filter dataframe by subject phrase |
 | `FetchOperativePart` | Extract operative part from a single case document |

{cellar_extractor-2.0.2 → cellar_extractor-2.0.4}/cellar_extractor/__init__.py

@@ -9,6 +9,9 @@ from cellar_extractor.cellar import get_cellar_extra
 from cellar_extractor.cellar import get_nodes_and_edges_lists
 from cellar_extractor.cellar import filter_subject_matter
 from cellar_extractor.eurlex_scraping import get_legislation_by_celex_id
+from cellar_extractor.eurlex_scraping import get_cellar_manifestations_by_celex
+from cellar_extractor.eurlex_scraping import extract_cellar_fulltexts
+from cellar_extractor.eurlex_scraping import normalize_celex
 from cellar_extractor.operative_extractions import FetchOperativePart
 from cellar_extractor.operative_extractions import Writing
 import logging

{cellar_extractor-2.0.2 → cellar_extractor-2.0.4}/cellar_extractor/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.0.2'
-__version_tuple__ = version_tuple = (2, 0, 2)
+__version__ = version = '2.0.4'
+__version_tuple__ = version_tuple = (2, 0, 4)
 
-__commit_id__ = commit_id = 'gf354af594'
+__commit_id__ = commit_id = 'g792a41d4a'

{cellar_extractor-2.0.2 → cellar_extractor-2.0.4}/cellar_extractor/cellar.py

@@ -4,7 +4,12 @@ from concurrent.futures import ThreadPoolExecutor
 from tqdm import tqdm
 
 from cellar_extractor.cellar_extra_extract import extra_cellar
-from cellar_extractor.cellar_queries import get_all_eclis, get_raw_cellar_metadata
+from cellar_extractor.cellar_queries import (
+    get_all_eclis,
+    get_infocuria_document_metadata,
+    get_raw_cellar_metadata,
+    reconcile_document_metadata,
+)
 from cellar_extractor.json_to_csv import json_to_csv_returning
 from cellar_extractor.nodes_and_edges import get_nodes_and_edges
 from cellar_extractor.persistence import (
@@ -70,6 +75,7 @@ def get_cellar(
     output_path=None,
     return_data=None,
     save=None,
+    reconcile_infocuria=False,
 ):
     """
     Fetch base CELLAR metadata.
@@ -91,10 +97,24 @@ def get_cellar(
     logging.info(f"Up until the specified end date {ed}")
     eclis = get_all_eclis(starting_date=sd, ending_date=ed, limit=max_ecli)
     logging.info(f"Found {len(eclis)} ECLIs")
-    if len(eclis) == 0:
+    all_eclis = _fetch_metadata_batches(eclis)
+    if reconcile_infocuria:
+        infocuria_metadata = get_infocuria_document_metadata(
+            starting_date=sd,
+            ending_date=ed,
+            limit=max_ecli,
+        )
+        logging.info(
+            "Found %s ECLIs in the InfoCuria document catalogue",
+            len(infocuria_metadata),
+        )
+        all_eclis = reconcile_document_metadata(all_eclis, infocuria_metadata)
+        if max_ecli is not None and len(all_eclis) > max_ecli:
+            all_eclis = dict(list(all_eclis.items())[:max_ecli])
+
+    if len(all_eclis) == 0:
         logging.info(f"No data to download found between {sd} and {ed}")
         return False
-    all_eclis = _fetch_metadata_batches(eclis)
 
     result = _materialize_cellar_output(all_eclis, file_format)
     if save_enabled:
@@ -136,7 +156,14 @@ def get_cellar_extra(
     if not ed:
         ed = datetime.now().isoformat(timespec="seconds")
     save_enabled = resolve_save_enabled(save=save, save_file=save_file, default=True)
-    data = get_cellar(ed=ed, save=False, max_ecli=max_ecli, sd=sd, file_format="csv")
+    data = get_cellar(
+        ed=ed,
+        save=False,
+        max_ecli=max_ecli,
+        sd=sd,
+        file_format="csv",
+        reconcile_infocuria=True,
+    )
     if data is False:
         logging.warning("Cellar extraction unsuccessful")
         return False, False

{cellar_extractor-2.0.2 → cellar_extractor-2.0.4}/cellar_extractor/cellar_queries.py

@@ -1,6 +1,8 @@
+import re
 import time
 from datetime import date, datetime, timedelta
 
+import requests
 from SPARQLWrapper import SPARQLWrapper, JSON, POST
 
 # Literal placeholder CELLAR emits while a property is awaiting curation;
@@ -13,6 +15,17 @@ MAX_SORTED_TOP_LIMIT = 10000
 ECLI_WINDOW_DAYS = 366
 SPARQL_REQUEST_TIMEOUT_SECONDS = 30
 SPARQL_RETRY_BACKOFF_BASE_SECONDS = 0.5
+INFOCURIA_SEARCH_ENDPOINT = "https://infocuriaws.curia.europa.eu/elastic-connector/search"
+INFOCURIA_PAGE_SIZE = 100
+INFOCURIA_REQUEST_TIMEOUT_SECONDS = 60
+INFOCURIA_IDENTITY_FIELDS = {
+    "case-law_ecli",
+    "resource_legal_id_celex",
+    "work_date_document",
+    "resource_legal_type",
+    "resource_legal_id_sector",
+    "case-law_affaire_number",
+}
 
 
 def _query_with_retries(sparql, retries, error_message):
@@ -157,6 +170,192 @@ def get_all_eclis(starting_date=None, ending_date=None, limit=None, max_retries=
     return eclis
 
 
+def _normalize_infocuria_celex(value):
+    """Return a canonical primary-document CELEX from an InfoCuria hit.
+
+    InfoCuria writes numbered document variants as ``.01`` while EUR-Lex and
+    CELLAR use ``(01)``. Derived summary/information works are deliberately
+    rejected instead of being collapsed onto their base CELEX.
+    """
+    if value is None:
+        return ""
+    celex = str(value).replace(" ", "").strip()
+    if celex == "":
+        return ""
+    celex = celex.split(";", 1)[0]
+    if re.search(r"_(?:SUM|RES|INF)$", celex, flags=re.IGNORECASE):
+        return ""
+    celex = re.sub(r"\.(\d{2})$", r"(\1)", celex)
+    if not celex.startswith("6"):
+        return ""
+    return celex
+
+
+def _build_infocuria_search_payload(starting_date, ending_date, page_number, page_size):
+    start = page_number * page_size + 1
+    return {
+        "multiSearchTerms": [],
+        "searchTerm": "",
+        "ecli": "",
+        "publishedId": "",
+        "usualName": "",
+        "logicDocId": "",
+        "repJurExpand": False,
+        "pagination": {
+            "pageNumber": page_number,
+            "pageSize": page_size,
+            "from": start,
+            "to": start + page_size - 1,
+            "origin": "jurisprudence",
+        },
+        "sortTermList": [
+            {
+                "sortDirection": "ASC",
+                "sortTerm": "DOC_DATE",
+                "sortSourceTab": "jurisprudence",
+            }
+        ],
+        "filtersValue": [{"field": "docDate", "values": [starting_date, ending_date]}],
+        "advancedFiltersValue": [],
+        "language": "EN",
+        "isSearchExact": False,
+        "searchSources": ["document", "metadata"],
+        "tabName": "jurisprudence",
+        "isAllTabsRequest": False,
+    }
+
+
+def _query_infocuria_page(payload, max_retries):
+    last_error = None
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(
+                INFOCURIA_SEARCH_ENDPOINT,
+                json=payload,
+                timeout=INFOCURIA_REQUEST_TIMEOUT_SECONDS,
+            )
+            response.raise_for_status()
+            result = response.json()
+            if not isinstance(result, dict):
+                raise ValueError("InfoCuria search response is not an object")
+            return result
+        except Exception as exc:
+            last_error = exc
+            if attempt < max_retries - 1:
+                time.sleep(SPARQL_RETRY_BACKOFF_BASE_SECONDS * (2**attempt))
+    raise RuntimeError(
+        "Failed to query InfoCuria document catalogue after retries"
+    ) from last_error
+
+
+def _infocuria_metadata_from_hit(hit):
+    content = hit.get("content", {}) if isinstance(hit, dict) else {}
+    if not isinstance(content, dict):
+        return None
+
+    ecli = str(content.get("ecli") or "").strip()
+    celex = _normalize_infocuria_celex(content.get("celex"))
+    document_date = str(content.get("docDate") or "").strip()
+    if not ecli.startswith("ECLI:EU:") or celex == "" or document_date == "":
+        return None
+
+    resource_type = celex[5:7] if len(celex) >= 7 else ""
+    metadata = {
+        "case-law_ecli": [ecli],
+        "resource_legal_id_celex": [celex],
+        "work_date_document": [document_date],
+        "resource_legal_id_sector": [celex[0]],
+        "metadata_catalog_source": ["infocuria"],
+    }
+    if resource_type:
+        metadata["resource_legal_type"] = [resource_type]
+    published_id = str(content.get("idPublished") or "").strip()
+    if published_id:
+        metadata["case-law_affaire_number"] = [published_id]
+    return ecli, metadata
+
+
+def get_infocuria_document_metadata(
+    starting_date=None,
+    ending_date=None,
+    limit=None,
+    max_retries=3,
+):
+    """Enumerate official InfoCuria documents for a date range.
+
+    CELLAR's SPARQL graph does not contain every document that is available
+    through EUR-Lex/InfoCuria, particularly procedural orders. InfoCuria is
+    therefore used as a second catalogue source. Results use the same
+    predicate-map shape as :func:`get_raw_cellar_metadata` so callers can
+    reconcile the sources before normal schema flattening.
+    """
+    metadata = {}
+    for window_start, window_end in _build_ecli_windows(
+        starting_date=starting_date,
+        ending_date=ending_date,
+    ):
+        page_number = 0
+        while True:
+            remaining = None if limit is None else limit - len(metadata)
+            if remaining is not None and remaining <= 0:
+                return metadata
+            page_size = INFOCURIA_PAGE_SIZE
+
+            payload = _build_infocuria_search_payload(
+                str(window_start)[:10],
+                str(window_end)[:10],
+                page_number,
+                page_size,
+            )
+            result = _query_infocuria_page(payload, max_retries=max_retries)
+            hits = result.get("searchHits", [])
+            if not isinstance(hits, list):
+                raise RuntimeError("InfoCuria catalogue returned invalid searchHits")
+
+            for hit in hits:
+                parsed = _infocuria_metadata_from_hit(hit)
+                if parsed is None:
+                    continue
+                ecli, values = parsed
+                # Multiple logical documents can share an ECLI. Their CELEX
+                # identity is normally identical; retaining the first hit is
+                # deterministic because the endpoint is date-sorted.
+                metadata.setdefault(ecli, values)
+                if limit is not None and len(metadata) >= limit:
+                    return metadata
+
+            total_hits = int(result.get("totalHits") or 0)
+            consumed = (page_number + 1) * page_size
+            if not hits or consumed >= total_hits:
+                break
+            page_number += 1
+    return metadata
+
+
+def reconcile_document_metadata(cellar_metadata, infocuria_metadata):
+    """Merge both catalogues, preferring InfoCuria for document identity.
+
+    Rich CELLAR metadata is retained. InfoCuria supplies missing documents
+    and corrects identity fields when CELLAR associates an ECLI with a stale
+    or sibling CELEX work.
+    """
+    reconciled = {
+        ecli: {key: list(values) for key, values in values_by_key.items()}
+        for ecli, values_by_key in (cellar_metadata or {}).items()
+    }
+    for ecli, values_by_key in (infocuria_metadata or {}).items():
+        if ecli not in reconciled:
+            reconciled[ecli] = {
+                key: list(values) for key, values in values_by_key.items()
+            }
+            continue
+        target = reconciled[ecli]
+        for key, values in values_by_key.items():
+            if key in INFOCURIA_IDENTITY_FIELDS or not target.get(key):
+                target[key] = list(values)
+    return reconciled
+
+
 def get_raw_cellar_metadata_by_celex(
     celex_ids,
     get_labels=True,

{cellar_extractor-2.0.2 → cellar_extractor-2.0.4}/cellar_extractor/eurlex_scraping.py

@@ -126,9 +126,21 @@ def _normalize_celex(celex):
         value = non_inf[0] if non_inf else options[0]
     if "_" in value:
         value = value.split("_")[0]
+    value = re.sub(r"\.(\d{2})$", r"(\1)", value)
     return value
 
 
+def normalize_celex(celex):
+    """Return the canonical work CELEX used for full-text retrieval.
+
+    CELLAR metadata can bundle a primary document with derived information,
+    summary, and résumé works (for example ``62020CJ0414_SUM;62020CJ0414``).
+    Full-text callers must resolve the unsuffixed base work so a derived work
+    can never occupy the judgment's language slot.
+    """
+    return _normalize_celex(celex)
+
+
 def _sleep_with_backoff(attempt, base=0.2):
     time.sleep(base * (attempt + 1) + random.uniform(0.0, 0.1))
 
@@ -413,6 +425,25 @@ def _fetch_sector8_items_for_celex(celex, sector="8"):
     return work_uris, candidates
 
 
+def get_cellar_manifestations_by_celex(celex, sector="8"):
+    """Return all CELLAR works and manifestation candidates for a CELEX.
+
+    A CELEX can resolve to multiple CELLAR works with different language
+    coverage.  This public entry point deliberately returns the union across
+    every matching work so callers do not need to depend on the extractor's
+    private sector-8 helpers.
+
+    The return value is ``(work_uris, manifestations)``.  Each manifestation
+    contains ``item_url``, ``format``, and ``language`` keys and is deduplicated
+    on that triple.  ``sector`` defaults to ``"8"`` and may be set to ``"6"``
+    for CJEU documents.
+    """
+    canonical_celex = normalize_celex(celex)
+    if not canonical_celex:
+        return [], []
+    return _fetch_sector8_items_for_celex(canonical_celex, sector=sector)
+
+
 def _fetch_sector8_work_uri(celex, sector="8"):
     """Resolve a CELEX to its CELLAR work URI.
 
@@ -553,6 +584,17 @@ def _fanout_fulltexts_from_candidates(candidates, source_label):
     return out
 
 
+def extract_cellar_fulltexts(manifestations, source_label="CELLAR_ITEM"):
+    """Download the best manifestation per language as fulltext records.
+
+    ``manifestations`` is the candidate list returned by
+    :func:`get_cellar_manifestations_by_celex`.  Empty bodies are omitted and
+    each returned dictionary contains ``text``, ``html``, ``text_source``,
+    ``text_language``, and ``text_format``.
+    """
+    return _fanout_fulltexts_from_candidates(manifestations, source_label)
+
+
 def _get_case_data_sector8(celex, language="EN"):
     work_uris, main_candidates = _fetch_sector8_items_for_celex(celex)
 
@@ -773,7 +815,7 @@ def _collect_affecting_ids(content):
     return ids
 
 
-def _choose_best_document(doc_hits, language="EN"):
+def _choose_best_document(doc_hits, language="EN", celex=None):
     candidates = []
     for hit in doc_hits or []:
         content = hit.get("content", {}) if isinstance(hit, dict) else {}
@@ -786,6 +828,23 @@ def _choose_best_document(doc_hits, language="EN"):
     if len(candidates) == 0:
         return None
 
+    normalized_target = _normalize_celex(celex) if celex else ""
+    if normalized_target:
+        candidates_with_celex = [
+            doc for doc in candidates if _normalize_celex(doc.get("celex", ""))
+        ]
+        exact_candidates = [
+            doc
+            for doc in candidates_with_celex
+            if _normalize_celex(doc.get("celex", "")) == normalized_target
+        ]
+        if exact_candidates:
+            candidates = exact_candidates
+        elif candidates_with_celex:
+            # Selecting a judgment merely because it is the highest-ranked
+            # document can attach a sibling judgment to an order CELEX.
+            return None
+
     type_priority = {
         "ARRET": 0,
         "ORDONNANCE": 1,
@@ -987,7 +1046,11 @@ def _get_case_data_sector6(celex, language="EN"):
         if isinstance(root_hit, dict)
         else []
     )
-    selected_doc = _choose_best_document(documents, language=language)
+    selected_doc = _choose_best_document(
+        documents,
+        language=language,
+        celex=normalized,
+    )
     if selected_doc is None:
         return _get_case_data_sector6_cellar_fallback(normalized, language=language)
 
@@ -1043,18 +1106,41 @@ def _get_case_data_sector6(celex, language="EN"):
     else:
         summary_source = ""
 
-    # Multi-language fanout: InfoCuria's `documents.searchHits` already
-    # carries every docLang variant of the procedure. Fetch each blob the
-    # same way the primary one was fetched and build a fulltexts list.
+    # Multi-language fanout must remain within the selected logical document.
+    # A procedure can contain judgments, orders, opinions, and notices. The
+    # selected document's groupByLogicalId list is the authoritative language
+    # family; older responses without that field fall back to documents with
+    # the same logicDocId.
     fulltexts: list = []
     seen_langs: set = set()
     session = _get_http_session()
-    for doc in documents or []:
-        if not isinstance(doc, dict):
-            continue
-        content = doc.get("content", {}) if isinstance(doc, dict) else {}
-        if not isinstance(content, dict):
-            continue
+    selected_logic_id = str(selected_doc.get("logicDocId", ""))
+    selected_group = selected_doc.get("groupByLogicalId") or []
+    variant_contents = []
+    if isinstance(selected_group, list) and selected_group:
+        for variant in selected_group:
+            if not isinstance(variant, dict):
+                continue
+            variant_contents.append(
+                {
+                    "docLang": variant.get("docLang"),
+                    "docFormats": variant.get("formats") or [],
+                    "logicDocId": selected_logic_id,
+                    "idProcedure": variant.get("idProcedure")
+                    or selected_doc.get("idProcedure"),
+                }
+            )
+    else:
+        for doc in documents or []:
+            content = doc.get("content", {}) if isinstance(doc, dict) else {}
+            if not isinstance(content, dict):
+                continue
+            if str(content.get("logicDocId", "")) == selected_logic_id:
+                variant_contents.append(content)
+    if not variant_contents:
+        variant_contents = [selected_doc]
+
+    for content in variant_contents:
         variant_lang = content.get("docLang") or ""
         variant_lang_upper = str(variant_lang).upper()
         if variant_lang_upper == "" or variant_lang_upper in seen_langs:
@@ -1104,15 +1190,14 @@ def _get_case_data_sector6(celex, language="EN"):
             }
         )
 
-    # Supplement InfoCuria fulltexts with any languages CELLAR has that
-    # InfoCuria didn't expose. InfoCuria's documents.searchHits typically
-    # carries only the procedural language plus EN; CELLAR's CDM model
-    # exposes all 23 EU-official manifestations via expression_uses_language.
-    # We keep InfoCuria's entries where languages overlap (the court's own
-    # publication is typically higher fidelity) and append CELLAR-sourced
-    # entries for any missing languages. Metadata fields (judge, advocate,
-    # directory_codes, etc.) remain InfoCuria-sourced — CELLAR cannot
-    # populate them.
+    # Merge InfoCuria fulltexts with every language CELLAR has. CELLAR is
+    # authoritative when both sources expose the same language because its
+    # manifestation belongs to the canonical CELEX work. InfoCuria's
+    # procedure search has returned a different document under the judgment
+    # slot in production (AG opinions, procedural orders, and notices), so an
+    # existing InfoCuria language must not block the canonical manifestation.
+    # Metadata fields (judge, advocate, directory_codes, etc.) remain
+    # InfoCuria-sourced — CELLAR cannot populate them.
     #
     # All-in-one try/except: a CELLAR-side failure must never kill the
     # InfoCuria-sourced row we already built.
@@ -1122,18 +1207,36 @@ def _get_case_data_sector6(celex, language="EN"):
             cellar_fulltexts = _fanout_fulltexts_from_candidates(
                 cellar_candidates, source_label="CELLAR_ITEM"
             )
+            by_language = {
+                entry.get("text_language", "").upper(): entry
+                for entry in fulltexts
+                if entry.get("text_language", "")
+            }
             for entry in cellar_fulltexts:
                 entry_lang = entry.get("text_language", "").upper()
-                if not entry_lang or entry_lang in seen_langs:
+                if not entry_lang:
                     continue
                 seen_langs.add(entry_lang)
-                fulltexts.append(entry)
+                by_language[entry_lang] = entry
+            fulltexts = list(by_language.values())
     except Exception:
         # CELLAR supplementation is best-effort. If anything goes wrong
         # (SPARQL timeout, network hiccup, schema drift on the manifestation
         # graph) the InfoCuria-only result is still returned.
         pass
 
+    primary = next(
+        (
+            entry
+            for entry in fulltexts
+            if entry.get("text_language", "").upper() == str(language).upper()
+        ),
+        None,
+    )
+    if primary is not None:
+        text = primary.get("text", "")
+        html = primary.get("html", "")
+
     return {
         "html": html,
         "text": text,
@@ -1146,9 +1249,9 @@ def _get_case_data_sector6(celex, language="EN"):
         "affecting_ids": affecting_ids,
         "affecting_string": affecting_string,
         "citations_extra": citations_extra,
-        "text_source": "INFOCURIA_BLOB_HTML" if text != "" else "",
-        "text_language": str(doc_lang).upper() if doc_lang else language.upper(),
-        "text_format": "html" if text != "" else "",
+        "text_source": primary.get("text_source", "") if primary else "",
+        "text_language": primary.get("text_language", "") if primary else "",
+        "text_format": primary.get("text_format", "") if primary else "",
         "summary_source": summary_source,
         "summary_language": "EN" if summary != "" else "",
         "sector": "6",