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

nucliadb/common/cluster/rollover.py

@@ -34,8 +34,10 @@ from nucliadb.common.external_index_providers.base import ExternalIndexManager
 from nucliadb.common.external_index_providers.manager import (
     get_external_index_manager,
 )
+from nucliadb.common.maindb.utils import get_driver
 from nucliadb.common.nidx import get_nidx_api_client
 from nucliadb.common.vector_index_config import nucliadb_index_config_to_nidx
+from nucliadb.ingest.orm.knowledgebox import KnowledgeBox
 from nucliadb.migrator.settings import settings
 from nucliadb_protos import utils_pb2, writer_pb2
 from nucliadb_telemetry import errors
@@ -45,6 +47,7 @@ from .utils import (
     get_resource,
     get_rollover_resource_index_message,
     index_resource_to_shard,
+    wait_for_nidx,
 )
 
 logger = logging.getLogger(__name__)
@@ -254,6 +257,7 @@ async def index_to_rollover_index(
             for rid in resource_ids
         ]
         await asyncio.gather(*batch)
+        await wait_for_indexing_to_catch_up(app_context)
 
     async with datamanagers.with_transaction() as txn:
         state.resources_indexed = True
@@ -262,6 +266,22 @@ async def index_to_rollover_index(
         await txn.commit()
 
 
+async def wait_for_indexing_to_catch_up(app_context: ApplicationContext):
+    try:
+        app_context.nats_manager
+    except AssertionError:
+        logger.warning("Nats manager not initialized. Cannot wait for indexing to catch up")
+        return
+    max_pending = 1000
+    while True:
+        try:
+            await wait_for_nidx(app_context.nats_manager, max_wait_seconds=60, max_pending=max_pending)
+            return
+        except asyncio.TimeoutError:
+            logger.warning(f"Nidx is behind more than {max_pending} messages. Throttling rollover.")
+            await asyncio.sleep(30)
+
+
 async def _index_resource_to_rollover_index(
     app_context: ApplicationContext,
     rollover_shards: writer_pb2.Shards,
@@ -415,6 +435,15 @@ async def cutover_shards(app_context: ApplicationContext, kbid: str) -> None:
 
         await txn.commit()
 
+    # For KBs with pre-warm enabled, we must configure the new shards. There may
+    # be some small delay between this call and the shards being actually
+    # prewarmed, but rollovers are quite unusual and we prefer this rather than
+    # prewarming old and new shards at the same time
+    kb_config = await datamanagers.atomic.kb.get_config(kbid=kbid)
+    if kb_config is not None and kb_config.prewarm_enabled:
+        driver = get_driver()
+        await KnowledgeBox.configure_shards(driver, kbid, prewarm=True)
+
 
 async def validate_indexed_data(
     app_context: ApplicationContext, kbid: str, external: Optional[ExternalIndexManager] = None

nucliadb/common/cluster/settings.py

@@ -42,7 +42,7 @@ class Settings(BaseSettings):
         description="Maximum number of paragraphs to target per shard",
     )
     max_resource_paragraphs: int = Field(
-        default=50_000,
+        default=300_000,
         title="Max paragraphs per resource",
         description="Maximum number of paragraphs allowed on a single resource",
     )

nucliadb/common/cluster/utils.py

@@ -32,6 +32,7 @@ from nucliadb.common.cluster.settings import settings
 from nucliadb.ingest.orm import index_message
 from nucliadb.ingest.orm.resource import Resource
 from nucliadb_protos import writer_pb2
+from nucliadb_utils.nats import NatsConnectionManager
 from nucliadb_utils.utilities import Utility, clean_utility, get_utility, set_utility
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -125,3 +126,28 @@ async def delete_resource_from_shard(
     partition = partitioning.generate_partition(kbid, resource_id)
 
     await sm.delete_resource(shard, resource_id, 0, str(partition), kbid)
+
+
+async def get_nats_consumer_pending_messages(
+    nats_manager: NatsConnectionManager, *, stream: str, consumer: str
+) -> int:
+    # get raw js client
+    js = nats_manager.js
+    consumer_info = await js.consumer_info(stream, consumer)
+    return consumer_info.num_pending
+
+
+async def wait_for_nidx(
+    nats_manager: NatsConnectionManager,
+    max_pending: int,
+    poll_interval_seconds: int = 5,
+    max_wait_seconds: int = 60,
+):
+    async with asyncio.timeout(max_wait_seconds):  # type: ignore
+        while True:
+            pending = await get_nats_consumer_pending_messages(
+                nats_manager, stream="nidx", consumer="nidx"
+            )
+            if pending < max_pending:
+                return
+            await asyncio.sleep(poll_interval_seconds)

nucliadb/common/datamanagers/atomic.py

@@ -42,6 +42,7 @@ from typing_extensions import Concatenate, ParamSpec
 
 from nucliadb.common.maindb.driver import Transaction
 
+from . import cluster as cluster_dm
 from . import kb as kb_dm
 from . import labels as labels_dm
 from . import resources as resources_dm
@@ -73,6 +74,10 @@ def rw_txn_wrap(fun: Callable[Concatenate[Transaction, P], Awaitable[T]]) -> Cal
     return wrapper
 
 
+class cluster:
+    get_kb_shards = ro_txn_wrap(cluster_dm.get_kb_shards)
+
+
 class kb:
     exists_kb = ro_txn_wrap(kb_dm.exists_kb)
     get_config = ro_txn_wrap(kb_dm.get_config)
@@ -83,6 +88,7 @@ class resources:
     get_resource_uuid_from_slug = ro_txn_wrap(resources_dm.get_resource_uuid_from_slug)
     resource_exists = ro_txn_wrap(resources_dm.resource_exists)
     slug_exists = ro_txn_wrap(resources_dm.slug_exists)
+    get_all_field_ids = ro_txn_wrap(resources_dm.get_all_field_ids)
 
 
 class labelset:

nucliadb/common/datamanagers/utils.py

@@ -42,7 +42,7 @@ async def get_kv_pb(
 @contextlib.asynccontextmanager
 async def with_rw_transaction():
     driver = get_driver()
-    async with driver.transaction(read_only=False) as txn:
+    async with driver.rw_transaction() as txn:
         yield txn
 
 
@@ -53,5 +53,5 @@ with_transaction = with_rw_transaction
 @contextlib.asynccontextmanager
 async def with_ro_transaction():
     driver = get_driver()
-    async with driver.transaction(read_only=True) as ro_txn:
+    async with driver.ro_transaction() as ro_txn:
         yield ro_txn

nucliadb/common/external_index_providers/manager.py

@@ -23,13 +23,9 @@ import async_lru
 
 from nucliadb.common import datamanagers
 from nucliadb.common.external_index_providers.base import ExternalIndexManager
-from nucliadb.common.external_index_providers.pinecone import PineconeIndexManager
-from nucliadb.common.external_index_providers.settings import settings
 from nucliadb_protos.knowledgebox_pb2 import (
-    ExternalIndexProviderType,
     StoredExternalIndexProviderMetadata,
 )
-from nucliadb_utils.utilities import get_endecryptor
 
 
 async def get_external_index_manager(
@@ -39,31 +35,7 @@ async def get_external_index_manager(
     Returns an ExternalIndexManager for the given kbid.
     If for_rollover is True, the ExternalIndexManager returned will include the rollover indexes (if any).
     """
-    metadata = await get_external_index_metadata(kbid)
-    if metadata is None or metadata.type != ExternalIndexProviderType.PINECONE:
-        # Only Pinecone is supported for now
-        return None
-
-    api_key = get_endecryptor().decrypt(metadata.pinecone_config.encrypted_api_key)
-    default_vectorset = await get_default_vectorset_id(kbid)
-
-    rollover_indexes = None
-    if for_rollover:
-        rollover_metadata = await get_rollover_external_index_metadata(kbid)
-        if rollover_metadata is not None:
-            rollover_indexes = dict(rollover_metadata.pinecone_config.indexes)
-
-    return PineconeIndexManager(
-        kbid=kbid,
-        api_key=api_key,
-        indexes=dict(metadata.pinecone_config.indexes),
-        upsert_parallelism=settings.pinecone_upsert_parallelism,
-        delete_parallelism=settings.pinecone_delete_parallelism,
-        upsert_timeout=settings.pinecone_upsert_timeout,
-        delete_timeout=settings.pinecone_delete_timeout,
-        default_vectorset=default_vectorset,
-        rollover_indexes=rollover_indexes,
-    )
+    return None
 
 
 @async_lru.alru_cache(maxsize=None)

nucliadb/common/external_index_providers/settings.py

@@ -17,36 +17,10 @@
 # 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 pydantic import Field
 from pydantic_settings import BaseSettings
 
 
-class ExternalIndexProvidersSettings(BaseSettings):
-    pinecone_upsert_parallelism: int = Field(
-        default=3,
-        title="Pinecone upsert parallelism",
-        description="Number of parallel upserts to Pinecone on each set resource operation",
-    )
-    pinecone_delete_parallelism: int = Field(
-        default=2,
-        title="Pinecone delete parallelism",
-        description="Number of parallel deletes to Pinecone on each delete resource operation",
-    )
-    pinecone_upsert_timeout: float = Field(
-        default=10.0,
-        title="Pinecone upsert timeout",
-        description="Timeout in seconds for each upsert operation to Pinecone",
-    )
-    pinecone_delete_timeout: float = Field(
-        default=10.0,
-        title="Pinecone delete timeout",
-        description="Timeout in seconds for each delete operation to Pinecone",
-    )
-    pinecone_query_timeout: float = Field(
-        default=10.0,
-        title="Pinecone query timeout",
-        description="Timeout in seconds for each query operation to Pinecone",
-    )
+class ExternalIndexProvidersSettings(BaseSettings): ...
 
 
 settings = ExternalIndexProvidersSettings()

nucliadb/common/filter_expression.py

@@ -52,37 +52,20 @@ from nucliadb_models.filters import (
 )
 
 # Filters that end up as a facet
-FacetFilter = Union[
-    OriginTag,
-    Label,
-    ResourceMimetype,
-    FieldMimetype,
-    Entity,
-    Language,
-    OriginMetadata,
-    OriginPath,
-    Generated,
-    Kind,
-    OriginCollaborator,
-    OriginSource,
-    Status,
-]
-# In Python 3.9 we cannot do isinstance against an union
-# Once we support only 3.10+, we can remove this
-FacetFilterTypes = (
-    OriginTag,
-    Label,
-    ResourceMimetype,
-    FieldMimetype,
-    Entity,
-    Language,
-    OriginMetadata,
-    OriginPath,
-    Generated,
-    Kind,
-    OriginCollaborator,
-    OriginSource,
-    Status,
+FacetFilter = (
+    OriginTag
+    | Label
+    | ResourceMimetype
+    | FieldMimetype
+    | Entity
+    | Language
+    | OriginMetadata
+    | OriginPath
+    | Generated
+    | Kind
+    | OriginCollaborator
+    | OriginSource
+    | Status
 )
 
 
@@ -110,7 +93,7 @@ async def parse_expression(
             if rid is None:
                 raise InvalidQueryError("slug", f"Cannot find slug {expr.slug}")
             f.resource.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, Field):
@@ -131,7 +114,7 @@ async def parse_expression(
             f.date.since.FromDatetime(expr.since)
         if expr.until:
             f.date.until.FromDatetime(expr.until)
-    elif isinstance(expr, FacetFilterTypes):
+    elif isinstance(expr, FacetFilter):
         f.facet.facet = facet_from_filter(expr)
     else:
         # This is a trick so mypy generates an error if this branch can be reached,

nucliadb/common/http_clients/exceptions.py

@@ -21,6 +21,10 @@ class ClientException(Exception):
     pass
 
 
+class ServerException(Exception):
+    pass
+
+
 class NotFoundException(ClientException):
     pass
 
@@ -35,3 +39,7 @@ class RateLimitException(ClientException):
 
 class AccountLimitException(ClientException):
     pass
+
+
+class ServiceUnavailableException(ServerException):
+    pass

nucliadb/common/http_clients/processing.py

@@ -209,6 +209,10 @@ class ProcessingHTTPClient:
     async def close(self):
         await self.session.close()
 
+    async def reset_session(self):
+        await self.close()
+        self.session = aiohttp.ClientSession()
+
     async def in_progress(self, ack_token: str):
         url = self.base_url_v2 + "/pull/in_progress"
         request = InProgressRequest(ack=[ack_token])

nucliadb/common/http_clients/utils.py

@@ -33,5 +33,8 @@ def check_status(resp: aiohttp.ClientResponse, resp_text: str) -> None:
         raise exceptions.AuthorizationException(f"Unauthorized to access: {resp.status}")
     elif resp.status == 429:
         raise exceptions.RateLimitException("Rate limited")
+    elif resp.status in (502, 503):
+        # Service unavailable, can be retried
+        raise exceptions.ServiceUnavailableException(f"Service unavailable: {resp.status} - {resp_text}")
     else:
         raise exceptions.ClientException(f"Unknown error: {resp.status} - {resp_text}")

nucliadb/common/ids.py

@@ -47,6 +47,8 @@ FIELD_TYPE_NAME_TO_STR = {
     FieldTypeName.CONVERSATION: "c",
 }
 
+FIELD_TYPE_STR_TO_NAME = {v: k for k, v in FIELD_TYPE_NAME_TO_STR.items()}
+
 
 @dataclass
 class FieldId:
@@ -65,7 +67,7 @@ class FieldId:
 
     Examples:
 
-    >>> FieldId(rid="rid", type="u", key="/my-link")
+    >>> FieldId(rid="rid", type="u", key="my-link")
     FieldID("rid/u/my-link")
     >>> FieldId.from_string("rid/u/my-link")
     FieldID("rid/u/my-link")
@@ -77,31 +79,6 @@ class FieldId:
     # also knwon as `split`, this indicates a part of a field in, for example, conversations
     subfield_id: Optional[str] = None
 
-    def __repr__(self) -> str:
-        return f"FieldId({self.full()})"
-
-    def short_without_subfield(self) -> str:
-        return f"/{self.type}/{self.key}"
-
-    def full(self) -> str:
-        if self.subfield_id is None:
-            return f"{self.rid}/{self.type}/{self.key}"
-        else:
-            return f"{self.rid}/{self.type}/{self.key}/{self.subfield_id}"
-
-    def __hash__(self) -> int:
-        return hash(self.full())
-
-    @property
-    def pb_type(self) -> FieldType.ValueType:
-        return FIELD_TYPE_STR_TO_PB[self.type]
-
-    @classmethod
-    def from_pb(
-        cls, rid: str, field_type: FieldType.ValueType, key: str, subfield_id: Optional[str] = None
-    ) -> "FieldId":
-        return cls(rid=rid, type=FIELD_TYPE_PB_TO_STR[field_type], key=key, subfield_id=subfield_id)
-
     @classmethod
     def from_string(cls, value: str) -> "FieldId":
         """
@@ -120,11 +97,11 @@ class FieldId:
         parts = value.split("/")
         if len(parts) == 3:
             rid, _type, key = parts
-            _type = cls.parse_field_type(_type)
+            _type = cls._parse_field_type(_type)
             return cls(rid=rid, type=_type, key=key)
         elif len(parts) == 4:
             rid, _type, key, subfield_id = parts
-            _type = cls.parse_field_type(_type)
+            _type = cls._parse_field_type(_type)
             return cls(
                 rid=rid,
                 type=_type,
@@ -135,7 +112,46 @@ class FieldId:
             raise ValueError(f"Invalid FieldId: {value}")
 
     @classmethod
-    def parse_field_type(cls, _type: str) -> str:
+    def from_pb(
+        cls, rid: str, field_type: FieldType.ValueType, key: str, subfield_id: Optional[str] = None
+    ) -> "FieldId":
+        return cls(rid=rid, type=FIELD_TYPE_PB_TO_STR[field_type], key=key, subfield_id=subfield_id)
+
+    @property
+    def pb_type(self) -> FieldType.ValueType:
+        return FIELD_TYPE_STR_TO_PB[self.type]
+
+    def full(self) -> str:
+        if self.subfield_id is None:
+            return f"{self.rid}/{self.type}/{self.key}"
+        else:
+            return f"{self.rid}/{self.type}/{self.key}/{self.subfield_id}"
+
+    def short_without_subfield(self) -> str:
+        return f"/{self.type}/{self.key}"
+
+    def paragraph_id(self, paragraph_start: int, paragraph_end: int) -> "ParagraphId":
+        """Generate a ParagraphId from the current field given its start and
+        end.
+
+        """
+        return ParagraphId(
+            field_id=self,
+            paragraph_start=paragraph_start,
+            paragraph_end=paragraph_end,
+        )
+
+    def __str__(self) -> str:
+        return self.full()
+
+    def __repr__(self) -> str:
+        return f"FieldId({self.full()})"
+
+    def __hash__(self) -> int:
+        return hash(self.full())
+
+    @staticmethod
+    def _parse_field_type(_type: str) -> str:
         if _type not in FIELD_TYPE_STR_TO_PB:
             # Try to parse the enum value
             # XXX: This is to support field types that are integer values of FieldType
@@ -157,19 +173,6 @@ class ParagraphId:
     paragraph_start: int
     paragraph_end: int
 
-    def __repr__(self) -> str:
-        return f"ParagraphId({self.full()})"
-
-    def full(self) -> str:
-        return f"{self.field_id.full()}/{self.paragraph_start}-{self.paragraph_end}"
-
-    def __hash__(self) -> int:
-        return hash(self.full())
-
-    @property
-    def rid(self) -> str:
-        return self.field_id.rid
-
     @classmethod
     def from_string(cls, value: str) -> "ParagraphId":
         parts = value.split("/")
@@ -192,6 +195,22 @@ class ParagraphId:
             paragraph_end=vid.vector_end,
         )
 
+    @property
+    def rid(self) -> str:
+        return self.field_id.rid
+
+    def full(self) -> str:
+        return f"{self.field_id.full()}/{self.paragraph_start}-{self.paragraph_end}"
+
+    def __str__(self) -> str:
+        return self.full()
+
+    def __repr__(self) -> str:
+        return f"ParagraphId({self.full()})"
+
+    def __hash__(self) -> int:
+        return hash(self.full())
+
 
 @dataclass
 class VectorId:
@@ -217,19 +236,6 @@ class VectorId:
     vector_start: int
     vector_end: int
 
-    def __repr__(self) -> str:
-        return f"VectorId({self.full()})"
-
-    def full(self) -> str:
-        return f"{self.field_id.full()}/{self.index}/{self.vector_start}-{self.vector_end}"
-
-    def __hash__(self) -> int:
-        return hash(self.full())
-
-    @property
-    def rid(self) -> str:
-        return self.field_id.rid
-
     @classmethod
     def from_string(cls, value: str) -> "VectorId":
         parts = value.split("/")
@@ -239,6 +245,22 @@ class VectorId:
         field_id = FieldId.from_string("/".join(parts[:-2]))
         return cls(field_id=field_id, index=index, vector_start=start, vector_end=end)
 
+    @property
+    def rid(self) -> str:
+        return self.field_id.rid
+
+    def full(self) -> str:
+        return f"{self.field_id.full()}/{self.index}/{self.vector_start}-{self.vector_end}"
+
+    def __str__(self) -> str:
+        return self.full()
+
+    def __repr__(self) -> str:
+        return f"VectorId({self.full()})"
+
+    def __hash__(self) -> int:
+        return hash(self.full())
+
 
 def extract_data_augmentation_id(generated_field_id: str) -> Optional[str]:
     """Data augmentation generated fields have a strict id with the following

nucliadb/common/locking.py

@@ -75,7 +75,7 @@ class _Lock:
         start = time.time()
         while True:
             try:
-                async with self.driver.transaction() as txn:
+                async with self.driver.rw_transaction() as txn:
                     lock_data = await self.get_lock_data(txn)
                     if lock_data is None:
                         await self._set_lock_value(txn)
@@ -128,7 +128,7 @@ class _Lock:
         while True:
             try:
                 await asyncio.sleep(self.refresh_timeout)
-                async with self.driver.transaction() as txn:
+                async with self.driver.rw_transaction() as txn:
                     await self._update_lock_value(txn)
                     await txn.commit()
             except (asyncio.CancelledError, RuntimeError):
@@ -138,12 +138,12 @@ class _Lock:
 
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
         self.task.cancel()
-        async with self.driver.transaction() as txn:
+        async with self.driver.rw_transaction() as txn:
             await txn.delete(self.key)
             await txn.commit()
 
     async def is_locked(self) -> bool:
-        async with get_driver().transaction(read_only=True) as txn:
+        async with get_driver().ro_transaction() as txn:
             lock_data = await self.get_lock_data(txn)
         return lock_data is not None and time.time() < lock_data.expires_at
 

nucliadb/common/maindb/driver.py

@@ -81,5 +81,15 @@ class Driver:
                     pass
 
     @asynccontextmanager
-    async def transaction(self, read_only: bool = False) -> AsyncGenerator[Transaction, None]:
+    async def _transaction(self, *, read_only: bool) -> AsyncGenerator[Transaction, None]:
         yield Transaction()
+
+    @asynccontextmanager
+    async def ro_transaction(self) -> AsyncGenerator[Transaction, None]:
+        async with self._transaction(read_only=True) as txn:
+            yield txn
+
+    @asynccontextmanager
+    async def rw_transaction(self) -> AsyncGenerator[Transaction, None]:
+        async with self._transaction(read_only=False) as txn:
+            yield txn

nucliadb/common/maindb/local.py

@@ -222,7 +222,7 @@ class LocalDriver(Driver):
         pass
 
     @asynccontextmanager
-    async def transaction(self, read_only: bool = False) -> AsyncGenerator[Transaction, None]:
+    async def _transaction(self, *, read_only: bool) -> AsyncGenerator[Transaction, None]:
         if self.url is None:
             raise AttributeError("Invalid url")
         txn = LocalTransaction(self.url, self)

nucliadb/common/maindb/pg.py

@@ -330,7 +330,7 @@ class PGDriver(Driver):
             metric.set(value)
 
     @asynccontextmanager
-    async def transaction(self, read_only: bool = False) -> AsyncGenerator[Transaction, None]:
+    async def _transaction(self, *, read_only: bool) -> AsyncGenerator[Transaction, None]:
         if read_only:
             yield ReadOnlyPGTransaction(self)
         else:

nucliadb/common/nidx.py

@@ -82,6 +82,24 @@ def _storage_config(prefix: str, bucket: Optional[str]) -> dict[str, str]:
         config[f"{prefix}__REGION_NAME"] = storage_settings.s3_region_name or ""
         if storage_settings.s3_endpoint:
             config[f"{prefix}__ENDPOINT"] = storage_settings.s3_endpoint
+    elif storage_settings.file_backend == FileBackendConfig.AZURE:
+        if storage_settings.azure_account_url is None:
+            raise ValueError("Azure account is required")
+        config[f"{prefix}__OBJECT_STORE"] = "azure"
+        url = storage_settings.azure_account_url
+        container = bucket or extended_storage_settings.azure_indexing_bucket
+        if container:
+            url += f"/{container}"
+        config[f"{prefix}__CONTAINER_URL"] = url
+        if storage_settings.azure_connection_string:
+            params = {
+                p.split("=", 1)[0]: p.split("=", 1)[1]
+                for p in storage_settings.azure_connection_string.split(";")
+            }
+            if "AccountKey" in params:
+                config[f"{prefix}__ACCOUNT_KEY"] = params["AccountKey"]
+            if "BlobEndpoint" in params:
+                config[f"{prefix}__ENDPOINT"] = params["BlobEndpoint"]
 
     return config
 
@@ -198,7 +216,7 @@ class NidxServiceUtility(NidxUtility):
         return await self.indexer.index(writer)
 
 
-async def start_nidx_utility(service_name: str = "nucliadb.nidx") -> Optional[NidxUtility]:
+async def start_nidx_utility(service_name: str = "nucliadb.nidx") -> NidxUtility:
     nidx = get_utility(Utility.NIDX)
     if nidx:
         return nidx

nucliadb/common/vector_index_config.py

@@ -26,7 +26,7 @@ from nucliadb_protos import knowledgebox_pb2 as Nucliadb
 def nucliadb_vector_type_to_nidx(nucliadb: Nucliadb.VectorType.ValueType) -> Nidx.VectorType.ValueType:
     if nucliadb == Nucliadb.DENSE_F32:
         return Nidx.DENSE_F32
-    else:  # pragma: nocover
+    else:  # pragma: no cover
         raise Exception("Unknown vector type")