nucliadb 6.4.0.post4204__py3-none-any.whl → 6.4.0.post4210__py3-none-any.whl

nucliadb/common/external_index_providers/base.py

@@ -55,16 +55,19 @@ class VectorsetExternalIndex:
     similarity: VectorSimilarity.ValueType
 
 
-class TextBlockMatch(BaseModel):
+class ScoredTextBlock(BaseModel):
+    paragraph_id: ParagraphId
+    score: float
+    score_type: SCORE_TYPE
+
+
+class TextBlockMatch(ScoredTextBlock):
     """
     Model a text block/paragraph retrieved from an external index with all the information
     needed in order to later hydrate retrieval results.
     """
 
-    paragraph_id: ParagraphId
     position: TextPosition
-    score: float
-    score_type: SCORE_TYPE
     order: int
     page_with_visual: bool = False
     fuzzy_search: bool

nucliadb/search/search/chat/ask.py

@@ -33,6 +33,8 @@ from nuclia_models.predict.generative_responses import (
 from pydantic_core import ValidationError
 
 from nucliadb.common.datamanagers.exceptions import KnowledgeBoxNotFound
+from nucliadb.common.external_index_providers.base import ScoredTextBlock
+from nucliadb.common.ids import ParagraphId
 from nucliadb.models.responses import HTTPClientError
 from nucliadb.search import logger, predict
 from nucliadb.search.predict import (
@@ -63,6 +65,7 @@ from nucliadb.search.search.graph_strategy import get_graph_results
 from nucliadb.search.search.metrics import RAGMetrics
 from nucliadb.search.search.query_parser.fetcher import Fetcher
 from nucliadb.search.search.query_parser.parsers.ask import fetcher_for_ask, parse_ask
+from nucliadb.search.search.rank_fusion import WeightedCombSum
 from nucliadb.search.search.rerankers import (
     get_reranker,
 )
@@ -865,6 +868,10 @@ async def retrieval_in_resource(
     )
 
 
+class _FindParagraph(ScoredTextBlock):
+    original: FindParagraph
+
+
 def compute_best_matches(
     main_results: KnowledgeboxFindResults,
     prequeries_results: Optional[list[PreQueryResult]] = None,
@@ -882,42 +889,46 @@ def compute_best_matches(
     `main_query_weight` is the weight given to the paragraphs matching the main query when calculating the final score.
     """
 
-    def iter_paragraphs(results: KnowledgeboxFindResults):
+    def extract_paragraphs(results: KnowledgeboxFindResults) -> list[_FindParagraph]:
+        paragraphs = []
         for resource in results.resources.values():
             for field in resource.fields.values():
                 for paragraph in field.paragraphs.values():
-                    yield paragraph
-
-    total_weights = main_query_weight + sum(prequery.weight for prequery, _ in prequeries_results or [])
-    paragraph_id_to_match: dict[str, RetrievalMatch] = {}
-    for paragraph in iter_paragraphs(main_results):
-        normalized_weight = main_query_weight / total_weights
-        rmatch = RetrievalMatch(
-            paragraph=paragraph,
-            weighted_score=paragraph.score * normalized_weight,
-        )
-        paragraph_id_to_match[paragraph.id] = rmatch
-
-    for prequery, prequery_results in prequeries_results or []:
-        for paragraph in iter_paragraphs(prequery_results):
-            normalized_weight = prequery.weight / total_weights
-            weighted_score = paragraph.score * normalized_weight
-            if paragraph.id in paragraph_id_to_match:
-                rmatch = paragraph_id_to_match[paragraph.id]
-                # If a paragraph is matched in various prequeries, the final score is the
-                # sum of the weighted scores
-                rmatch.weighted_score += weighted_score
-            else:
-                paragraph_id_to_match[paragraph.id] = RetrievalMatch(
-                    paragraph=paragraph,
-                    weighted_score=weighted_score,
-                )
+                    paragraphs.append(
+                        _FindParagraph(
+                            paragraph_id=ParagraphId.from_string(paragraph.id),
+                            score=paragraph.score,
+                            score_type=paragraph.score_type,
+                            original=paragraph,
+                        )
+                    )
+        return paragraphs
 
-    return sorted(
-        paragraph_id_to_match.values(),
-        key=lambda match: match.weighted_score,
-        reverse=True,
-    )
+    weights = {
+        "main": main_query_weight,
+    }
+    total_weight = main_query_weight
+    find_results = {
+        "main": extract_paragraphs(main_results),
+    }
+    for i, (prequery, prequery_results) in enumerate(prequeries_results or []):
+        weights[f"prequery-{i}"] = prequery.weight
+        total_weight += prequery.weight
+        find_results[f"prequery-{i}"] = extract_paragraphs(prequery_results)
+
+    normalized_weights = {key: value / total_weight for key, value in weights.items()}
+
+    # window does nothing here
+    rank_fusion = WeightedCombSum(window=0, weights=normalized_weights)
+
+    merged = []
+    for item in rank_fusion.fuse(find_results):
+        match = RetrievalMatch(
+            paragraph=item.original,
+            weighted_score=item.score,
+        )
+        merged.append(match)
+    return merged
 
 
 def calculate_prequeries_for_json_schema(

nucliadb/search/search/find_merge.py

@@ -42,7 +42,7 @@ from nucliadb.search.search.hydrator import (
 )
 from nucliadb.search.search.merge import merge_relations_results
 from nucliadb.search.search.query_parser.models import UnitRetrieval
-from nucliadb.search.search.rank_fusion import RankFusionAlgorithm
+from nucliadb.search.search.rank_fusion import IndexSource, RankFusionAlgorithm
 from nucliadb.search.search.rerankers import (
     RerankableItem,
     Reranker,
@@ -108,7 +108,13 @@ async def build_find_response(
     )
     graph_results = graph_results_to_text_block_matches(search_response.graph)
 
-    merged_text_blocks = rank_fusion_algorithm.fuse(keyword_results, semantic_results, graph_results)
+    merged_text_blocks = rank_fusion_algorithm.fuse(
+        {
+            IndexSource.KEYWORD: keyword_results,
+            IndexSource.SEMANTIC: semantic_results,
+            IndexSource.GRAPH: graph_results,
+        }
+    )
 
     # cut
     # we assume pagination + predict reranker is forbidden and has been already

nucliadb/search/search/rank_fusion.py

@@ -19,8 +19,10 @@
 #
 import logging
 from abc import ABC, abstractmethod
+from enum import Enum, auto
+from typing import Optional, TypeVar
 
-from nucliadb.common.external_index_providers.base import TextBlockMatch
+from nucliadb.common.external_index_providers.base import ScoredTextBlock
 from nucliadb.common.ids import ParagraphId
 from nucliadb.search.search.query_parser import models as parser_models
 from nucliadb_models.search import SCORE_TYPE
@@ -45,6 +47,14 @@ rank_fusion_observer = Observer(
     ],
 )
 
+ScoredItem = TypeVar("ScoredItem", bound=ScoredTextBlock)
+
+
+class IndexSource(str, Enum):
+    KEYWORD = auto()
+    SEMANTIC = auto()
+    GRAPH = auto()
+
 
 class RankFusionAlgorithm(ABC):
     def __init__(self, window: int):
@@ -60,46 +70,44 @@ class RankFusionAlgorithm(ABC):
         """
         return self._window
 
-    def fuse(
-        self,
-        keyword: list[TextBlockMatch],
-        semantic: list[TextBlockMatch],
-        graph: list[TextBlockMatch],
-    ) -> list[TextBlockMatch]:
-        """Fuse keyword and semantic results and return a list with the merged
+    def fuse(self, sources: dict[str, list[ScoredItem]]) -> list[ScoredItem]:
+        """Fuse elements from multiple sources and return a list of merged
         results.
 
-        If only one retriever is provided, rank fusion will be skipped.
+        If only one source is provided, rank fusion will be skipped.
 
         """
-        # sort results by it's score before merging them
-        keyword = [k for k in sorted(keyword, key=lambda r: r.score, reverse=True)]
-        semantic = [s for s in sorted(semantic, key=lambda r: r.score, reverse=True)]
-        graph = [g for g in graph]
-
-        retrievals_with_results = [x for x in (keyword, semantic, graph) if len(x) > 0]
-        if len(retrievals_with_results) == 1:
-            return retrievals_with_results[0]
+        sources_with_results = [x for x in sources.values() if len(x) > 0]
+        if len(sources_with_results) == 1:
+            # skip rank fusion, we only have a source
+            merged = sources_with_results[0]
         else:
-            merged = self._fuse(keyword, semantic, graph)
+            merged = self._fuse(sources)
+
+        # sort and return the unordered results from the implementation
+        merged.sort(key=lambda r: r.score, reverse=True)
         return merged
 
     @abstractmethod
-    def _fuse(
-        self,
-        keyword: list[TextBlockMatch],
-        semantic: list[TextBlockMatch],
-        graph: list[TextBlockMatch],
-    ) -> list[TextBlockMatch]:
-        """Rank fusion implementation. All arguments are assumed to be ordered
-        by decreasing score."""
+    def _fuse(self, sources: dict[str, list[ScoredItem]]) -> list[ScoredItem]:
+        """Rank fusion implementation.
+
+        Each concrete subclass must provide an implementation that merges
+        `sources`, a group of unordered matches, into a list of unordered
+        results with the new rank fusion score.
+
+        Results can be deduplicated or changed by the rank fusion algorithm.
+
+        """
         ...
 
 
 class ReciprocalRankFusion(RankFusionAlgorithm):
     """Rank-based rank fusion algorithm. Discounts the weight of documents
-    occurring deep in retrieved lists using a reciprocal distribution. It can be
-    parametrized with weights to boost retrievers.
+    occurring deep in retrieved lists using a reciprocal distribution.
+
+    This implementation can be further parametrized with a weight (boost) per
+    retriever that will be applied to all documents ranked by it.
 
     RRF = Σ(r ∈ R) (1 / (k + r(d)) · w(r))
 
@@ -119,9 +127,8 @@ class ReciprocalRankFusion(RankFusionAlgorithm):
         k: float = 60.0,
         *,
         window: int,
-        keyword_weight: float = 1.0,
-        semantic_weight: float = 1.0,
-        graph_weight: float = 1.0,
+        weights: Optional[dict[str, float]] = None,
+        default_weight: float = 1.0,
     ):
         super().__init__(window)
         # Constant used in RRF, studies agree on 60 as a good default value
@@ -129,49 +136,118 @@ class ReciprocalRankFusion(RankFusionAlgorithm):
         # difference among the best results and a smaller score difference among
         # bad results
         self._k = k
-        self._keyword_boost = keyword_weight
-        self._semantic_boost = semantic_weight
-        self._graph_boost = graph_weight
+        self._weights = weights or {}
+        self._default_weight = default_weight
 
     @rank_fusion_observer.wrap({"type": "reciprocal_rank_fusion"})
     def _fuse(
         self,
-        keyword: list[TextBlockMatch],
-        semantic: list[TextBlockMatch],
-        graph: list[TextBlockMatch],
-    ) -> list[TextBlockMatch]:
+        sources: dict[str, list[ScoredItem]],
+    ) -> list[ScoredItem]:
+        # accumulated scores per paragraph
+        scores: dict[ParagraphId, tuple[float, SCORE_TYPE]] = {}
+        # pointers from paragraph to the original source
+        match_positions: dict[ParagraphId, list[tuple[int, int]]] = {}
+
+        # sort results by it's score before fusing them, as we need the rank
+        sources = {
+            retriever: sorted(values, key=lambda r: r.score, reverse=True)
+            for retriever, values in sources.items()
+        }
+        rankings = [
+            (values, self._weights.get(source, self._default_weight))
+            for source, values in sources.items()
+        ]
+        for i, (ranking, weight) in enumerate(rankings):
+            for rank, item in enumerate(ranking):
+                id = item.paragraph_id
+                score, score_type = scores.setdefault(id, (0, item.score_type))
+                score += 1 / (self._k + rank) * weight
+                if {score_type, item.score_type} == {SCORE_TYPE.BM25, SCORE_TYPE.VECTOR}:
+                    score_type = SCORE_TYPE.BOTH
+                scores[id] = (score, score_type)
+
+                position = (i, rank)
+                match_positions.setdefault(item.paragraph_id, []).append(position)
+
+        merged = []
+        for paragraph_id, positions in match_positions.items():
+            # we are getting only one position, effectively deduplicating
+            # multiple matches for the same text block
+            i, j = match_positions[paragraph_id][0]
+            score, score_type = scores[paragraph_id]
+            item = rankings[i][0][j]
+            item.score = score
+            item.score_type = score_type
+            merged.append(item)
+
+        return merged
+
+
+class WeightedCombSum(RankFusionAlgorithm):
+    """Score-based rank fusion algorithm. Multiply each score by a list-specific
+    weight (boost). Then adds the retrieval score of documents contained in more
+    than one list and sort by score.
+
+    wCombSUM = Σ(r ∈ R) (w(r) · S(r, d))
+
+    where:
+    - d is a document
+    - R is the set of retrievers
+    - w(r) weight (boost) for retriever r
+    - S(r, d) is the score of document d given by retriever r
+
+    wCombSUM boosts matches from multiple retrievers and deduplicate them. As a
+    score ranking algorithm, comparison of different scores may lead to bad
+    results.
+
+    """
+
+    def __init__(
+        self,
+        *,
+        window: int,
+        weights: Optional[dict[str, float]] = None,
+        default_weight: float = 1.0,
+    ):
+        super().__init__(window)
+        self._weights = weights or {}
+        self._default_weight = default_weight
+
+    @rank_fusion_observer.wrap({"type": "weighted_comb_sum"})
+    def _fuse(self, sources: dict[str, list[ScoredItem]]) -> list[ScoredItem]:
+        # accumulated scores per paragraph
         scores: dict[ParagraphId, tuple[float, SCORE_TYPE]] = {}
+        # pointers from paragraph to the original source
         match_positions: dict[ParagraphId, list[tuple[int, int]]] = {}
 
         rankings = [
-            (keyword, self._keyword_boost),
-            (semantic, self._semantic_boost),
-            (graph, self._graph_boost),
+            (values, self._weights.get(source, self._default_weight))
+            for source, values in sources.items()
         ]
-        for r, (ranking, boost) in enumerate(rankings):
-            for i, result in enumerate(ranking):
-                id = result.paragraph_id
-                score, score_type = scores.setdefault(id, (0, result.score_type))
-                score += 1 / (self._k + i) * boost
-                if {score_type, result.score_type} == {SCORE_TYPE.BM25, SCORE_TYPE.VECTOR}:
+        for i, (ranking, weight) in enumerate(rankings):
+            for j, item in enumerate(ranking):
+                id = item.paragraph_id
+                score, score_type = scores.setdefault(id, (0, item.score_type))
+                score += item.score * weight
+                if {score_type, item.score_type} == {SCORE_TYPE.BM25, SCORE_TYPE.VECTOR}:
                     score_type = SCORE_TYPE.BOTH
                 scores[id] = (score, score_type)
 
-                position = (r, i)
-                match_positions.setdefault(result.paragraph_id, []).append(position)
+                position = (i, j)
+                match_positions.setdefault(item.paragraph_id, []).append(position)
 
         merged = []
         for paragraph_id, positions in match_positions.items():
             # we are getting only one position, effectively deduplicating
             # multiple matches for the same text block
-            r, i = match_positions[paragraph_id][0]
+            i, j = match_positions[paragraph_id][0]
             score, score_type = scores[paragraph_id]
-            result = rankings[r][0][i]
-            result.score = score
-            result.score_type = score_type
-            merged.append(result)
+            item = rankings[i][0][j]
+            item.score = score
+            item.score_type = score_type
+            merged.append(item)
 
-        merged.sort(key=lambda x: x.score, reverse=True)
         return merged
 
 
@@ -184,9 +260,11 @@ def get_rank_fusion(rank_fusion: parser_models.RankFusion) -> RankFusionAlgorith
         algorithm = ReciprocalRankFusion(
             k=rank_fusion.k,
             window=window,
-            keyword_weight=rank_fusion.boosting.keyword,
-            semantic_weight=rank_fusion.boosting.semantic,
-            graph_weight=rank_fusion.boosting.graph,
+            weights={
+                IndexSource.KEYWORD: rank_fusion.boosting.keyword,
+                IndexSource.SEMANTIC: rank_fusion.boosting.semantic,
+                IndexSource.GRAPH: rank_fusion.boosting.graph,
+            },
         )
 
     else:

{nucliadb-6.4.0.post4204.dist-info → nucliadb-6.4.0.post4210.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucliadb
-Version: 6.4.0.post4204
+Version: 6.4.0.post4210
 Summary: NucliaDB
 Author-email: Nuclia <nucliadb@nuclia.com>
 License: AGPL
@@ -20,11 +20,11 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: <4,>=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: nucliadb-telemetry[all]>=6.4.0.post4204
-Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.4.0.post4204
-Requires-Dist: nucliadb-protos>=6.4.0.post4204
-Requires-Dist: nucliadb-models>=6.4.0.post4204
-Requires-Dist: nidx-protos>=6.4.0.post4204
+Requires-Dist: nucliadb-telemetry[all]>=6.4.0.post4210
+Requires-Dist: nucliadb-utils[cache,fastapi,storages]>=6.4.0.post4210
+Requires-Dist: nucliadb-protos>=6.4.0.post4210
+Requires-Dist: nucliadb-models>=6.4.0.post4210
+Requires-Dist: nidx-protos>=6.4.0.post4210
 Requires-Dist: nucliadb-admin-assets>=1.0.0.post1224
 Requires-Dist: nuclia-models>=0.24.2
 Requires-Dist: uvicorn[standard]

{nucliadb-6.4.0.post4204.dist-info → nucliadb-6.4.0.post4210.dist-info}/RECORD

@@ -93,7 +93,7 @@ nucliadb/common/datamanagers/synonyms.py,sha256=zk3GEH38KF5vV_VcuL6DCg-2JwgXJfQl
 nucliadb/common/datamanagers/utils.py,sha256=McHlXvE4P3x-bBY3pr0n8djbTDQvI1G5WusJrnRdhLA,1827
 nucliadb/common/datamanagers/vectorsets.py,sha256=ciYb5uD435Zo8ZbqgPUAszFW9Svp_-R2hY2FEhQ411Y,4304
 nucliadb/common/external_index_providers/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
-nucliadb/common/external_index_providers/base.py,sha256=K5lJc2IMcbMTm5rFeB96-mPgicBtGmaunF6GeE2qBxM,8863
+nucliadb/common/external_index_providers/base.py,sha256=BL3DuYbnp-KCmGUiN-FGRtgjWj3SmtgMsGdjGq_7cX4,8905
 nucliadb/common/external_index_providers/exceptions.py,sha256=nDhhOIkb66hjCrBk4Spvl2vN1SuW5gbwrMCDmrdjHHE,1209
 nucliadb/common/external_index_providers/manager.py,sha256=aFSrrKKYG1ydpTSyq4zYD0LOxFS7P-CO6rcKC0hiF4I,4267
 nucliadb/common/external_index_providers/pinecone.py,sha256=sCvMgmXrLebnFLkpLnimDGrm4lE9ydb_ywotOMUSMrI,38124
@@ -239,7 +239,7 @@ nucliadb/search/search/exceptions.py,sha256=klGLgAGGrXcSGix_W6418ZBMqDchAIGjN77o
 nucliadb/search/search/fetch.py,sha256=eiljOKim-4OOEZn-3fyVZSYxztCH156BXYdqlIwVdN4,6181
 nucliadb/search/search/filters.py,sha256=1MkHlJjAQqoRCj7e5cEzK2HvBxGLE17I_omsjiklbtw,6476
 nucliadb/search/search/find.py,sha256=WTc_0HdbaU0Mwkmlf9s4pCmTuU0hz1jetBjIpNLXEEM,7982
-nucliadb/search/search/find_merge.py,sha256=2NtVZlR61MnTZl7mkzqcpIOPUU8hGWPrrP7ATeubt7w,19677
+nucliadb/search/search/find_merge.py,sha256=c-7IlfjfdmWAvQOyM7IO3bKS1EQpnR4oi6pN6mwrQKw,19815
 nucliadb/search/search/graph_merge.py,sha256=y5V7X-BhjHsKDXE69tzQLIIKGm4XuaFrZXw0odcHVNM,3402
 nucliadb/search/search/graph_strategy.py,sha256=JsV-i9PGhekCAzmGpqeueQIitJb7fWCihIwUf76Q3pU,32912
 nucliadb/search/search/hydrator.py,sha256=-R37gCrGxkyaiHQalnTWHNG_FCx11Zucd7qA1vQCxuw,6985
@@ -250,13 +250,13 @@ nucliadb/search/search/paragraphs.py,sha256=pNAEiYqJGGUVcEf7xf-PFMVqz0PX4Qb-WNG-
 nucliadb/search/search/pgcatalog.py,sha256=s_J98fsX_RuFXwpejpkGqG-tD9ELuzz4YQ6U3ew5h2g,9313
 nucliadb/search/search/predict_proxy.py,sha256=IFI3v_ODz2_UU1XZnyaD391fE7-2C0npSmj_HmDvzS4,3123
 nucliadb/search/search/query.py,sha256=-gvKsyGmKYpsoEVzKkq3HJUMcs_3LD3TYUueOcJsTec,11511
-nucliadb/search/search/rank_fusion.py,sha256=8Bq3AHfHgytp7UIhJQgbnXrchrjlCQbgf8PhLQkWBPY,6718
+nucliadb/search/search/rank_fusion.py,sha256=xZtXhbmKb_56gs73u6KkFm2efvTATOSMmpOV2wrAIqE,9613
 nucliadb/search/search/rerankers.py,sha256=PvhExUb8zZYghiFHRgGotw6h6bU--Rft09wE8arvtAw,7424
 nucliadb/search/search/shards.py,sha256=mc5DK-MoCv9AFhlXlOFHbPvetcyNDzTFOJ5rimK8PC8,2636
 nucliadb/search/search/summarize.py,sha256=ksmYPubEQvAQgfPdZHfzB_rR19B2ci4IYZ6jLdHxZo8,4996
 nucliadb/search/search/utils.py,sha256=ajRIXfdTF67dBVahQCXW-rSv6gJpUMPt3QhJrWqArTQ,2175
 nucliadb/search/search/chat/__init__.py,sha256=cp15ZcFnHvpcu_5-aK2A4uUyvuZVV_MJn4bIXMa20ks,835
-nucliadb/search/search/chat/ask.py,sha256=KO1YD1nGwblT4h2CfV7ccCpLP0OuoBCJQHBB5bDQatg,37476
+nucliadb/search/search/chat/ask.py,sha256=jYOGh2rySV4aFx_D2KlNVbPXHBsbkcy0Ve-eBS7CSYc,37611
 nucliadb/search/search/chat/exceptions.py,sha256=Siy4GXW2L7oPhIR86H3WHBhE9lkV4A4YaAszuGGUf54,1356
 nucliadb/search/search/chat/images.py,sha256=PA8VWxT5_HUGfW1ULhKTK46UBsVyINtWWqEM1ulzX1E,3095
 nucliadb/search/search/chat/prompt.py,sha256=Jnja-Ss7skgnnDY8BymVfdeYsFPnIQFL8tEvcRXTKUE,47356
@@ -369,8 +369,8 @@ nucliadb/writer/tus/local.py,sha256=7jYa_w9b-N90jWgN2sQKkNcomqn6JMVBOVeDOVYJHto,
 nucliadb/writer/tus/s3.py,sha256=vF0NkFTXiXhXq3bCVXXVV-ED38ECVoUeeYViP8uMqcU,8357
 nucliadb/writer/tus/storage.py,sha256=ToqwjoYnjI4oIcwzkhha_MPxi-k4Jk3Lt55zRwaC1SM,2903
 nucliadb/writer/tus/utils.py,sha256=MSdVbRsRSZVdkaum69_0wku7X3p5wlZf4nr6E0GMKbw,2556
-nucliadb-6.4.0.post4204.dist-info/METADATA,sha256=fAIY46KkkEIlOfObcPGceV3ZnO74SMottRW6kUPOFnU,4223
-nucliadb-6.4.0.post4204.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-nucliadb-6.4.0.post4204.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
-nucliadb-6.4.0.post4204.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
-nucliadb-6.4.0.post4204.dist-info/RECORD,,
+nucliadb-6.4.0.post4210.dist-info/METADATA,sha256=SB9gIMgWxoWNtUEexRLH85E0PL-MnroGhJ6aOambTT4,4223
+nucliadb-6.4.0.post4210.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+nucliadb-6.4.0.post4210.dist-info/entry_points.txt,sha256=XqGfgFDuY3zXQc8ewXM2TRVjTModIq851zOsgrmaXx4,1268
+nucliadb-6.4.0.post4210.dist-info/top_level.txt,sha256=hwYhTVnX7jkQ9gJCkVrbqEG1M4lT2F_iPQND1fCzF80,20
+nucliadb-6.4.0.post4210.dist-info/RECORD,,