nucliadb 6.7.2.post4862__py3-none-any.whl → 6.9.2.post5282__py3-none-any.whl

nucliadb/search/search/query.py

@@ -26,9 +26,6 @@ from nidx_protos.noderesources_pb2 import Resource
 from nucliadb.common import datamanagers
 from nucliadb.common.exceptions import InvalidQueryError
 from nucliadb.common.filter_expression import add_and_expression, parse_expression
-from nucliadb.search.search.filters import (
-    translate_label,
-)
 from nucliadb.search.search.query_parser.fetcher import Fetcher
 from nucliadb_models.filters import FilterExpression
 from nucliadb_models.labels import LABEL_HIDDEN
@@ -166,26 +163,6 @@ def expand_entities(
     return list(result_entities.values())
 
 
-def apply_entities_filter(
-    request: nodereader_pb2.SearchRequest,
-    detected_entities: list[utils_pb2.RelationNode],
-) -> list[str]:
-    added_filters = []
-    for entity_filter in [
-        f"/e/{entity.subtype}/{entity.value}"
-        for entity in detected_entities
-        if entity.ntype == utils_pb2.RelationNode.NodeType.ENTITY
-    ]:
-        if entity_filter not in added_filters:
-            added_filters.append(entity_filter)
-            # Add the entity to the filter expression (with AND)
-            entity_expr = nodereader_pb2.FilterExpression()
-            entity_expr.facet.facet = translate_label(entity_filter)
-            add_and_expression(request.field_filter, entity_expr)
-
-    return added_filters
-
-
 async def suggest_query_to_pb(
     kbid: str,
     features: list[SuggestOptions],

nucliadb/search/search/query_parser/fetcher.py

@@ -393,7 +393,7 @@ async def get_matryoshka_dimension_cached(kbid: str, vectorset: str) -> Optional
 
 @query_parse_dependency_observer.wrap({"type": "matryoshka_dimension"})
 async def get_matryoshka_dimension(kbid: str, vectorset: Optional[str]) -> Optional[int]:
-    async with get_driver().transaction(read_only=True) as txn:
+    async with get_driver().ro_transaction() as txn:
         matryoshka_dimension = None
         if not vectorset:
             # XXX this should be migrated once we remove the "default" vectorset
@@ -409,23 +409,23 @@ async def get_matryoshka_dimension(kbid: str, vectorset: Optional[str]) -> Optio
 
 @query_parse_dependency_observer.wrap({"type": "classification_labels"})
 async def get_classification_labels(kbid: str) -> knowledgebox_pb2.Labels:
-    async with get_driver().transaction(read_only=True) as txn:
+    async with get_driver().ro_transaction() as txn:
         return await datamanagers.labels.get_labels(txn, kbid=kbid)
 
 
 @query_parse_dependency_observer.wrap({"type": "synonyms"})
 async def get_kb_synonyms(kbid: str) -> Optional[knowledgebox_pb2.Synonyms]:
-    async with get_driver().transaction(read_only=True) as txn:
+    async with get_driver().ro_transaction() as txn:
         return await datamanagers.synonyms.get(txn, kbid=kbid)
 
 
 @query_parse_dependency_observer.wrap({"type": "entities_meta_cache"})
 async def get_entities_meta_cache(kbid: str) -> datamanagers.entities.EntitiesMetaCache:
-    async with get_driver().transaction(read_only=True) as txn:
+    async with get_driver().ro_transaction() as txn:
         return await datamanagers.entities.get_entities_meta_cache(txn, kbid=kbid)
 
 
 @query_parse_dependency_observer.wrap({"type": "deleted_entities_groups"})
 async def get_deleted_entity_groups(kbid: str) -> list[str]:
-    async with get_driver().transaction(read_only=True) as txn:
+    async with get_driver().ro_transaction() as txn:
         return list((await datamanagers.entities.get_deleted_groups(txn, kbid=kbid)).entities_groups)

nucliadb/search/search/query_parser/models.py

@@ -17,9 +17,8 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
-from dataclasses import dataclass
 from datetime import datetime
-from typing import Literal, Optional, Union
+from typing import Optional, Union
 
 from nidx_protos import nodereader_pb2
 from pydantic import BaseModel, ConfigDict, Field
@@ -86,7 +85,6 @@ class Filters(BaseModel):
         nodereader_pb2.FilterOperator.AND
     )
 
-    autofilter: Optional[list[utils_pb2.RelationNode]] = None
     facets: list[str] = Field(default_factory=list)
     hidden: Optional[bool] = None
     security: Optional[search_models.RequestSecurity] = None
@@ -153,33 +151,6 @@ class ParsedQuery(BaseModel):
     generation: Optional[Generation] = None
 
 
-### Catalog
-@dataclass
-class CatalogExpression:
-    @dataclass
-    class Date:
-        field: Union[Literal["created_at"], Literal["modified_at"]]
-        since: Optional[datetime]
-        until: Optional[datetime]
-
-    bool_and: Optional[list["CatalogExpression"]] = None
-    bool_or: Optional[list["CatalogExpression"]] = None
-    bool_not: Optional["CatalogExpression"] = None
-    date: Optional[Date] = None
-    facet: Optional[str] = None
-    resource_id: Optional[str] = None
-
-
-class CatalogQuery(BaseModel):
-    kbid: str
-    query: Optional[search_models.CatalogQuery]
-    filters: Optional[CatalogExpression]
-    sort: search_models.SortOptions
-    faceted: list[str]
-    page_size: int
-    page_number: int
-
-
 ### Graph
 
 

nucliadb/search/search/query_parser/parsers/ask.py

@@ -63,7 +63,7 @@ class _AskParser:
             )
         elif isinstance(self.item.max_tokens, MaxTokens):
             max_tokens = self.item.max_tokens
