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

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

@@ -6,12 +6,11 @@ import abc
 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

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

corvic/system/_image_embedder.py

@@ -1,4 +1,6 @@
+import asyncio
 import dataclasses
+from concurrent.futures import ThreadPoolExecutor
 from io import BytesIO
 from typing import TYPE_CHECKING, Any
 
@@ -51,6 +53,15 @@ class RandomImageEmbedder(ImageEmbedder):
             )
         )
 
+    async def aembed(
+        self,
+        context: EmbedImageContext,
+        worker_threads: ThreadPoolExecutor | None = None,
+    ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError:
+        return await asyncio.get_running_loop().run_in_executor(
+            worker_threads, self.embed, context
+        )
+
 
 def image_from_bytes(
     image: bytes, mode: str = "RGB"
@@ -155,6 +166,15 @@ class Clip(ImageEmbedder):
             )
         )
 
+    async def aembed(
+        self,
+        context: EmbedImageContext,
+        worker_threads: ThreadPoolExecutor | None = None,
+    ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError:
+        return await asyncio.get_running_loop().run_in_executor(
+            worker_threads, self.embed, context
+        )
+
 
 class CombinedImageEmbedder(ImageEmbedder):
     def __init__(self):
@@ -168,6 +188,15 @@ class CombinedImageEmbedder(ImageEmbedder):
             return self._random_embedder.embed(context)
         return self._clip_embedder.embed(context)
 
+    async def aembed(
+        self,
+        context: EmbedImageContext,
+        worker_threads: ThreadPoolExecutor | None = None,
+    ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError:
+        return await asyncio.get_running_loop().run_in_executor(
+            worker_threads, self.embed, context
+        )
+
 
 class IdentityImageEmbedder(ImageEmbedder):
     """A deterministic image embedder.
@@ -251,6 +280,15 @@ class IdentityImageEmbedder(ImageEmbedder):
             )
         )
 
+    async def aembed(
+        self,
+        context: EmbedImageContext,
+        worker_threads: ThreadPoolExecutor | None = None,
+    ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError:
+        return await asyncio.get_running_loop().run_in_executor(
+            worker_threads, self.embed, context
+        )
+
     def preimage(
         self,
         embedding: list[float],

corvic/system/_planner.py

@@ -1,3 +1,4 @@
+from concurrent.futures import ThreadPoolExecutor
 from typing import ClassVar
 
 from more_itertools import flatten
@@ -182,8 +183,10 @@ class ValidateFirstExecutor(OpGraphExecutor):
     def __init__(self, wrapped_executor: OpGraphExecutor):
         self._wrapped_executor = wrapped_executor
 
-    def execute(
-        self, context: ExecutionContext
+    async def execute(
+        self,
+        context: ExecutionContext,
+        worker_threads: ThreadPoolExecutor | None = None,
     ) -> (
         Ok[ExecutionResult]
         | InvalidArgumentError
@@ -201,4 +204,4 @@ class ValidateFirstExecutor(OpGraphExecutor):
                 return InvalidArgumentError(
                     "sql_output_slice_args set but impossible on a given op_graph"
                 )
-        return self._wrapped_executor.execute(context)
+        return await self._wrapped_executor.execute(context, worker_threads)

corvic/system/_text_embedder.py

@@ -1,3 +1,6 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
 import numpy as np
 import polars as pl
 
@@ -40,6 +43,15 @@ class RandomTextEmbedder(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
+        )
+
 
 class IdentityTextEmbedder(TextEmbedder):
     """A deterministic text embedder.
@@ -90,6 +102,15 @@ class IdentityTextEmbedder(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
+        )
+
     def preimage(self, embedding: list[float], *, normalized: bool = False) -> str:
         """Reconstruct the text from a given embedding vector."""
         if normalized: