corvic-engine 0.3.0rc43__cp38-abi3-win_amd64.whl → 0.3.0rc45__cp38-abi3-win_amd64.whl

corvic/model/_space.py

@@ -3,15 +3,13 @@
 from __future__ import annotations
 
 import abc
-import copy
-import dataclasses
 import datetime
 import uuid
 from collections.abc import Iterable, Mapping, Sequence
 from typing import Final, Literal, TypeAlias
 
 import pyarrow as pa
-from more_itertools import first
+import sqlalchemy as sa
 from sqlalchemy import orm as sa_orm
 from typing_extensions import Self
 
@@ -24,12 +22,10 @@ from corvic.model._proto_orm_convert import (
     space_orm_to_proto,
     space_proto_to_orm,
 )
-from corvic.model._source import Source
 from corvic.result import InvalidArgumentError, NotFoundError, Ok
 from corvic.table import Table
 from corvic_generated.algorithm.graph.v1 import graph_pb2
 from corvic_generated.embedding.v1 import models_pb2 as embedding_models_pb2
-from corvic_generated.feature.v2 import space_pb2 as feature_space_pb2
 from corvic_generated.model.v1alpha import models_pb2
 from corvic_generated.orm.v1 import space_pb2
 
@@ -72,17 +68,6 @@ class Space(BaseModel[SpaceID, models_pb2.Space, orm.Space]):
     >>> space = Space.node2vec(feature_view, dim=10, walk_length=10, window=10)
     """
 
-    _feature_view: FeatureView | None
-
-    def __init__(
-        self,
-        client: system.Client,
-        proto_self: models_pb2.Space,
-        feature_view: FeatureView | None = None,
-    ):
-        super().__init__(client, proto_self)
-        self._feature_view = feature_view
-
     @classmethod
     def orm_class(cls):
         return orm.Space
@@ -107,43 +92,14 @@ class Space(BaseModel[SpaceID, models_pb2.Space, orm.Space]):
     ) -> Ok[None] | InvalidArgumentError:
         return space_delete_orms(ids, session)
 
-    @property
-    def column_embedding_parameters(
-        self,
-    ) -> embedding_models_pb2.ColumnEmbeddingParameters | None:
-        if self.proto_self.space_parameters.HasField("column_embedding_parameters"):
-            return self.proto_self.space_parameters.column_embedding_parameters
-        return None
-
-    @property
-    def node2vec_parameters(self) -> graph_pb2.Node2VecParameters | None:
-        if self.proto_self.space_parameters.HasField("node2vec_parameters"):
-            return self.proto_self.space_parameters.node2vec_parameters
-        return None
-
-    @property
-    def concat_and_embed_parameters(
-        self,
-    ) -> embedding_models_pb2.ConcatAndEmbedParameters | None:
-        if self.proto_self.space_parameters.HasField("concat_and_embed_parameters"):
-            return self.proto_self.space_parameters.concat_and_embed_parameters
-        return None
-
-    @property
-    def embed_and_concat_parameters(
-        self,
-    ) -> embedding_models_pb2.EmbedAndConcatParameters | None:
-        if self.proto_self.space_parameters.HasField("embed_and_concat_parameters"):
-            return self.proto_self.space_parameters.embed_and_concat_parameters
-        return None
-
-    @property
-    def embed_image_parameters(
-        self,
-    ) -> embedding_models_pb2.EmbedImageParameters | None:
-        if self.proto_self.space_parameters.HasField("embed_image_parameters"):
-            return self.proto_self.space_parameters.embed_image_parameters
-        return None
+    @classmethod
+    def orm_load_options(cls) -> list[sa.LoaderOption]:
+        return [
+            sa_orm.selectinload(orm.Space.feature_view)
+            .selectinload(orm.FeatureView.feature_view_sources)
+            .selectinload(orm.FeatureViewSource.source)
+            .selectinload(orm.Source.pipeline_ref)
+        ]
 
     @property
     def name(self):
@@ -158,46 +114,79 @@ class Space(BaseModel[SpaceID, models_pb2.Space, orm.Space]):
         return self.proto_self.description
 
     @property
-    def parameters(self):
-        return self.proto_self.space_parameters
-
-    @property
-    def feature_view_id(self):
-        return FeatureViewID(self.proto_self.feature_view_id)
+    def feature_view(self) -> FeatureView:
+        return FeatureView.from_proto(self.proto_self.feature_view, self.client)
 
     @property
     def auto_sync(self):
         return self.proto_self.auto_sync
 
-    @property
-    def space_type(self):
-        if self.node2vec_parameters:
-            return feature_space_pb2.SPACE_TYPE_RELATIONAL
-        if self.concat_and_embed_parameters:
-            return feature_space_pb2.SPACE_TYPE_SEMANTIC
-        if self.embed_and_concat_parameters:
-            return feature_space_pb2.SPACE_TYPE_TABULAR
-        if self.embed_image_parameters:
-            return feature_space_pb2.SPACE_TYPE_IMAGE
-        return feature_space_pb2.SPACE_TYPE_UNSPECIFIED
-
     def with_auto_sync(self, *, auto_sync: bool):
         self.proto_self.auto_sync = auto_sync
         return self
 
-    def feature_view(self):
-        if self._feature_view:
-            return Ok(self._feature_view)
-        match FeatureView.load_proto_for(self.feature_view_id, self.client):
-            case Ok(feature_view):
-                return Ok(FeatureView.from_proto(feature_view, self.client))
-            case NotFoundError() as err:
-                return err
-
     @abc.abstractmethod
     def embeddings_tables(self) -> Ok[Mapping[str, Table]] | InvalidArgumentError:
         """Generate per-output-source embeddings tables for this space."""
 
+    @classmethod
+    def create_specific(
+        cls,
+        name: str,
+        description: str,
+        feature_view: FeatureView,
+        parameters: SpecificSpaceParameters,
+        client: system.Client | None = None,
+        room_id: RoomID | None = None,
+        *,
+        auto_sync: bool = False,
+    ) -> Ok[SpecificSpace] | InvalidArgumentError:
+        client = client or feature_view.client
+        room_id = room_id or feature_view.room_id
+        if room_id != feature_view.room_id:
+            return InvalidArgumentError("room id must match feature_view room id")
+        match parameters:
+            case Node2VecParameters():
+                return RelationalSpace.create(
+                    name,
+                    description,
+                    feature_view,
+                    parameters,
+                    client,
+                    room_id,
+                    auto_sync=auto_sync,
+                )
+            case ConcatAndEmbedParameters():
+                return SemanticSpace.create(
+                    name,
+                    description,
+                    feature_view,
+                    parameters,
+                    client,
+                    room_id,
+                    auto_sync=auto_sync,
+                )
+            case EmbedAndConcatParameters():
+                return TabularSpace.create(
+                    name,
+                    description,
+                    feature_view,
+                    parameters,
+                    client,
+                    room_id,
+                    auto_sync=auto_sync,
+                )
+            case EmbedImageParameters():
+                return ImageSpace.create(
+                    name,
+                    description,
+                    feature_view,
+                    parameters,
+                    client,
+                    room_id,
+                    auto_sync=auto_sync,
+                )
+
     @classmethod
     def from_id(
         cls,
@@ -258,46 +247,109 @@ class Space(BaseModel[SpaceID, models_pb2.Space, orm.Space]):
 class UnknownSpace(Space):
     """A space that this version of the code doesn't know what to do with."""
 
