nucliadb 4.0.0.post542__py3-none-any.whl → 6.2.1.post2798__py3-none-any.whl

nucliadb/ingest/tests/unit/orm/test_resource.py

@@ -1,331 +0,0 @@
-# Copyright (C) 2021 Bosutech XXI S.L.
-#
-# nucliadb is offered under the AGPL v3.0 and as commercial software.
-# For commercial licensing, contact us at info@nuclia.com.
-#
-# AGPL:
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Affero General Public License for more details.
-#
-# 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 unittest.mock import AsyncMock, MagicMock, Mock, patch
-
-import pytest
-from nucliadb_protos.resources_pb2 import (
-    AllFieldIDs,
-    Basic,
-    CloudFile,
-    FieldID,
-    FieldText,
-    FieldType,
-    FileExtractedData,
-    PagePositions,
-)
-from nucliadb_protos.writer_pb2 import BrokerMessage
-
-from nucliadb.ingest.orm.resource import (
-    Resource,
-    get_file_page_positions,
-    get_text_field_mimetype,
-    maybe_update_basic_icon,
-    maybe_update_basic_summary,
-    maybe_update_basic_thumbnail,
-    update_basic_languages,
-)
-from nucliadb_protos import utils_pb2, writer_pb2
-
-
-@pytest.mark.asyncio
-async def test_get_file_page_positions():
-    extracted_data = FileExtractedData()
-    extracted_data.file_pages_previews.positions.extend(
-        [PagePositions(start=0, end=10), PagePositions(start=11, end=20)]
-    )
-    file_field = AsyncMock(
-        get_file_extracted_data=AsyncMock(return_value=extracted_data)
-    )
-    assert await get_file_page_positions(file_field) == {0: (0, 10), 1: (11, 20)}
-
-
-@pytest.mark.parametrize(
-    "basic,summary,updated",
-    [
-        (Basic(), "new_summary", True),
-        (Basic(summary="summary"), "new_summary", False),
-        (Basic(summary="summary"), "", False),
-    ],
-)
-def test_maybe_update_basic_summary(basic, summary, updated):
-    assert maybe_update_basic_summary(basic, summary) is updated
-    if updated:
-        assert basic.summary == summary
-    else:
-        assert basic.summary != summary
-
-
-def test_update_basic_languages():
-    basic = Basic()
-    # Languages are updated the first time
-    assert update_basic_languages(basic, ["en"]) is True
-    assert basic.metadata.language == "en"
-    assert basic.metadata.languages == ["en"]
-
-    # Languages are not updated
-    assert update_basic_languages(basic, ["en"]) is False
-    assert basic.metadata.language == "en"
-    assert basic.metadata.languages == ["en"]
-
-    # Main language is not updated but new language is added
-    assert update_basic_languages(basic, ["de"]) is True
-    assert basic.metadata.language == "en"
-    assert basic.metadata.languages == ["en", "de"]
-
-    # Null values
-    assert update_basic_languages(basic, [""]) is False
-    assert update_basic_languages(basic, [None]) is False  # type: ignore
-    assert basic.metadata.language == "en"
-    assert basic.metadata.languages == ["en", "de"]
-
-
-@pytest.mark.parametrize(
-    "basic,thumbnail,updated",
-    [
-        (Basic(), CloudFile(uri="new_thumbnail_url"), True),
-        (
-            Basic(thumbnail="old_thumbnail_url"),
-            CloudFile(uri="new_thumbnail_url"),
-            False,
-        ),
-        (Basic(thumbnail="old_thumbnail_url"), None, False),
-    ],
-)
-def test_maybe_update_basic_thumbnail(basic, thumbnail, updated):
-    assert maybe_update_basic_thumbnail(basic, thumbnail) == updated
-    if updated:
-        assert basic.thumbnail == thumbnail.uri
-    else:
-        assert basic.thumbnail == "old_thumbnail_url"
-
-
-@pytest.mark.parametrize(
-    "text_format,mimetype",
-    [
-        (None, None),
-        (FieldText.Format.PLAIN, "text/plain"),
-        (FieldText.Format.HTML, "text/html"),
-        (FieldText.Format.RST, "text/x-rst"),
-        (FieldText.Format.MARKDOWN, "text/markdown"),
-        (FieldText.Format.KEEP_MARKDOWN, "text/markdown"),
-    ],
-)
-def test_get_text_field_mimetype(text_format, mimetype):
-    message = BrokerMessage()
-    if text_format is not None:
-        message.texts["foo"].body = "foo"
-        message.texts["foo"].format = text_format
-    assert get_text_field_mimetype(message) == mimetype
-
-
-@pytest.mark.parametrize(
-    "basic,icon,updated",
-    [
-        (Basic(), None, False),
-        (Basic(icon="text/plain"), "text/html", False),
-        (Basic(), "text/html", True),
-        (Basic(icon=""), "text/html", True),
-        (Basic(icon="application/octet-stream"), "text/html", True),
-    ],
-)
-def test_maybe_update_basic_icon(basic, icon, updated):
-    assert maybe_update_basic_icon(basic, icon) == updated
-    if updated:
-        assert basic.icon == icon
-
-
-class Transaction:
-    def __init__(self):
-        self.kv = {}
-
-    async def get(self, key):
-        return self.kv.get(key)
-
-    async def set(self, key, value):
-        self.kv[key] = value
-
-
-@pytest.fixture(scope="function")
-def txn():
-    return Transaction()
-
-
-@pytest.fixture(scope="function")
-def storage():
-    mock = AsyncMock()
-    return mock
-
-
-@pytest.fixture(scope="function")
-def kb():
-    mock = AsyncMock()
-    mock.kbid = "mock-kbid"
-    return mock
-
-
-async def test_get_fields_ids_caches_keys(txn, storage, kb):
-    resource = Resource(txn, storage, kb, "rid")
-    cached_field_keys = [(0, "foo"), (1, "bar")]
-    new_field_keys = [(2, "baz")]
-    resource._inner_get_fields_ids = AsyncMock(return_value=new_field_keys)  # type: ignore
-    resource.all_fields_keys = cached_field_keys
-
-    assert await resource.get_fields_ids() == cached_field_keys
-    resource._inner_get_fields_ids.assert_not_awaited()
-
-    assert await resource.get_fields_ids(force=True) == new_field_keys
-    resource._inner_get_fields_ids.assert_awaited_once()
-    assert resource.all_fields_keys == new_field_keys
-
-    # If the all_field_keys is an empty list,
-    # we should not be calling the inner_get_fields_ids
-    resource.all_fields_keys = []
-    resource._inner_get_fields_ids.reset_mock()
-    assert await resource.get_fields_ids() == []
-    resource._inner_get_fields_ids.assert_not_awaited()
-
-
-async def test_get_set_all_field_ids(txn, storage, kb):
-    resource = Resource(txn, storage, kb, "rid")
-
-    assert await resource.get_all_field_ids() is None
-
-    all_fields = AllFieldIDs()
-    all_fields.fields.append(FieldID(field_type=FieldType.TEXT, field="text"))
-
-    await resource.set_all_field_ids(all_fields)
-
-    assert await resource.get_all_field_ids() == all_fields
-
-
-async def test_update_all_fields_key(txn, storage, kb):
-    resource = Resource(txn, storage, kb, "rid")
-
-    await resource.update_all_field_ids(updated=[], deleted=[])
-
-    # Initial value is Empty
-    assert (await resource.get_all_field_ids()) == AllFieldIDs()
-
-    all_fields = AllFieldIDs()
-    all_fields.fields.append(FieldID(field_type=FieldType.TEXT, field="text1"))
-    all_fields.fields.append(FieldID(field_type=FieldType.TEXT, field="text2"))
-
-    await resource.update_all_field_ids(updated=all_fields.fields)
-
-    # Check updates
-    assert await resource.get_all_field_ids() == all_fields
-
-    file_field = FieldID(field_type=FieldType.FILE, field="file")
-    await resource.update_all_field_ids(updated=[file_field])
-
-    result = await resource.get_all_field_ids()
-    assert list(result.fields) == list(all_fields.fields) + [file_field]
-
-    # Check deletes
-    await resource.update_all_field_ids(deleted=[file_field])
-
-    assert await resource.get_all_field_ids() == all_fields
-
-
-async def test_apply_fields_calls_update_all_field_ids(txn, storage, kb):
-    resource = Resource(txn, storage, kb, "rid")
-    resource.update_all_field_ids = AsyncMock()  # type: ignore
-    resource.set_field = AsyncMock()  # type: ignore
-
-    bm = MagicMock()
-    bm.layouts = {"layout": MagicMock()}
-    bm.texts = {"text": MagicMock()}
-    bm.keywordsets = {"keywordset": MagicMock()}
-    bm.datetimes = {"datetime": MagicMock()}
-    bm.links = {"link": MagicMock()}
-    bm.files = {"file": MagicMock()}
-    bm.conversations = {"conversation": MagicMock()}
-    bm.delete_fields.append(FieldID(field_type=FieldType.LAYOUT, field="to_delete"))
-
-    await resource.apply_fields(bm)
-
-    resource.update_all_field_ids.assert_awaited_once()
-
-    resource.update_all_field_ids.call_args[1]["updated"] == [
-        FieldID(field_type=FieldType.LAYOUT, field="layout"),
-        FieldID(field_type=FieldType.TEXT, field="text"),
-        FieldID(field_type=FieldType.KEYWORDSET, field="keywordset"),
-        FieldID(field_type=FieldType.DATETIME, field="datetime"),
-        FieldID(field_type=FieldType.LINK, field="link"),
-        FieldID(field_type=FieldType.FILE, field="file"),
-        FieldID(field_type=FieldType.CONVERSATION, field="conversation"),
-    ]
-    resource.update_all_field_ids.call_args[1]["deleted"] == [
-        FieldID(field_type=FieldType.LAYOUT, field="to_delete"),
-    ]
-
-
-async def test_apply_extracted_vectors_matryoshka_embeddings(txn, storage, kb):
-    STORED_VECTOR_DIMENSION = 100
-    MATRYOSHKA_DIMENSION = 10
-
-    mock_field = AsyncMock()
-    vectors = utils_pb2.VectorObject(
-        vectors=utils_pb2.Vectors(
-            vectors=[
-                utils_pb2.Vector(
-                    start=0,
-                    end=10,
-                    start_paragraph=0,
-                    end_paragraph=10,
-                    vector=[1.0] * STORED_VECTOR_DIMENSION,
-                )
-            ]
-        )
-    )
-    mock_field.set_vectors.return_value = (vectors, False, [])
-
-    resource = Resource(txn, storage, kb, "matryoshka-rid")
-    with (
-        patch.object(resource, "has_field", Mock(return_value=True)),
-        patch.object(resource, "get_field", AsyncMock(return_value=mock_field)),
-        patch.object(resource, "generate_field_id", Mock(return_value="field_id")),
-        patch("nucliadb.ingest.orm.resource.datamanagers") as mock_datamanagers,
-        patch.object(
-            resource.indexer, "apply_field_vectors", AsyncMock()
-        ) as apply_field_vectors,
-    ):
-        mock_datamanagers.kb.get_matryoshka_vector_dimension = AsyncMock(
-            return_value=None
-        )
-        await resource._apply_extracted_vectors(
-            writer_pb2.ExtractedVectorsWrapper(vectors=vectors)
-        )
-        assert apply_field_vectors.call_count == 1
-        assert (
-            apply_field_vectors.call_args.kwargs["matryoshka_vector_dimension"] is None
-        )
-
-        mock_datamanagers.kb.get_matryoshka_vector_dimension = AsyncMock(
-            return_value=MATRYOSHKA_DIMENSION
-        )
-        await resource._apply_extracted_vectors(
-            writer_pb2.ExtractedVectorsWrapper(vectors=vectors)
-        )
-        assert apply_field_vectors.call_count == 2
-        assert (
-            apply_field_vectors.call_args.kwargs["matryoshka_vector_dimension"]
-            == MATRYOSHKA_DIMENSION
-        )