-        else:  # pragma: nocover
+        else:  # pragma: no cover
             # This is a trick so mypy generates an error if this branch can be reached,
             # that is, if we are missing some ifs
             _a: int = "a"

nucliadb/search/search/query_parser/parsers/catalog.py

@@ -19,13 +19,10 @@
 #
 
 from nucliadb.common import datamanagers
+from nucliadb.common.catalog.interface import CatalogExpression, CatalogQuery
 from nucliadb.common.exceptions import InvalidQueryError
-from nucliadb.common.filter_expression import FacetFilterTypes, facet_from_filter
+from nucliadb.common.filter_expression import FacetFilter, facet_from_filter
 from nucliadb.search.search.filters import translate_label
-from nucliadb.search.search.query_parser.models import (
-    CatalogExpression,
-    CatalogQuery,
-)
 from nucliadb_models import search as search_models
 from nucliadb_models.filters import (
     And,
@@ -185,14 +182,14 @@ async def parse_filter_expression(expr: ResourceFilterExpression, kbid: str) ->
             if rid is None:
                 raise InvalidQueryError("slug", f"Cannot find slug {expr.slug}")
             cat.resource_id = rid
-        else:  # pragma: nocover
+        else:  # pragma: no cover
             # Cannot happen due to model validation
             raise ValueError("Resource needs id or slug")
     elif isinstance(expr, DateCreated):
         cat.date = CatalogExpression.Date(field="created_at", since=expr.since, until=expr.until)
     elif isinstance(expr, DateModified):
         cat.date = CatalogExpression.Date(field="modified_at", since=expr.since, until=expr.until)
-    elif isinstance(expr, FacetFilterTypes):
+    elif isinstance(expr, FacetFilter):
         cat.facet = facet_from_filter(expr)
     else:
         # This is a trick so mypy generates an error if this branch can be reached,

nucliadb/search/search/query_parser/parsers/common.py

@@ -21,7 +21,6 @@ import re
 import string
 from typing import Optional, Union
 
-from nucliadb.common.exceptions import InvalidQueryError
 from nucliadb.search import logger
 from nucliadb.search.search.query_parser.fetcher import Fetcher
 from nucliadb.search.search.query_parser.models import (
@@ -32,15 +31,20 @@ from nucliadb_models import search as search_models
 
 DEFAULT_GENERIC_SEMANTIC_THRESHOLD = 0.7
 
-# -* is an invalid query in tantivy and it won't return results but if you add some whitespaces
-# between - and *, it will actually trigger a tantivy bug and panic
-INVALID_QUERY = re.compile(r"- +\*")
 
+def validate_query_syntax(query: str) -> str:
+    """Filter some queries that panic tantivy, better than returning the 500"""
 
-def validate_query_syntax(query: str):
-    # Filter some queries that panic tantivy, better than returning the 500
+    # -* is an invalid query in tantivy and it won't return results but if you add some whitespaces
+    # between - and *, it will actually trigger a tantivy bug and panic
+    INVALID_QUERY = re.compile(r"- *\*+")
     if INVALID_QUERY.search(query):
-        raise InvalidQueryError("query", "Invalid query syntax")
+        # remove the * and extra spaces, as it's probably what doesn't have
+        # meaning in both cases: -* and - *
+        fixed = re.sub(INVALID_QUERY, "- ", query)
+        query = fixed
+
+    return query
 
 
 def is_empty_query(request: search_models.BaseSearchRequest) -> bool:
@@ -85,6 +89,7 @@ async def parse_keyword_query(
     fetcher: Fetcher,
 ) -> KeywordQuery:
     query = item.query
+
     # If there was a rephrase with image, we should use the rephrased query for keyword search
     rephrased_query = await fetcher.get_rephrased_query()
     if item.query_image is not None and rephrased_query is not None:
@@ -98,6 +103,10 @@ async def parse_keyword_query(
             query = synonyms_query
             is_synonyms_query = True
 
+    # after all query transformations, pass a validator that can fix some
+    # queries that trigger a panic on the index
+    query = validate_query_syntax(query)
+
     min_score = parse_keyword_min_score(item.min_score)
 
     return KeywordQuery(

nucliadb/search/search/query_parser/parsers/find.py

@@ -57,7 +57,6 @@ from .common import (
     parse_semantic_query,
     parse_top_k,
     should_disable_vector_search,
-    validate_query_syntax,
 )
 
 
@@ -146,8 +145,6 @@ class _FindParser:
         return retrieval
 
     def _validate_request(self):
-        validate_query_syntax(self.item.query)
-
         # synonyms are not compatible with vector/graph search
         if (
             self.item.with_synonyms
@@ -256,17 +253,9 @@ class _FindParser:
             else:
                 filter_operator = nodereader_pb2.FilterOperator.AND
 
-        autofilter = None
-        if self.item.autofilter:
-            if self._query.relation is not None:
-                autofilter = self._query.relation.entry_points
-            else:
-                autofilter = await self._get_detected_entities()
-
         hidden = await filter_hidden_resources(self.kbid, self.item.show_hidden)
 
         return Filters(
-            autofilter=autofilter,
             facets=[],
             field_expression=field_expr,
             paragraph_expression=paragraph_expr,

nucliadb/search/search/query_parser/parsers/graph.py

@@ -153,7 +153,7 @@ def parse_path_query(expr: graph_requests.GraphPathQuery) -> nodereader_pb2.Grap
     elif isinstance(expr, graph_requests.Generated):
         _set_generated_to_pb(expr, pb)
 
-    else:  # pragma: nocover
+    else:  # pragma: no cover
         # This is a trick so mypy generates an error if this branch can be reached,
         # that is, if we are missing some ifs
         _a: int = "a"
@@ -182,7 +182,7 @@ def _parse_node_query(expr: graph_requests.GraphNodesQuery) -> nodereader_pb2.Gr
     elif isinstance(expr, graph_requests.Generated):
         _set_generated_to_pb(expr, pb)
 
-    else:  # pragma: nocover
+    else:  # pragma: no cover
         # This is a trick so mypy generates an error if this branch can be reached,
         # that is, if we are missing some ifs
         _a: int = "a"
@@ -212,7 +212,7 @@ def _parse_relation_query(
     elif isinstance(expr, graph_requests.Generated):
         _set_generated_to_pb(expr, pb)
 
-    else:  # pragma: nocover
+    else:  # pragma: no cover
         # This is a trick so mypy generates an error if this branch can be reached,
         # that is, if we are missing some ifs
         _a: int = "a"
@@ -230,7 +230,7 @@ def _set_node_to_pb(node: graph_requests.GraphNode, pb: nodereader_pb2.GraphQuer
             pb.fuzzy.kind = nodereader_pb2.GraphQuery.Node.MatchLocation.PREFIX
             pb.fuzzy.distance = 1
 
-        else:  # pragma: nocover
+        else:  # pragma: no cover
             # This is a trick so mypy generates an error if this branch can be reached,
             # that is, if we are missing some ifs
             _a: int = "a"
@@ -263,7 +263,7 @@ def _set_generated_to_pb(generated: graph_requests.Generated, pb: nodereader_pb2
 
         pb.facet.facet = facet
 
-    else:  # pragma: nocover
+    else:  # pragma: no cover
         # This is a trick so mypy generates an error if this branch can be reached,
         # that is, if we are missing some ifs
         _a: int = "a"

nucliadb/search/search/query_parser/parsers/search.py

@@ -51,7 +51,6 @@ from .common import (
     parse_semantic_query,
     parse_top_k,
     should_disable_vector_search,
-    validate_query_syntax,
 )
 
 INDEX_SORTABLE_FIELDS = [
@@ -128,8 +127,6 @@ class _SearchParser:
         return retrieval
 
     def _validate_request(self):
-        validate_query_syntax(self.item.query)
-
         # synonyms are not compatible with vector/graph search
         if (
             self.item.with_synonyms
@@ -254,17 +251,9 @@ class _SearchParser:
             else:
                 filter_operator = nodereader_pb2.FilterOperator.AND
 
-        autofilter = None
-        if self.item.autofilter:
-            if self._query.relation is not None:
-                autofilter = self._query.relation.entry_points
-            else:
-                autofilter = await self._get_detected_entities()
-
         hidden = await filter_hidden_resources(self.kbid, self.item.show_hidden)
 
         return Filters(
-            autofilter=autofilter,
             facets=self.item.faceted,
             field_expression=field_expr,
             paragraph_expression=paragraph_expr,

nucliadb/search/search/query_parser/parsers/unit_retrieval.py

@@ -25,10 +25,10 @@ from nidx_protos.nodereader_pb2 import SearchRequest
 from nucliadb.common.filter_expression import add_and_expression
 from nucliadb.search.search.filters import translate_label
 from nucliadb.search.search.metrics import node_features, query_parser_observer
-from nucliadb.search.search.query import apply_entities_filter, get_sort_field_proto
+from nucliadb.search.search.query import get_sort_field_proto
 from nucliadb.search.search.query_parser.models import ParsedQuery, PredictReranker, UnitRetrieval
 from nucliadb.search.search.query_parser.parsers.graph import parse_path_query
-from nucliadb_models.labels import LABEL_HIDDEN, translate_system_to_alias_label
+from nucliadb_models.labels import LABEL_HIDDEN
 from nucliadb_models.search import SortOrderMap
 from nucliadb_protos import utils_pb2
 
@@ -36,7 +36,7 @@ from nucliadb_protos import utils_pb2
 @query_parser_observer.wrap({"type": "convert_retrieval_to_proto"})
 async def legacy_convert_retrieval_to_proto(
     parsed: ParsedQuery,
-) -> tuple[SearchRequest, bool, list[str], Optional[str]]:
+) -> tuple[SearchRequest, bool, Optional[str]]:
     converter = _Converter(parsed.retrieval)
     request = converter.into_search_request()
 
@@ -44,13 +44,12 @@ async def legacy_convert_retrieval_to_proto(
     # needed. We should find a better abstraction
 
     incomplete = is_incomplete(parsed.retrieval)
-    autofilter = converter._autofilter
 
     rephrased_query = None
     if parsed.retrieval.query.semantic:
         rephrased_query = await parsed.fetcher.get_rephrased_query()
 
-    return request, incomplete, autofilter, rephrased_query
+    return request, incomplete, rephrased_query
 
 
 @query_parser_observer.wrap({"type": "convert_retrieval_to_proto"})
@@ -65,8 +64,6 @@ class _Converter:
         self.req = nodereader_pb2.SearchRequest()
         self.retrieval = retrieval
 
-        self._autofilter: list[str] = []
-
     def into_search_request(self) -> nodereader_pb2.SearchRequest:
         """Generate a SearchRequest proto from a retrieval operation."""
         self._apply_text_queries()
@@ -235,10 +232,6 @@ class _Converter:
             self.req.paragraph_filter.CopyFrom(self.retrieval.filters.paragraph_expression)
         self.req.filter_operator = self.retrieval.filters.filter_expression_operator
 
-        if self.retrieval.filters.autofilter:
-            entity_filters = apply_entities_filter(self.req, self.retrieval.filters.autofilter)
-            self._autofilter.extend([translate_system_to_alias_label(e) for e in entity_filters])
-
         if self.retrieval.filters.hidden is not None:
             expr = nodereader_pb2.FilterExpression()
             if self.retrieval.filters.hidden:

nucliadb/search/search/rerankers.py

@@ -181,7 +181,7 @@ def get_reranker(reranker: parser_models.Reranker) -> Reranker:
     elif isinstance(reranker, parser_models.PredictReranker):
         algorithm = PredictReranker(reranker.window)
 
-    else:  # pragma: nocover
+    else:  # pragma: no cover
         # This is a trick so mypy generates an error if this branch can be reached,
         # that is, if we are missing some ifs
         _a: int = "a"

nucliadb/search/search/summarize.py

@@ -77,7 +77,7 @@ async def get_extracted_texts(kbid: str, resource_uuids_or_slugs: list[str]) ->
     tasks = []
 
     # Schedule getting extracted text for each field of each resource
-    async with driver.transaction(read_only=True) as txn:
+    async with driver.ro_transaction() as txn:
         if not await datamanagers.kb.exists_kb(txn, kbid=kbid):
             raise datamanagers.exceptions.KnowledgeBoxNotFound(kbid)
 

nucliadb/standalone/run.py

@@ -116,6 +116,9 @@ def run():
     if nuclia_settings.nuclia_service_account:
         settings_to_output["NUA API key"] = "Configured ✔"
         settings_to_output["NUA API zone"] = nuclia_settings.nuclia_zone
+        settings_to_output["NUA API url"] = (
+            nuclia_settings.nuclia_public_url.format(zone=nuclia_settings.nuclia_zone) + "/api"
+        )
 
     settings_to_output_fmted = "\n".join(
         [f"||      - {k}:{' ' * (27 - len(k))}{v}" for k, v in settings_to_output.items()]

nucliadb/tasks/retries.py

@@ -151,7 +151,7 @@ class TaskRetryHandler:
 
 
 async def _get_metadata(kv_driver: Driver, metadata_key: str) -> Optional[TaskMetadata]:
-    async with kv_driver.transaction(read_only=True) as txn:
+    async with kv_driver.ro_transaction() as txn:
         metadata = await txn.get(metadata_key)
         if metadata is None:
             return None
@@ -159,7 +159,7 @@ async def _get_metadata(kv_driver: Driver, metadata_key: str) -> Optional[TaskMe
 
 
 async def _set_metadata(kv_driver: Driver, metadata_key: str, metadata: TaskMetadata) -> None:
-    async with kv_driver.transaction() as txn:
+    async with kv_driver.rw_transaction() as txn:
         await txn.set(metadata_key, metadata.model_dump_json().encode())
         await txn.commit()
 
@@ -188,7 +188,7 @@ async def purge_batch(
     """
     Returns the next start key and the number of purged records. If start is None, it means there are no more records to purge.
     """
-    async with kv_driver.transaction() as txn:
+    async with kv_driver.rw_transaction() as txn:
         txn = cast(PGTransaction, txn)
         async with txn.connection.cursor() as cur:
             await cur.execute(
@@ -226,7 +226,7 @@ async def purge_batch(
     while len(to_delete) > 0:
         batch = to_delete[:delete_batch_size]
         to_delete = to_delete[delete_batch_size:]
-        async with kv_driver.transaction() as txn:
+        async with kv_driver.rw_transaction() as txn:
             for key in batch:
                 logger.info("Purging task metadata", extra={"key": key})
                 await txn.delete(key)

nucliadb/train/generators/sentence_classifier.py

@@ -116,10 +116,7 @@ async def get_sentences(kbid: str, result: str) -> list[str]:
     if split is not None:
         text = extracted_text.split_text[split]
         for paragraph in field_metadata.split_metadata[split].paragraphs:
-            if paragraph.key == "":
-                key = f"{rid}/{field_type}/{field}/{paragraph.start}-{paragraph.end}"
-            else:
-                key = paragraph.key
+            key = f"{rid}/{field_type}/{field}/{paragraph.start}-{paragraph.end}"
             if key == result:
                 for sentence in paragraph.sentences:
                     splitted_text = text[sentence.start : sentence.end]
@@ -127,10 +124,7 @@ async def get_sentences(kbid: str, result: str) -> list[str]:
     else:
         text = extracted_text.text
         for paragraph in field_metadata.metadata.paragraphs:
-            if paragraph.key == "":
-                key = f"{rid}/{field_type}/{field}/{paragraph.start}-{paragraph.end}"
-            else:
-                key = paragraph.key
+            key = f"{rid}/{field_type}/{field}/{paragraph.start}-{paragraph.end}"
             if key == result:
                 for sentence in paragraph.sentences:
                     splitted_text = text[sentence.start : sentence.end]

nucliadb/train/generators/utils.py

@@ -41,7 +41,7 @@ async def get_resource_from_cache_or_db(kbid: str, uuid: str) -> Optional[Resour
 
 async def _get_resource_from_db(kbid: str, uuid: str) -> Optional[ResourceORM]:
     storage = await get_storage(service_name=SERVICE_NAME)
-    async with get_driver().transaction(read_only=True) as transaction:
+    async with get_driver().ro_transaction() as transaction:
         kb = KnowledgeBoxORM(transaction, storage, kbid)
         return await kb.get(uuid)
 

nucliadb/train/nodes.py

@@ -81,7 +81,7 @@ class TrainShardManager(manager.KBShardManager):
         return manager
 
     async def kb_sentences(self, request: GetSentencesRequest) -> AsyncIterator[TrainSentence]:
-        async with self.driver.transaction(read_only=True) as txn:
+        async with self.driver.ro_transaction() as txn:
             kb = KnowledgeBox(txn, self.storage, request.kb.uuid)
             if request.uuid != "":
                 # Filter by uuid
@@ -95,7 +95,7 @@ class TrainShardManager(manager.KBShardManager):
                         yield sentence
 
     async def kb_paragraphs(self, request: GetParagraphsRequest) -> AsyncIterator[TrainParagraph]:
-        async with self.driver.transaction(read_only=True) as txn:
+        async with self.driver.ro_transaction() as txn:
             kb = KnowledgeBox(txn, self.storage, request.kb.uuid)
             if request.uuid != "":
                 # Filter by uuid
@@ -109,7 +109,7 @@ class TrainShardManager(manager.KBShardManager):
                         yield paragraph
 
     async def kb_fields(self, request: GetFieldsRequest) -> AsyncIterator[TrainField]:
-        async with self.driver.transaction(read_only=True) as txn:
+        async with self.driver.ro_transaction() as txn:
             kb = KnowledgeBox(txn, self.storage, request.kb.uuid)
             if request.uuid != "":
                 # Filter by uuid
@@ -123,7 +123,7 @@ class TrainShardManager(manager.KBShardManager):
                         yield field
 
     async def kb_resources(self, request: GetResourcesRequest) -> AsyncIterator[TrainResource]:
-        async with self.driver.transaction(read_only=True) as txn:
+        async with self.driver.ro_transaction() as txn:
             kb = KnowledgeBox(txn, self.storage, request.kb.uuid)
             base = KB_RESOURCE_SLUG_BASE.format(kbid=request.kb.uuid)
             async for key in txn.keys(match=base):

nucliadb/train/servicer.py

@@ -89,7 +89,7 @@ class TrainServicer(train_pb2_grpc.TrainServicer):
     ) -> GetEntitiesResponse:
         kbid = request.kb.uuid
         response = GetEntitiesResponse()
-        async with self.proc.driver.transaction(read_only=True) as txn:
+        async with self.proc.driver.ro_transaction() as txn:
             entities_manager = await self.proc.get_kb_entities_manager(txn, kbid)
             if entities_manager is None:
                 await txn.abort()

nucliadb/train/uploader.py

@@ -75,7 +75,7 @@ class UploadServicer:
     ) -> GetEntitiesResponse:
         kbid = request.kb.uuid
         response = GetEntitiesResponse()
-        async with self.proc.driver.transaction(read_only=True) as txn:
+        async with self.proc.driver.ro_transaction() as txn:
             kbobj = await self.proc.get_kb_obj(txn, request.kb)
             if kbobj is None:
                 response.status = GetEntitiesResponse.Status.NOTFOUND

nucliadb/writer/api/v1/field.py

@@ -18,7 +18,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 from inspect import iscoroutinefunction
-from typing import TYPE_CHECKING, Annotated, Callable, Optional, Type, Union
+from typing import TYPE_CHECKING, Annotated, Callable, List, Optional, Type, Union
 
 import pydantic
 from fastapi import HTTPException, Query, Response
@@ -249,9 +249,10 @@ async def parse_conversation_field_adapter(
     writer: BrokerMessage,
     toprocess: PushPayload,
     resource_classifications: ResourceClassifications,
+    replace_field: bool = False,
 ):
     return await parse_conversation_field(
-        field_id, field_payload, writer, toprocess, kbid, rid, resource_classifications
+        field_id, field_payload, writer, toprocess, kbid, rid, resource_classifications, replace_field
     )
 
 
@@ -380,7 +381,9 @@ async def add_resource_field_conversation_rslug_prefix(
     field_id: FieldIdString,
     field_payload: models.InputConversationField,
 ) -> ResourceFieldAdded:
-    return await add_field_to_resource_by_slug(request, kbid, rslug, field_id, field_payload)
+    return await add_field_to_resource_by_slug(
+        request, kbid, rslug, field_id, field_payload, replace_field=True
+    )
 
 
 @api.put(
@@ -399,7 +402,7 @@ async def add_resource_field_conversation_rid_prefix(
     field_id: FieldIdString,
     field_payload: models.InputConversationField,
 ) -> ResourceFieldAdded:
-    return await add_field_to_resource(request, kbid, rid, field_id, field_payload)
+    return await add_field_to_resource(request, kbid, rid, field_id, field_payload, replace_field=True)
 
 
 @api.put(
@@ -460,13 +463,15 @@ async def append_messages_to_conversation_field_rslug_prefix(
     kbid: str,
     rslug: str,
     field_id: FieldIdString,
-    messages: list[models.InputMessage],
+    messages: List[models.InputMessage],
 ) -> ResourceFieldAdded:
     try:
         field = models.InputConversationField(messages=messages)
     except pydantic.ValidationError as e:
         raise HTTPException(status_code=422, detail=str(e))
-    return await add_field_to_resource_by_slug(request, kbid, rslug, field_id, field)
+    return await add_field_to_resource_by_slug(
+        request, kbid, rslug, field_id, field, replace_field=False
+    )
 
 
 @api.put(
@@ -483,13 +488,13 @@ async def append_messages_to_conversation_field_rid_prefix(
     kbid: str,
     rid: str,
     field_id: FieldIdString,
-    messages: list[models.InputMessage],
+    messages: List[models.InputMessage],
 ) -> ResourceFieldAdded:
     try:
         field = models.InputConversationField(messages=messages)
     except pydantic.ValidationError as e:
         raise HTTPException(status_code=422, detail=str(e))
-    return await add_field_to_resource(request, kbid, rid, field_id, field)
+    return await add_field_to_resource(request, kbid, rid, field_id, field, replace_field=False)
 
 
 @api.delete(
@@ -572,7 +577,7 @@ async def reprocess_file_field(
     storage = await get_storage(service_name=SERVICE_NAME)
     driver = get_driver()
 
-    async with driver.transaction(read_only=True) as txn:
+    async with driver.ro_transaction() as txn:
         kb = KnowledgeBox(txn, storage, kbid)
 
         resource = await kb.get(rid)