+    @classmethod
+    def create(cls, feature_view: FeatureView, client: system.Client | None = None):
+        client = client or feature_view.client
+        return cls(
+            client,
+            models_pb2.Space(
+                feature_view=feature_view.proto_self,
+            ),
+        )
+
     def embeddings_tables(self) -> Ok[Mapping[str, Table]] | InvalidArgumentError:
         """Generate per-ouput-source embeddings tables for this space."""
         return Ok({})
 
 
-@dataclasses.dataclass(frozen=True)
 class Node2VecParameters:
-    dim: int = 10
-    walk_length: int = 10
-    window: int = 10
-    p: float = 1.0
-    q: float = 1.0
-    alpha: float = 0.025
-    min_alpha: float = 0.0001
-    negative: int = 5
-    epochs: int = 10
-
-    def to_proto(self) -> graph_pb2.Node2VecParameters:
-        return graph_pb2.Node2VecParameters(
-            ndim=self.dim,
-            walk_length=self.walk_length,
-            window=self.window,
-            p=self.p,
-            q=self.q,
-            alpha=self.alpha,
-            min_alpha=self.min_alpha,
-            negative=self.negative,
-            epochs=self.epochs,
+    proto_self: Final[graph_pb2.Node2VecParameters]
+
+    def __init__(self, proto_self: graph_pb2.Node2VecParameters):
+        self.proto_self = proto_self
+
+    @classmethod
+    def create(  # noqa: PLR0913
+        cls,
+        dim: int = 10,
+        walk_length: int = 10,
+        window: int = 10,
+        p: float = 1.0,
+        q: float = 1.0,
+        alpha: float = 0.025,
+        min_alpha: float = 0.0001,
+        negative: int = 5,
+        epochs: int = 10,
+    ):
+        return cls(
+            graph_pb2.Node2VecParameters(
+                ndim=dim,
+                walk_length=walk_length,
+                window=window,
+                p=p,
+                q=q,
+                alpha=alpha,
+                min_alpha=min_alpha,
+                negative=negative,
+                epochs=epochs,
+            )
         )
 
+    @property
+    def dim(self) -> int:
+        return self.proto_self.ndim
+
+    @property
+    def walk_length(self) -> int:
+        return self.proto_self.walk_length
+
+    @property
+    def window(self) -> int:
+        return self.proto_self.window
+
+    @property
+    def p(self) -> float:
+        return self.proto_self.p
+
+    @property
+    def q(self) -> float:
+        return self.proto_self.q
+
+    @property
+    def alpha(self) -> float:
+        return self.proto_self.alpha
+
+    @property
+    def min_alpha(self) -> float:
+        return self.proto_self.min_alpha
+
+    @property
+    def negative(self) -> int:
+        return self.proto_self.negative
+
+    @property
+    def epochs(self) -> int:
+        return self.proto_self.epochs
+
 
 class RelationalSpace(Space):
     """Spaces for embeddings that encode relationships."""
 
+    @property
+    def parameters(self) -> Node2VecParameters:
+        return Node2VecParameters(self.proto_self.space_parameters.node2vec_parameters)
+
     @classmethod
     def create(
         cls,
+        name: str,
+        description: str,
         feature_view: FeatureView,
+        parameters: Node2VecParameters,
         client: system.Client | None = None,
         room_id: orm.RoomID | None = None,
+        *,
+        auto_sync: bool = False,
     ) -> Ok[RelationalSpace] | InvalidArgumentError:
         if not feature_view.relationships:
             return InvalidArgumentError(
@@ -310,34 +362,25 @@ class RelationalSpace(Space):
         client = client or feature_view.client
         room_id = room_id or Defaults.get_default_room_id(client)
         proto_self = models_pb2.Space(
-            feature_view_id=str(feature_view.id), room_id=str(room_id)
+            name=name,
+            description=description,
+            auto_sync=auto_sync,
+            feature_view=feature_view.proto_self,
+            room_id=str(room_id),
+            space_parameters=space_pb2.SpaceParameters(
+                node2vec_parameters=parameters.proto_self
+            ),
         )
 
         return Ok(
             RelationalSpace(
                 client,
                 proto_self,
-                feature_view,
             )
         )
 
-    def with_node2vec(self, params: Node2VecParameters):
-        proto_self = copy.deepcopy(self.proto_self)
-        proto_self.space_parameters.CopyFrom(
-            space_pb2.SpaceParameters(node2vec_parameters=params.to_proto())
-        )
-        return RelationalSpace(
-            self.client, proto_self, self.feature_view().unwrap_or_raise()
-        )
-
     def legacy_embeddings_table(self) -> Ok[Table] | InvalidArgumentError:
-        if not self.node2vec_parameters:
-            return InvalidArgumentError("space was not configured")
-        match self.feature_view():
-            case Ok(feature_view):
-                pass
-            case NotFoundError() as err:
-                return InvalidArgumentError.from_(err)
+        feature_view = self.feature_view
 
         def gen_edge_list_tables():
             for edge_table in feature_view.output_edge_tables():
@@ -361,7 +404,7 @@ class RelationalSpace(Space):
 
         return op_graph.op.embed_node2vec_from_edge_lists(
             edge_list_tables=edge_list_tables,
-            params=self.node2vec_parameters,
+            params=self.parameters.proto_self,
         ).map(
             lambda t: Table(
                 self.client,
@@ -377,11 +420,7 @@ class RelationalSpace(Space):
                 return err
             case Ok(embeddings_table):
                 pass
-        match self.feature_view():
-            case Ok(feature_view):
-                pass
-            case NotFoundError() as err:
-                return InvalidArgumentError.from_(err)
+        feature_view = self.feature_view
         id_fields = [
             field
             for field in embeddings_table.schema
@@ -392,8 +431,7 @@ class RelationalSpace(Space):
         dtype_to_id_field = {field.dtype: field.name for field in id_fields[:-1]}
 
         tables: Mapping[str, Table] = {}
-        for source_id in feature_view.output_sources:
-            source = feature_view.source_id_to_feature_view_source[source_id].source
+        for source in feature_view.output_sources:
             primary_key_field = source.table.schema.get_primary_key()
             if primary_key_field is None:
                 return InvalidArgumentError(
@@ -416,7 +454,7 @@ class RelationalSpace(Space):
                     )
                 )
                 .and_then(
-                    lambda t, source_id=source_id: t.add_literal_column(
+                    lambda t, source_id=source.id: t.add_literal_column(
                         "source_id",
                         str(source_id),
                         pa.string(),
@@ -442,126 +480,93 @@ class RelationalSpace(Space):
         )
 
 
-@dataclasses.dataclass
 class ConcatAndEmbedParameters:
-    column_names: list[str]
-    model_name: str
-    tokenizer_name: str
-    expected_vector_length: int
+    proto_self: Final[embedding_models_pb2.ConcatAndEmbedParameters]
 
+    def __init__(self, proto_self: embedding_models_pb2.ConcatAndEmbedParameters):
+        self.proto_self = proto_self
 
-class SemanticSpace(Space):
-    """Spaces for embedding source properties."""
+    @classmethod
+    def create(
+        cls, column_names: Sequence[str], model_name: str, expected_vector_length: int
+    ):
+        return cls(
+            embedding_models_pb2.ConcatAndEmbedParameters(
+                column_names=column_names,
+                model_parameters=embedding_models_pb2.Parameters(
+                    model=name_to_proto_embedding_model.get(
+                        model_name, embedding_models_pb2.MODEL_UNSPECIFIED
+                    ),
+                    ndim=expected_vector_length,
+                ),
+            )
+        )
 
-    _output_sources: list[Source] | None
+    @property
+    def model_name(self) -> str:
+        return embedding_model_proto_to_name[self.proto_self.model_parameters.model]
 
-    def __init__(
-        self,
-        client: system.Client,
-        proto_self: models_pb2.Space,
-        feature_view: FeatureView | None = None,
-        output_sources: list[Source] | None = None,
-    ):
-        super().__init__(client, proto_self, feature_view)
-        self._output_sources = output_sources
-
-    def output_sources(self):
-        if self._output_sources is not None:
-            return Ok(self._output_sources)
-        match self.feature_view():
-            case Ok(feature_view):
-                return Ok(
-                    [
-                        feature_view.source_id_to_feature_view_source[
-                            output_source
-                        ].source
-                        for output_source in feature_view.output_sources
-                    ]
-                )
-            case NotFoundError() as err:
-                return err
+    @property
+    def column_names(self) -> Sequence[str]:
+        return self.proto_self.column_names
 
     @property
-    def expected_coordinate_bitwidth(self) -> Literal[32]:
-        return 32
+    def expected_vector_length(self) -> int:
+        return self.proto_self.model_parameters.ndim
+
+
+class SemanticSpace(Space):
+    """Spaces for embedding source properties."""
 
     @property
-    def tokenizer_name(self) -> Literal[""]:
-        return ""
+    def parameters(self) -> ConcatAndEmbedParameters:
+        return ConcatAndEmbedParameters(
+            self.proto_self.space_parameters.concat_and_embed_parameters
+        )
 
     @property
-    def model_name(self) -> str | None:
-        if self.concat_and_embed_parameters:
-            return embedding_model_proto_to_name[
-                self.concat_and_embed_parameters.model_parameters.model
-            ]
-        return None
+    def expected_coordinate_bitwidth(self) -> Literal[32]:
+        return 32
 
     @classmethod
     def create(
         cls,
+        name: str,
+        description: str,
         feature_view: FeatureView,
+        parameters: ConcatAndEmbedParameters,
         client: system.Client | None = None,
         room_id: orm.RoomID | None = None,
+        *,
+        auto_sync: bool = False,
     ) -> Ok[SemanticSpace] | InvalidArgumentError:
         client = client or feature_view.client
         if len(feature_view.output_sources) == 0:
             return InvalidArgumentError(
                 "feature view must have at least one output source"
             )
-        sources = [
-            feature_view.source_id_to_feature_view_source[output_source].source
-            for output_source in feature_view.output_sources
-        ]
-
         room_id = room_id or Defaults.get_default_room_id(client)
         proto_self = models_pb2.Space(
-            feature_view_id=str(feature_view.id), room_id=str(room_id)
+            name=name,
+            description=description,
+            auto_sync=auto_sync,
+            feature_view=feature_view.proto_self,
+            room_id=str(room_id),
+            space_parameters=space_pb2.SpaceParameters(
+                concat_and_embed_parameters=parameters.proto_self
+            ),
         )
         return Ok(
             SemanticSpace(
                 client,
                 proto_self,
-                feature_view,
-                sources,
             )
         )
 
-    def with_concat_and_embed(self, params: ConcatAndEmbedParameters) -> SemanticSpace:
-        proto_self = copy.deepcopy(self.proto_self)
-        proto_self.space_parameters.CopyFrom(
-            space_pb2.SpaceParameters(
-                concat_and_embed_parameters=embedding_models_pb2.ConcatAndEmbedParameters(
-                    column_names=params.column_names,
-                    model_parameters=embedding_models_pb2.Parameters(
-                        model=name_to_proto_embedding_model.get(
-                            params.model_name, embedding_models_pb2.MODEL_UNSPECIFIED
-                        ),
-                        ndim=params.expected_vector_length,
-                    ),
-                )
-            )
-        )
-        return SemanticSpace(
-            self.client,
-            proto_self,
-            self.feature_view().unwrap_or_raise(),
-            output_sources=self.output_sources().unwrap_or_raise(),
-        )
-
     def embeddings_tables(self) -> Ok[Mapping[str, Table]] | InvalidArgumentError:
-        model_name = self.model_name
-        if not self.concat_and_embed_parameters or model_name is None:
-            return InvalidArgumentError(
-                "space was not configured to produce embeddings"
-            )
-        match self.output_sources():
-            case Ok(output_sources):
-                pass
-            case NotFoundError() as err:
-                return InvalidArgumentError.from_(err)
-
-        params = self.concat_and_embed_parameters
+        params = self.parameters
+        model_name = params.model_name
+        output_sources = self.feature_view.output_sources
         combined_column_tmp_name = f"__concat-{uuid.uuid4()}"
         embedding_column_tmp_name = f"__embed-{uuid.uuid4()}"
 
@@ -590,8 +595,8 @@ class SemanticSpace(Space):
                         combined_column_tmp_name,
                         embedding_column_tmp_name,
                         model_name,
-                        self.tokenizer_name,
-                        params.model_parameters.ndim,
+                        "",
+                        params.expected_vector_length,
                         self.expected_coordinate_bitwidth,
                     )
                 )
@@ -632,99 +637,68 @@ class SemanticSpace(Space):
         return Ok(tables)
 
 
-@dataclasses.dataclass
 class EmbedAndConcatParameters:
-    expected_vector_length: int
+    proto_self: Final[embedding_models_pb2.EmbedAndConcatParameters]
+
+    def __init__(self, proto_self: embedding_models_pb2.EmbedAndConcatParameters):
+        self.proto_self = proto_self
+
+    @classmethod
+    def create(cls, expected_vector_length: int):
+        return cls(
+            embedding_models_pb2.EmbedAndConcatParameters(ndim=expected_vector_length)
+        )
+
+    @property
+    def expected_vector_length(self) -> int:
+        return self.proto_self.ndim
 
 
 class TabularSpace(Space):
     """Spaces for embedding source properties."""
 
-    _output_sources: list[Source] | None
-
-    def __init__(
-        self,
-        client: system.Client,
-        proto_self: models_pb2.Space,
-        feature_view: FeatureView | None = None,
-        output_sources: list[Source] | None = None,
-    ):
-        super().__init__(client, proto_self, feature_view)
-        self._output_sources = output_sources
-
-    def output_sources(self):
-        if self._output_sources is not None:
-            return Ok(self._output_sources)
-        match self.feature_view():
-            case Ok(feature_view):
-                return Ok(
-                    [
-                        feature_view.source_id_to_feature_view_source[
-                            output_source
-                        ].source
-                        for output_source in feature_view.output_sources
-                    ]
-                )
-            case NotFoundError() as err:
-                return err
+    @property
+    def parameters(self) -> EmbedAndConcatParameters:
+        return EmbedAndConcatParameters(
+            self.proto_self.space_parameters.embed_and_concat_parameters
+        )
 
     @classmethod
     def create(
         cls,
+        name: str,
+        description: str,
         feature_view: FeatureView,
+        parameters: EmbedAndConcatParameters,
         client: system.Client | None = None,
         room_id: orm.RoomID | None = None,
+        *,
+        auto_sync: bool = False,
     ) -> Ok[Self] | InvalidArgumentError:
         client = client or feature_view.client
         if len(feature_view.output_sources) == 0:
             return InvalidArgumentError(
                 "feature view must have at least one output source"
             )
-        sources = [
-            feature_view.source_id_to_feature_view_source[output_source].source
-            for output_source in feature_view.output_sources
-        ]
 
         room_id = room_id or Defaults.get_default_room_id(client)
         proto_self = models_pb2.Space(
-            feature_view_id=str(feature_view.id), room_id=str(room_id)
-        )
-        return Ok(
-            cls(
-                client,
-                proto_self,
-                feature_view,
-                sources,
-            )
-        )
-
-    def with_embed_and_concat(self, params: EmbedAndConcatParameters) -> TabularSpace:
-        proto_self = copy.deepcopy(self.proto_self)
-        proto_self.space_parameters.CopyFrom(
-            space_pb2.SpaceParameters(
-                embed_and_concat_parameters=embedding_models_pb2.EmbedAndConcatParameters(
-                    ndim=params.expected_vector_length,
-                )
-            )
-        )
-        return TabularSpace(
-            self.client,
-            proto_self,
-            self.feature_view().unwrap_or_raise(),
-            output_sources=self.output_sources().unwrap_or_raise(),
+            name=name,
+            description=description,
+            auto_sync=auto_sync,
+            feature_view=feature_view.proto_self,
+            room_id=str(room_id),
+            space_parameters=space_pb2.SpaceParameters(
+                embed_and_concat_parameters=parameters.proto_self
+            ),
         )
+        return Ok(cls(client, proto_self))
 
-    def embeddings_tables(self) -> Ok[Mapping[str, Table]] | InvalidArgumentError:  # noqa: C901
-        if not self.embed_and_concat_parameters:
-            return InvalidArgumentError(
-                "space was not configured to produce embeddings"
-            )
-        match self.output_sources():
-            case Ok(output_sources):
-                pass
-            case NotFoundError() as err:
-                return InvalidArgumentError.from_(err)
-        parameters = self.embed_and_concat_parameters
+    def embeddings_tables(  # noqa: C901
+        self,
+    ) -> Ok[Mapping[str, Table]] | InvalidArgumentError:
+        output_sources = self.feature_view.output_sources
+        parameters = self.parameters
 
         tables: Mapping[str, Table] = {}
         first_schema = output_sources[0].table.schema
@@ -783,7 +757,9 @@ class TabularSpace(Space):
             embedding_column_tmp_name = f"__embed-{uuid.uuid4()}"
 
             # Avoid 0 padding for spaces with small numbers of columns
-            target_list_length = min(parameters.ndim, len(embedding_column_tmp_names))
+            target_list_length = min(
+                parameters.expected_vector_length, len(embedding_column_tmp_names)
+            )
 
             def reduce_dimension(
                 op: op_graph.Op,
@@ -856,40 +832,58 @@ class TabularSpace(Space):
         return Ok(tables)
 
 
-@dataclasses.dataclass
 class EmbedImageParameters:
-    column_name: str
-    model_name: str
-    expected_vector_length: int
+    proto_self: Final[embedding_models_pb2.EmbedImageParameters]
+
+    def __init__(self, proto_self: embedding_models_pb2.EmbedImageParameters):
+        self.proto_self = proto_self
+
+    @classmethod
+    def create(
+        cls, column_name: str, model_name: str, expected_vector_length: int
+    ) -> Self:
+        return cls(
+            embedding_models_pb2.EmbedImageParameters(
+                column_name=column_name,
+                model_parameters=embedding_models_pb2.ImageModelParameters(
+                    model=name_to_proto_image_model.get(
+                        model_name,
+                        embedding_models_pb2.IMAGE_MODEL_UNSPECIFIED,
+                    ),
+                    ndim=expected_vector_length,
+                ),
+            )
+        )
+
+    @property
+    def column_name(self) -> str:
+        return self.proto_self.column_name
+
+    @property
+    def model_name(self) -> str:
+        return image_model_proto_to_name[self.proto_self.model_parameters.model]
+
+    @property
+    def model(self) -> embedding_models_pb2.ImageModel:
+        return self.proto_self.model_parameters.model
+
+    @property
+    def expected_vector_length(self) -> int:
+        return self.proto_self.model_parameters.ndim
 
 
 class ImageSpace(Space):
     """Spaces for embedding images."""
 
-    _output_source: Source | None = None
-
-    def __init__(
-        self,
-        client: system.Client,
-        proto_self: models_pb2.Space,
-        feature_view: FeatureView | None = None,
-        output_source: Source | None = None,
-    ):
-        super().__init__(client, proto_self, feature_view)
-        self._output_source = output_source
+    @property
+    def parameters(self) -> EmbedImageParameters:
+        return EmbedImageParameters(
+            self.proto_self.space_parameters.embed_image_parameters
+        )
 
+    @property
     def output_source(self):
-        if self._output_source is not None:
-            return Ok(self._output_source)
-        match self.feature_view():
-            case Ok(feature_view):
-                return Ok(
-                    feature_view.source_id_to_feature_view_source[
-                        first(iter(feature_view.output_sources))
-                    ].source
-                )
-            case NotFoundError() as err:
-                return err
+        return self.feature_view.output_sources[0]
 
     def _sub_orm_objects(self, orm_object: orm.Space) -> Iterable[orm.Base]:
         return []
@@ -898,78 +892,45 @@ class ImageSpace(Space):
     def expected_coordinate_bitwidth(self) -> Literal[32]:
         return 32
 
-    @property
-    def model_name(self) -> str | None:
-        if self.embed_image_parameters:
-            return image_model_proto_to_name[
-                self.embed_image_parameters.model_parameters.model
-            ]
-        return None
-
     @classmethod
     def create(
         cls,
+        name: str,
+        description: str,
         feature_view: FeatureView,
+        parameters: EmbedImageParameters,
         client: system.Client | None = None,
         room_id: orm.RoomID | None = None,
+        *,
+        auto_sync: bool = False,
     ) -> Ok[Self] | InvalidArgumentError:
         client = client or feature_view.client
         if len(feature_view.output_sources) != 1:
             return InvalidArgumentError(
                 "feature view must have exactly one output source"
             )
-        source = feature_view.source_id_to_feature_view_source[
-            first(iter(feature_view.output_sources))
-        ].source
-
         room_id = room_id or Defaults.get_default_room_id(client)
         proto_self = models_pb2.Space(
-            feature_view_id=str(feature_view.id), room_id=str(room_id)
+            name=name,
+            description=description,
+            auto_sync=auto_sync,
+            feature_view=feature_view.proto_self,
+            room_id=str(room_id),
+            space_parameters=space_pb2.SpaceParameters(
+                embed_image_parameters=parameters.proto_self
+            ),
         )
         return Ok(
             cls(
                 client,
                 proto_self,
-                feature_view,
-                source,
             )
         )
 
-    def with_embed_and_image(self, params: EmbedImageParameters) -> ImageSpace:
-        proto_self = copy.deepcopy(self.proto_self)
-        proto_self.space_parameters.CopyFrom(
-            space_pb2.SpaceParameters(
-                embed_image_parameters=embedding_models_pb2.EmbedImageParameters(
-                    column_name=params.column_name,
-                    model_parameters=embedding_models_pb2.ImageModelParameters(
-                        model=name_to_proto_image_model.get(
-                            params.model_name,
-                            embedding_models_pb2.IMAGE_MODEL_UNSPECIFIED,
-                        ),
-                        ndim=params.expected_vector_length,
-                    ),
-                )
-            )
-        )
-        return ImageSpace(
-            self.client,
-            proto_self,
-            self.feature_view().unwrap_or_raise(),
-            output_source=self.output_source().unwrap_or_raise(),
-        )
-
     def embeddings_tables(self) -> Ok[Mapping[str, Table]] | InvalidArgumentError:
-        model_name = self.model_name
-        if not self.embed_image_parameters or model_name is None:
-            return InvalidArgumentError(
-                "space was not configured to produce embeddings"
-            )
-        match self.output_source():
-            case Ok(output_source):
-                pass
-            case NotFoundError() as err:
-                return InvalidArgumentError.from_(err)
-        params = self.embed_image_parameters
+        params = self.parameters
+        model_name = params.model_name
+        output_source = self.output_source
         pk_field = output_source.table.schema.get_primary_key()
         if not pk_field:
             return InvalidArgumentError("output source must have a primary key")
@@ -981,7 +942,7 @@ class ImageSpace(Space):
                 column_name=params.column_name,
                 embedding_column_name=embedding_column_tmp_name,
                 model_name=model_name,
-                expected_vector_length=params.model_parameters.ndim,
+                expected_vector_length=params.expected_vector_length,
                 expected_coordinate_bitwidth=self.expected_coordinate_bitwidth,
             )
             .and_then(
@@ -1006,3 +967,10 @@ class ImageSpace(Space):
 SpecificSpace: TypeAlias = (
     RelationalSpace | SemanticSpace | TabularSpace | ImageSpace | UnknownSpace
 )
+
+SpecificSpaceParameters: TypeAlias = (
+    Node2VecParameters
+    | ConcatAndEmbedParameters
+    | EmbedAndConcatParameters
+    | EmbedImageParameters
+)