nucliadb/ingest/tests/unit/test_cache.py

@@ -1,31 +0,0 @@
-# Copyright (C) 2021 Bosutech XXI S.L.
-#
-# nucliadb is offered under the AGPL v3.0 and as commercial software.
-# For commercial licensing, contact us at info@nuclia.com.
-#
-# AGPL:
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Affero General Public License for more details.
-#
-# 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 nucliadb.common.cluster.index_node import READ_CONNECTIONS, WRITE_CONNECTIONS
-from nucliadb.ingest.cache import clear_ingest_cache
-
-
-def test_clear_ingest_cache():
-    READ_CONNECTIONS["addr1"] = "conn1"
-    WRITE_CONNECTIONS["addr2"] = "conn2"
-
-    clear_ingest_cache()
-
-    assert len(READ_CONNECTIONS) == 0
-    assert len(WRITE_CONNECTIONS) == 0

nucliadb/ingest/tests/unit/test_partitions.py

@@ -1,40 +0,0 @@
-# Copyright (C) 2021 Bosutech XXI S.L.
-#
-# nucliadb is offered under the AGPL v3.0 and as commercial software.
-# For commercial licensing, contact us at info@nuclia.com.
-#
-# AGPL:
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Affero General Public License for more details.
-#
-# 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/>.
-#
-import json
-import os
-
-import pytest
-
-from nucliadb.ingest.partitions import assign_partitions
-
-
-@pytest.mark.asyncio
-async def test_assign_partitions(partition_settings):
-    expected_partition_list = []
-    part = partition_settings.replica_number
-
-    while part < partition_settings.nuclia_partitions:
-        expected_partition_list.append(str(part + 1))
-        part += partition_settings.total_replicas
-
-    assign_partitions(partition_settings)
-
-    assert partition_settings.partitions == expected_partition_list
-    assert os.environ["PARTITIONS"] == json.dumps(expected_partition_list)

