nucliadb 2.46.1.post382__py3-none-any.whl → 6.2.1.post2777__py3-none-any.whl

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

@@ -1,275 +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
-
-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,
-)
-
-
-@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()
-    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"),
-    ]

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()

nucliadb/reader/api/v1/learning_collector.py

@@ -1,63 +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 fastapi import Request
-from fastapi_versioning import version
-
-from nucliadb.learning_proxy import learning_collector_proxy
-from nucliadb.reader.api.v1.router import KB_PREFIX, api
-from nucliadb_models.resource import NucliaDBRoles
-from nucliadb_utils.authentication import requires
-
-
-@api.get(
-    path=f"/{KB_PREFIX}/{{kbid}}/feedback/{{month}}",
-    status_code=200,
-    name="Download feedback of a Knowledge Box",
-    description="Download the feedback of a particular month in a Knowledge Box",  # noqa
-    response_model=None,
-    tags=["Knowledge Boxes"],
-)
-@requires(NucliaDBRoles.READER)
-@version(1)
-async def feedback_download(
-    request: Request,
-    kbid: str,
-    month: str,
-):
-    return await learning_collector_proxy(
-        request, "GET", f"/collect/feedback/{kbid}/{month}"
-    )
-
-
-@api.get(
-    path=f"/{KB_PREFIX}/{{kbid}}/feedback",
-    status_code=200,
-    name="Feedback avalaible months",
-    description="List of months within the last year with feedback data",
-    response_model=None,
-    tags=["Knowledge Boxes"],
-)
-@requires(NucliaDBRoles.READER)
-@version(1)
-async def feedback_list_months(
-    request: Request,
-    kbid: str,
-):
-    return await learning_collector_proxy(request, "GET", f"/collect/feedback/{kbid}")

nucliadb/reader/tests/__init__.py

@@ -1,19 +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/>.
-#