corvic-engine 0.3.0rc67__cp38-abi3-win_amd64.whl → 0.3.0rc69__cp38-abi3-win_amd64.whl

corvic/context/__init__.py

@@ -4,7 +4,6 @@ Affect things like logging and the names of metrics.
 """
 
 import contextvars
-import uuid
 from dataclasses import dataclass
 
 # These are sentinels used only in the Requester object below rather than actual org
@@ -21,17 +20,11 @@ class Requester:
 
 
 _SERVICE_NAME = contextvars.ContextVar("service_name", default="corvic")
-_TRACE_ID = contextvars.ContextVar("trace_id", default="")
 _REQUESTER = contextvars.ContextVar(
     "requester_identity", default=Requester(org_id=NOBODY_ORG_ID)
 )
 
 
-def get_trace_id() -> str:
-    """Get current trace id."""
-    return _TRACE_ID.get()
-
-
 def get_service_name() -> str:
     """Get current service name."""
     return _SERVICE_NAME.get()
@@ -45,7 +38,6 @@ def get_requester() -> Requester:
 def reset_context(*, service_name: str):
     """Reset contextvars for a new request."""
     _SERVICE_NAME.set(service_name)
-    _TRACE_ID.set(str(uuid.uuid4()))
     _REQUESTER.set(Requester(org_id=NOBODY_ORG_ID))
 
 

corvic/model/_base_model.py

@@ -5,12 +5,11 @@ import datetime
 import functools
 import uuid
 from collections.abc import Callable, Iterable, Iterator, Sequence
-from typing import Final, Generic
+from typing import Final, Generic, Self
 
 import sqlalchemy as sa
 import sqlalchemy.orm as sa_orm
 import structlog
-from typing_extensions import Self
 
 from corvic import orm, system
 from corvic.model._proto_orm_convert import (
@@ -54,7 +53,7 @@ class HasProtoSelf(Generic[ProtoObj], abc.ABC):
     @property
     def created_at(self) -> datetime.datetime | None:
         if self.proto_self.created_at:
-            return self.proto_self.created_at.ToDatetime(tzinfo=datetime.timezone.utc)
+            return self.proto_self.created_at.ToDatetime(tzinfo=datetime.UTC)
         return None
 
 
@@ -119,7 +118,7 @@ class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, ProtoObj]):
         while True:
             try:
                 yield from it
-            except Exception:  # noqa: PERF203
+            except Exception:
                 _logger.exception(
                     "omitting source from list: "
                     + "failed to parse source from database entry",

corvic/model/_completion_model.py

@@ -116,16 +116,14 @@ class CompletionModel(
     @property
     def last_validation_time(self) -> datetime.datetime | None:
         if self.proto_self.last_validation_time != UNIX_TIMESTAMP_START_DATETIME:
-            return self.proto_self.last_validation_time.ToDatetime(
-                tzinfo=datetime.timezone.utc
-            )
+            return self.proto_self.last_validation_time.ToDatetime(tzinfo=datetime.UTC)
         return None
 
     @property
     def last_successful_validation(self) -> datetime.datetime | None:
         if self.proto_self.last_successful_validation != UNIX_TIMESTAMP_START_DATETIME:
             return self.proto_self.last_successful_validation.ToDatetime(
-                tzinfo=datetime.timezone.utc
+                tzinfo=datetime.UTC
             )
         return None
 

corvic/model/_feature_view.py

@@ -7,15 +7,14 @@ import dataclasses
 import datetime
 import functools
 import uuid
-from collections.abc import Iterable, Mapping, MutableMapping, Sequence
-from typing import Any, Final, TypeAlias
+from collections.abc import AsyncIterable, Iterable, Mapping, MutableMapping, Sequence
+from typing import Any, Final, Self, TypeAlias
 
 import pyarrow as pa
 from google.protobuf import struct_pb2
 from more_itertools import flatten
 from sqlalchemy import orm as sa_orm
 from sqlalchemy.orm.interfaces import LoaderOption
-from typing_extensions import Self
 
 from corvic import op_graph, orm, system
 from corvic.model._base_model import BelongsToRoomModel, UsesOrmID
@@ -324,7 +323,7 @@ class Relationship:
             how="inner",
         )
 
-    def edge_list(self) -> Iterable[tuple[Any, Any]]:
+    async def edge_list(self) -> AsyncIterable[tuple[Any, Any]]:
         start_pk = self.start_fv_source.table.schema.get_primary_key()
         end_pk = self.end_fv_source.table.schema.get_primary_key()
 
@@ -340,8 +339,8 @@ class Relationship:
 
         result = self.joined_table().select(result_columns)
 
-        for batch in result.to_polars(
-            room_id=self.start_source.room_id
+        for batch in (
+            await result.to_polars(room_id=self.start_source.room_id)
         ).unwrap_or_raise():
             for row in batch.rows(named=True):
                 yield (row[result_columns[0]], row[result_columns[1]])

corvic/model/_pipeline.py

@@ -6,12 +6,11 @@ import datetime
 import functools
 import uuid
 from collections.abc import Iterable, Mapping, Sequence
-from typing import TypeAlias, cast
+from typing import Self, TypeAlias, cast
 
 import polars as pl
 from sqlalchemy import orm as sa_orm
 from sqlalchemy.orm.interfaces import LoaderOption
-from typing_extensions import Self
 
 import corvic.table
 from corvic import op_graph, orm, system

corvic/model/_resource.py

@@ -6,13 +6,12 @@ import copy
 import datetime
 import uuid
 from collections.abc import Iterable, Sequence
-from typing import TypeAlias
+from typing import Self, TypeAlias
 
 import polars as pl
 import sqlalchemy as sa
 from sqlalchemy import orm as sa_orm
 from sqlalchemy.orm.interfaces import LoaderOption
-from typing_extensions import Self
 
 from corvic import orm, system
 from corvic.model._base_model import BelongsToRoomModel

corvic/model/_source.py

@@ -6,13 +6,12 @@ import copy
 import datetime
 import functools
 from collections.abc import Iterable, Mapping, Sequence
-from typing import TypeAlias
+from typing import Self, TypeAlias
 
 import polars as pl
 import sqlalchemy as sa
 import sqlalchemy.orm as sa_orm
 from sqlalchemy.orm.interfaces import LoaderOption
-from typing_extensions import Self
 
 from corvic import op_graph, orm, system
 from corvic.model._base_model import BelongsToRoomModel

corvic/model/_space.py

@@ -3,15 +3,15 @@
 from __future__ import annotations
 
 import abc
+import copy
 import datetime
 import uuid
 from collections.abc import Iterable, Mapping, Sequence
-from typing import Final, Literal, TypeAlias
+from typing import Final, Literal, Self, TypeAlias
 
 import pyarrow as pa
 import sqlalchemy as sa
 from sqlalchemy import orm as sa_orm
-from typing_extensions import Self
 
 from corvic import op_graph, orm, system
 from corvic.model._base_model import BelongsToRoomModel
@@ -183,6 +183,30 @@ class Space(BelongsToRoomModel[SpaceID, models_pb2.Space, orm.Space]):
                     auto_sync=auto_sync,
                 )
 
+    def with_name(self, name: str):
+        proto_self = copy.copy(self.proto_self)
+
+        proto_self.name = name
+
+        return Ok(
+            self.__class__(
+                self.feature_view.client,
+                proto_self,
+            )
+        )
+
+    def with_description(self, description: str):
+        proto_self = copy.copy(self.proto_self)
+
+        proto_self.description = description
+
+        return Ok(
+            self.__class__(
+                self.feature_view.client,
+                proto_self,
+            )
+        )
+
     @classmethod
     def from_id(
         cls,

corvic/op_graph/row_filters/_jsonlogic.py

@@ -16,7 +16,7 @@ from corvic.op_graph.row_filters._row_filters import (
     lt,
     ne,
 )
-from corvic.pa_scalar import from_value
+from corvic.pa_scalar import from_value, to_value
 from corvic.result import Error, InvalidArgumentError, Ok
 
 
@@ -76,6 +76,35 @@ def _var_name(value: struct_pb2.Value) -> str:
             raise _Error("unexpected operation type")
 
 
+def _coerce_literal(literal: struct_pb2.Value, dtype: pa.DataType) -> struct_pb2.Value:
+    # Attempt to coerce the literal to the type it needs to be compared against,
+    # if the types don't already align.
+    match literal.WhichOneof("kind"):
+        case "null_value":
+            types_match = pa.types.is_null(dtype)
+        case "bool_value":
+            types_match = pa.types.is_boolean(dtype)
+        case "list_value":
+            # TODO(aneesh): inner checks for nested types
+            types_match = pa.types.is_list(dtype)
+        case "number_value":
+            types_match = pa.types.is_integer(dtype) or pa.types.is_floating(dtype)
+        case "string_value":
+            types_match = pa.types.is_string(dtype)
+        case "struct_value":
+            # TODO(aneesh): inner checks for nested types
+            types_match = pa.types.is_struct(dtype)
+        case None:
+            raise _Error("Unknown literal type")
+    if not types_match:
+        match from_value(literal, dtype):
+            case Ok(coerced_literal):
+                literal = to_value(coerced_literal)
+            case err:
+                raise err
+    return literal
+
+
 def _simple_compare(
     op: Literal["==", "!=", "<=", ">=", "<", ">"],
     operands: Sequence[struct_pb2.Value],
@@ -92,6 +121,8 @@ def _simple_compare(
     if dtype is None:
         raise _Error("unknown literal type", column_name=column_name)
 
+    literal = _coerce_literal(literal, dtype)
+
     match op:
         case "==":
             return eq(column_name, literal, dtype)

corvic/orm/base.py

@@ -3,14 +3,13 @@
 from __future__ import annotations
 
 import uuid
-from datetime import datetime, timezone
-from typing import Any, ClassVar, Protocol, runtime_checkable
+from datetime import UTC, datetime
+from typing import Any, ClassVar, Protocol, Self, runtime_checkable
 
 import sqlalchemy as sa
 import sqlalchemy.orm as sa_orm
 from google.protobuf import timestamp_pb2
 from sqlalchemy.ext import hybrid
-from typing_extensions import Self
 
 from corvic.orm._proto_columns import ProtoMessageDecorator
 from corvic.orm.func import utc_now
@@ -151,7 +150,7 @@ class Base(sa_orm.MappedAsDataclass, sa_orm.DeclarativeBase):
     def created_at(self) -> datetime | None:
         if not self._created_at:
             return None
-        return self._created_at.replace(tzinfo=timezone.utc)
+        return self._created_at.replace(tzinfo=UTC)
 
     @created_at.inplace.expression
     @classmethod
@@ -162,7 +161,7 @@ class Base(sa_orm.MappedAsDataclass, sa_orm.DeclarativeBase):
     def updated_at(self) -> datetime | None:
         if not self._updated_at:
             return None
-        return self._updated_at.replace(tzinfo=timezone.utc)
+        return self._updated_at.replace(tzinfo=UTC)
 
     @updated_at.inplace.expression
     @classmethod

corvic/orm/ids.py

@@ -3,11 +3,10 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, Self, TypeVar
 
 import sqlalchemy as sa
 import sqlalchemy.types as sa_types
-from typing_extensions import Self
 
 import corvic.context
 from corvic.orm.errors import InvalidORMIdentifierError

corvic/orm/mixins.py

@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Sequence
-from datetime import datetime, timezone
-from typing import Any, cast
+from datetime import UTC, datetime
+from typing import Any, LiteralString, cast
 
 import sqlalchemy as sa
 from google.protobuf import timestamp_pb2
@@ -12,7 +12,6 @@ from sqlalchemy import event, exc
 from sqlalchemy import orm as sa_orm
 from sqlalchemy.ext import hybrid
 from sqlalchemy.ext.hybrid import hybrid_property
-from typing_extensions import LiteralString
 
 import corvic.context
 from corvic.orm.base import EventBase, EventKey, OrgBase
@@ -137,7 +136,7 @@ class SoftDeleteMixin(sa_orm.MappedAsDataclass):
     def deleted_at(self) -> datetime | None:
         if not self._deleted_at:
             return None
-        return self._deleted_at.replace(tzinfo=timezone.utc)
+        return self._deleted_at.replace(tzinfo=UTC)
 
     def reset_delete(self):
         self._deleted_at = None
@@ -170,7 +169,7 @@ class SoftDeleteMixin(sa_orm.MappedAsDataclass):
         # set is_live to None instead of False so that orm objects can use it to
         # build uniqueness constraints that are only enforced on non-deleted objects
         self.is_live = None
-        self._deleted_at = datetime.now(tz=timezone.utc)
+        self._deleted_at = datetime.now(tz=UTC)
 
     @hybrid_property
     def is_deleted(self) -> bool:
@@ -343,7 +342,7 @@ class Session(sa_orm.Session):
 def _timestamp_or_utc_now(timestamp: datetime | None = None):
     if timestamp is not None:
         return timestamp
-    return datetime.now(tz=timezone.utc)
+    return datetime.now(tz=UTC)
 
 
 class EventLoggerMixin(sa_orm.MappedAsDataclass):
@@ -383,12 +382,11 @@ class EventLoggerMixin(sa_orm.MappedAsDataclass):
                 # this can occur when an event is set on a new object
                 if not self._event_src_id:
                     obj_session.flush()
-                from datetime import timezone
 
                 obj_session.add(
                     EventBase(
                         event=event.event_type,
-                        timestamp=event.timestamp.ToDatetime(tzinfo=timezone.utc),
+                        timestamp=event.timestamp.ToDatetime(tzinfo=UTC),
                         regarding=event.regarding,
                         reason=event.reason,
                         event_key=str(self.event_key),

corvic/pa_scalar/_temporal.py

@@ -86,7 +86,7 @@ def datetime_fromisoformat(s: str) -> datetime.datetime:
 
     tzinfo = None
     if m.group("utc"):
-        tzinfo = datetime.timezone.utc
+        tzinfo = datetime.UTC
 
     tz_hour = m.group("tz_hour")
     if tz_hour:

corvic/result/__init__.py

@@ -55,12 +55,11 @@ from typing import (
     Literal,
     NoReturn,
     ParamSpec,
+    Self,
     TypeVar,
     overload,
 )
 
-from typing_extensions import Self
-
 from corvic.well_known_types import JSONAble, JSONExpressable, to_json
 
 T_co = TypeVar("T_co", covariant=True)

corvic/system/_column_encoding.py

@@ -0,0 +1,215 @@
+import math
+from typing import Final, cast
+
+import numpy as np
+import polars as pl
+import structlog
+
+REFERENCE_YEAR: Final = 1900
+"""Reference year for normalizing year in Datetime encoder"""
+
+MAX_NUMBER_OF_YEARS: Final = 200
+"""Maximum number of years for normalizing year in Datetime encoder"""
+
+_logger = structlog.get_logger()
+
+
+def encode_one_hot(to_encode: pl.Series) -> tuple[pl.Series, list[str]]:
+    encoded = to_encode.to_dummies()
+    return (
+        encoded.select(
+            pl.concat_list(pl.all()).alias("val").cast(pl.List(pl.Boolean))
+        ).to_series(),
+        encoded.columns,
+    )
+
+
+def encode_min_max_scale(
+    to_encode: pl.Series, range_min: float, range_max: float
+) -> pl.Series:
+    from sklearn.preprocessing import MinMaxScaler
+
+    encoder = MinMaxScaler(
+        feature_range=(
+            range_min,
+            range_max,
+        )
+    )
+    return pl.Series(
+        encoder.fit_transform(to_encode.to_numpy().reshape(-1, 1)).flatten()
+    )
+
+
+def encode_label_boolean(
+    to_encode: pl.Series, neg_label: int, pos_label: int
+) -> pl.Series:
+    from sklearn.preprocessing import LabelBinarizer
+
+    encoder = LabelBinarizer(
+        neg_label=neg_label,
+        pos_label=pos_label,
+    )
+    return pl.Series(encoder.fit_transform(to_encode.to_numpy().reshape(-1)))
+
+
+def encode_label(to_encode: pl.Series, *, normalize: bool) -> pl.Series:
+    from sklearn.preprocessing import LabelEncoder
+
+    encoder = LabelEncoder()
+    encoded = encoder.fit_transform(to_encode.to_numpy().reshape(-1)).flatten()
+    # `classes_` is only set after fit,
+    # Creating custom typestubs will not solve this typing issue.
+    if normalize and hasattr(encoder, "classes_"):
+        classes_ = cast(list[int], encoder.classes_)  # pyright: ignore[reportAttributeAccessIssue, reportUnknownMemberType]
+        max_class: int = len(classes_) - 1
+        if max_class > 0:
+            encoded = encoded.astype(np.float64)
+            encoded /= max_class
+
+    return pl.Series(encoded)
+
+
+def encode_kbins(
+    to_encode: pl.Series, n_bins: int, method: str, strategy: str
+) -> pl.Series:
+    from sklearn.preprocessing import KBinsDiscretizer
+
+    encoder = KBinsDiscretizer(
+        n_bins=n_bins,
+        encode=method,
+        strategy=strategy,
+        dtype=np.float32,
+    )
+    return pl.Series(
+        encoder.fit_transform(to_encode.to_numpy().reshape(-1, 1)).flatten()
+    )
+
+
+def encode_boolean(to_encode: pl.Series, threshold: float) -> pl.Series:
+    from sklearn.preprocessing import Binarizer
+
+    encoder = Binarizer(
+        threshold=threshold,
+    )
+    return pl.Series(
+        encoder.fit_transform(to_encode.to_numpy().reshape(-1, 1)).flatten()
+    )
+
+
+def encode_max_abs_scale(to_encode: pl.Series) -> pl.Series:
+    from sklearn.preprocessing import MaxAbsScaler
+
+    encoder = MaxAbsScaler()
+    try:
+        encoded = encoder.fit_transform(
+            np.nan_to_num(to_encode.to_numpy()).reshape(-1, 1)
+        ).flatten()
+    except ValueError:
+        encoded = np.array([])
+
+    return pl.Series(encoded)
+
+
+def encode_standard_scale(
+    to_encode: pl.Series, *, with_mean: bool, with_std: bool
+) -> pl.Series:
+    from sklearn.preprocessing import StandardScaler
+
+    encoder = StandardScaler(
+        with_mean=with_mean,
+        with_std=with_std,
+    )
+    return pl.Series(
+        encoder.fit_transform(to_encode.to_numpy().reshape(-1, 1)).flatten()
+    )
+
+
+def encode_duration(to_encode: pl.Series) -> pl.Series:
+    if to_encode.dtype != pl.Duration:
+        raise ValueError("Invalid arguments, expected a duration series")
+    if to_encode.is_null().all():
+        return pl.zeros(len(to_encode), dtype=pl.Float32, eager=True)
+
+    return to_encode.dt.total_seconds().cast(pl.Float32).fill_null(0.0)
+
+
+def _get_cyclic_encoding(
+    to_encode: pl.Series,
+    period: int,
+) -> tuple[pl.Series, pl.Series]:
+    sine_series = (
+        (2 * math.pi * to_encode / period).sin().alias(f"{to_encode.name}_sine")
+    )
+    cosine_series = (
+        (2 * math.pi * to_encode / period).cos().alias(f"{to_encode.name}_cosine")
+    )
+    return sine_series, cosine_series
+
+
+def encode_datetime(to_encode: pl.Series) -> pl.Series:
+    match to_encode.dtype:
+        case pl.Date | pl.Time:
+            pass
+        case pl.Datetime:
+            to_encode = to_encode.dt.replace_time_zone("UTC")
+        case _:
+            raise ValueError(
+                "Invalid arguments column could not be endoded as datetime"
+            )
+
+    if to_encode.is_null().all():
+        zero_vector = pl.zeros(11, dtype=pl.Float32, eager=True)
+        return pl.Series([zero_vector] * len(to_encode), dtype=pl.List(pl.Float32))
+
+    n = len(to_encode)
+    year_norm = pl.zeros(n, dtype=pl.Float32, eager=True).alias("year")
+    month_sine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("month_sine")
+    month_cosine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("month_cosine")
+    day_sine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("day_sine")
+    day_cosine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("day_cosine")
+    hour_sine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("hour_sine")
+    hour_cosine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("hour_cosine")
+    minute_sine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("minute_sine")
+    minute_cosine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("minute_cosine")
+    second_sine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("second_sine")
+    second_cosine = pl.zeros(n, dtype=pl.Float32, eager=True).alias("second_cosine")
+
+    if to_encode.dtype in [pl.Date, pl.Datetime]:
+        try:
+            year = to_encode.dt.year().cast(pl.Float32).alias("year")
+            month = to_encode.dt.month().cast(pl.Float32).alias("month")
+            day = to_encode.dt.day().cast(pl.Float32).alias("day")
+
+            year_norm = (year - REFERENCE_YEAR) / MAX_NUMBER_OF_YEARS
+            month_sine, month_cosine = _get_cyclic_encoding(month, 12)
+            day_sine, day_cosine = _get_cyclic_encoding(day, 31)
+        except pl.exceptions.PanicException as e:
+            _logger.exception("Error extracting datetime", exc_info=e)
+
+    if to_encode.dtype in [pl.Time, pl.Datetime]:
+        try:
+            hour = to_encode.dt.hour().cast(pl.Float32).alias("hour")
+            minute = to_encode.dt.minute().cast(pl.Float32).alias("minute")
+            second = to_encode.dt.second().cast(pl.Float32).alias("second")
+
+            hour_sine, hour_cosine = _get_cyclic_encoding(hour, 24)
+            minute_sine, minute_cosine = _get_cyclic_encoding(minute, 60)
+            second_sine, second_cosine = _get_cyclic_encoding(second, 60)
+        except pl.exceptions.PanicException as e:
+            _logger.exception("Error extracting datetime", exc_info=e)
+
+    return pl.DataFrame(
+        [
+            year_norm.fill_null(0.0),
+            month_sine.fill_null(0.0),
+            month_cosine.fill_null(0.0),
+            day_sine.fill_null(0.0),
+            day_cosine.fill_null(0.0),
+            hour_sine.fill_null(0.0),
+            hour_cosine.fill_null(0.0),
+            minute_sine.fill_null(0.0),
+            minute_cosine.fill_null(0.0),
+            second_sine.fill_null(0.0),
+            second_cosine.fill_null(0.0),
+        ]
+    ).select(pl.concat_list(pl.all()).alias(to_encode.name))[to_encode.name]

corvic/system/_embedder.py

@@ -1,10 +1,11 @@
+import asyncio
 import dataclasses
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Literal
+from concurrent.futures import ThreadPoolExecutor
+from typing import TYPE_CHECKING, Any, Literal, Protocol
 
 import numpy as np
 import polars as pl
-from typing_extensions import Protocol
 
 from corvic import orm
 from corvic.result import InternalError, InvalidArgumentError, Ok
@@ -43,6 +44,12 @@ class TextEmbedder(Protocol):
         self, context: EmbedTextContext
     ) -> Ok[EmbedTextResult] | InvalidArgumentError | InternalError: ...
 
+    async def aembed(
+        self,
+        context: EmbedTextContext,
+        worker_threads: ThreadPoolExecutor | None = None,
+    ) -> Ok[EmbedTextResult] | InvalidArgumentError | InternalError: ...
+
 
 @dataclasses.dataclass
 class EmbedImageContext:
@@ -69,6 +76,12 @@ class ImageEmbedder(Protocol):
         self, context: EmbedImageContext
     ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError: ...
 
+    async def aembed(
+        self,
+        context: EmbedImageContext,
+        worker_threads: ThreadPoolExecutor | None = None,
+    ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError: ...
+
 
 @dataclasses.dataclass
 class ClipModels:
@@ -142,3 +155,12 @@ class ClipText(TextEmbedder):
                 ),
             )
         )
+
+    async def aembed(
+        self,
+        context: EmbedTextContext,
+        worker_threads: ThreadPoolExecutor | None = None,
+    ) -> Ok[EmbedTextResult] | InvalidArgumentError | InternalError:
+        return await asyncio.get_running_loop().run_in_executor(
+            worker_threads, self.embed, context
+        )