nucliadb/ingest/tests/unit/test_processing.py

@@ -1,171 +0,0 @@
-# Copyright (C) 2021 Bosutech XXI S.L.
-#
-# nucliadb is offered under the AGPL v3.0 and as commercial software.
-# For commercial licensing, contact us at info@nuclia.com.
-#
-# AGPL:
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Affero General Public License for more details.
-#
-# 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 unittest.mock import Mock
-
-import pytest
-from nucliadb_protos.resources_pb2 import CloudFile
-
-from nucliadb.ingest.processing import (
-    DummyProcessingEngine,
-    ProcessingEngine,
-    PushPayload,
-)
-from nucliadb.tests.utils.aiohttp_session import get_mocked_session
-from nucliadb_models import File, FileField
-from nucliadb_utils.exceptions import LimitsExceededError, SendToProcessError
-
-TEST_FILE = FileField(
-    password="mypassword", file=File(filename="myfile.pdf", payload="")
-)
-
-TEST_CLOUD_FILE = CloudFile(
-    uri="file.png",
-    source=CloudFile.Source.LOCAL,
-    bucket_name="/integration/ingest/assets",
-    size=4,
-    content_type="image/png",
-    filename="file.png",
-)
-
-TEST_ITEM = PushPayload(uuid="foo", kbid="bar", userid="baz", partition=1)
-
-
-@pytest.mark.asyncio
-async def test_dummy_processing_engine():
-    engine = DummyProcessingEngine()
-    await engine.initialize()
-    await engine.finalize()
-    await engine.convert_filefield_to_str(None)
-    engine.convert_external_filefield_to_str(None)
-    await engine.convert_internal_filefield_to_str(None, None)
-    await engine.convert_internal_cf_to_str(None, None)
-    await engine.send_to_process(Mock(kbid="foo"), 1)
-
-
-@pytest.fixture(scope="function")
-def engine():
-    pe = ProcessingEngine(
-        onprem=True,
-        nuclia_processing_cluster_url="cluster_url",
-        nuclia_public_url="public_url",
-    )
-    yield pe
-
-
-async def test_convert_filefield_to_str_200(engine):
-    engine.session = get_mocked_session("POST", 200, text="jwt")
-
-    assert await engine.convert_filefield_to_str(TEST_FILE) == "jwt"
-
-
-async def test_convert_filefield_to_str_402(engine):
-    engine.session = get_mocked_session("POST", 402, json={"detail": "limits exceeded"})
-
-    with pytest.raises(LimitsExceededError) as exc:
-        await engine.convert_filefield_to_str(TEST_FILE)
-    assert exc.value.status_code == 402
-
-
-async def test_convert_filefield_to_str_429(engine):
-    engine.session = get_mocked_session("POST", 429, json={"detail": "limits exceeded"})
-
-    with pytest.raises(LimitsExceededError) as exc:
-        await engine.convert_filefield_to_str(TEST_FILE)
-    assert exc.value.status_code == 429
-
-
-async def test_convert_filefield_to_str_500(engine):
-    engine.session = get_mocked_session("POST", 500, text="error")
-
-    with pytest.raises(Exception) as exc:
-        await engine.convert_filefield_to_str(TEST_FILE)
-    assert str(exc.value) == "STATUS: 500 - error"
-
-
-async def test_convert_internal_cf_to_str_200(engine):
-    engine.session = get_mocked_session("POST", 200, text="jwt")
-
-    assert await engine.convert_internal_cf_to_str(TEST_CLOUD_FILE, Mock()) == "jwt"
-
-
-async def test_convert_internal_cf_to_str_402(engine):
-    engine.session = get_mocked_session("POST", 402, json={"detail": "limits exceeded"})
-
-    with pytest.raises(LimitsExceededError) as exc:
-        await engine.convert_internal_cf_to_str(TEST_CLOUD_FILE, Mock())
-    assert exc.value.status_code == 402
-
-
-async def test_convert_internal_cf_to_str_429(engine):
-    engine.session = get_mocked_session("POST", 429, json={"detail": "limits exceeded"})
-
-    with pytest.raises(LimitsExceededError) as exc:
-        await engine.convert_internal_cf_to_str(TEST_CLOUD_FILE, Mock())
-    assert exc.value.status_code == 429
-
-
-async def test_convert_internal_cf_to_str_500(engine):
-    engine.session = get_mocked_session("POST", 500, text="error")
-
-    with pytest.raises(Exception) as exc:
-        await engine.convert_internal_cf_to_str(TEST_CLOUD_FILE, Mock())
-    assert str(exc.value) == "STATUS: 500 - error"
-
-
-async def test_send_to_process_200(engine):
-    json_data = {"seqid": 11, "account_seq": 22, "queue": "private"}
-    engine.session = get_mocked_session(
-        "POST", 200, json=json_data, context_manager=False
-    )
-
-    processing_info = await engine.send_to_process(TEST_ITEM, 1)
-    assert processing_info.seqid == 11
-    assert processing_info.account_seq == 22
-    assert processing_info.queue == "private"
-
-
-@pytest.mark.parametrize("status", [402, 413])
-async def test_send_to_process_limits_exceeded(status, engine):
-    engine.session = get_mocked_session(
-        "POST", status, json={"detail": "limits exceeded"}, context_manager=False
-    )
-
-    with pytest.raises(LimitsExceededError) as exc:
-        await engine.send_to_process(TEST_ITEM, 1)
-    assert exc.value.status_code == status
-
-
-async def test_send_to_process_limits_exceeded_429(engine):
-    engine.session = get_mocked_session(
-        "POST", 429, json={"detail": "limits exceeded"}, context_manager=False
-    )
-
-    with pytest.raises(LimitsExceededError) as exc:
-        await engine.send_to_process(TEST_ITEM, 1)
-    assert exc.value.status_code == 429
-
-
-async def test_send_to_process_500(engine):
-    engine.session = get_mocked_session(
-        "POST", 500, text="error", context_manager=False
-    )
-
-    with pytest.raises(SendToProcessError):
-        await engine.send_to_process(TEST_ITEM, 1)

nucliadb/middleware/transaction.py

@@ -1,117 +0,0 @@
-# Copyright (C) 2021 Bosutech XXI S.L.
-#
-# nucliadb is offered under the AGPL v3.0 and as commercial software.
-# For commercial licensing, contact us at info@nuclia.com.
-#
-# AGPL:
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU Affero General Public License for more details.
-#
-# 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/>.
-
-import asyncio
-from contextvars import ContextVar
-from typing import Optional
-
-from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from starlette.requests import Request
-from starlette.responses import Response
-
-from nucliadb.common.maindb.driver import Transaction
-from nucliadb.common.maindb.utils import get_driver
-
-txn_manager: ContextVar[Optional["ReadOnlyTransactionManager"]] = ContextVar(
-    "txn_manager", default=None
-)
-
-
-class ReadOnlyTransactionMiddleware(BaseHTTPMiddleware):
-    """
-    This middleware provides a unique read-only transaction for each request. The transaction is
-    created lazily, so if it's not used, it's not created. The middleware also ensures that the
-    transaction is aborted at the end of the request.
-
-    This is useful, for instance, on search endpoints where we want to minimize the number
-    of transactions that are created.
-
-    Usage:
-        - Add this middleware to the FastAPI app:
-
-            app = FastAPI()
-            app.add_middleware(ReadOnlyTransactionMiddleware)
-
-        - Where needed, get the transaction:
-
-            txn = await get_read_only_transaction()
-    """
-
-    async def dispatch(
-        self, request: Request, call_next: RequestResponseEndpoint
-    ) -> Response:
-        mgr = ReadOnlyTransactionManager()
-        txn_manager.set(mgr)
-        try:
-            return await call_next(request)
-        finally:
-            await mgr.maybe_abort()
-            txn_manager.set(None)
-
-
-class TransactionNotFoundException(Exception):
-    pass
-
-
-class ReadOnlyTransactionManager:
-    def __init__(self):
-        self._transaction: Optional[Transaction] = None
-        self._lock = asyncio.Lock()
-        self.aborted: bool = False
-
-    async def get_transaction(self) -> Transaction:
-        if self.aborted:
-            raise TransactionNotFoundException("Transaction was aborted")
-
-        if self._transaction is not None:
-            return self._transaction
-
-        async with self._lock:
-            # Check again in case it was set while waiting for the lock
-            if self._transaction is not None:
-                return self._transaction
-
-            self._transaction = await self._get_transaction()
-            return self._transaction
-
-    async def _get_transaction(self) -> Transaction:
-        driver = get_driver()
-        txn = await driver.begin(read_only=True)
-        return txn
-
-    async def maybe_abort(self):
-        if self.aborted or self._transaction is None:
-            return
-
-        await self._transaction.abort()
-        self._transaction = None
-        self._lock = None
-        self.aborted = True
-
-
-async def get_read_only_transaction() -> Transaction:
-    """
-    Returns the read-only transaction for the current request
-    """
-    manager: Optional[ReadOnlyTransactionManager] = txn_manager.get()
-    if manager is None:
-        raise TransactionNotFoundException(
-            "Context var is not set. Did you forget to add the ReadOnlyTransactionMiddleware to the app?"
-        )
-    return await manager.get_transaction()