maxframe 0.1.0b4__cp37-cp37m-win_amd64.whl → 1.0.0__cp37-cp37m-win_amd64.whl

maxframe/core/entity/objects.py

@@ -12,63 +12,57 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict
+from typing import Any, Dict, Type
 
-from ...serialization.serializables import FieldTypes, ListField
-from ...utils import skip_na_call
-from .chunks import Chunk, ChunkData
+from ...serialization import load_type
+from ...serialization.serializables import StringField
 from .core import Entity
 from .executable import _ToObjectMixin
 from .tileables import TileableData
 
 
-class ObjectChunkData(ChunkData):
-    # chunk whose data could be any serializable
+class ObjectData(TileableData, _ToObjectMixin):
     __slots__ = ()
     type_name = "Object"
+    # workaround for removed field since v0.1.0b5
+    # todo remove this when all versions below v1.0.0rc1 is eliminated
+    _legacy_deprecated_non_primitives = ["_chunks"]
+    _legacy_new_non_primitives = ["object_class"]
 
-    def __init__(self, op=None, index=None, **kw):
-        super().__init__(_op=op, _index=index, **kw)
-
-    @property
-    def params(self) -> Dict[str, Any]:
-        # params return the properties which useful to rebuild a new chunk
-        return {
-            "index": self.index,
-        }
-
-    @params.setter
-    def params(self, new_params: Dict[str, Any]):
-        params = new_params.copy()
-        params.pop("index", None)  # index not needed to update
-        if params:  # pragma: no cover
-            raise TypeError(f"Unknown params: {list(params)}")
+    object_class = StringField("object_class", default=None)
 
     @classmethod
-    def get_params_from_data(cls, data: Any) -> Dict[str, Any]:
-        return dict()
-
-
-class ObjectChunk(Chunk):
-    __slots__ = ()
-    _allow_data_type_ = (ObjectChunkData,)
-    type_name = "Object"
-
-
-class ObjectData(TileableData, _ToObjectMixin):
-    __slots__ = ()
-    type_name = "Object"
-
-    # optional fields
-    _chunks = ListField(
-        "chunks",
-        FieldTypes.reference(ObjectChunkData),
-        on_serialize=skip_na_call(lambda x: [it.data for it in x]),
-        on_deserialize=skip_na_call(lambda x: [ObjectChunk(it) for it in x]),
-    )
+    def get_entity_class(cls) -> Type["Object"]:
+        if getattr(cls, "_entity_class", None) is not None:
+            return cls._entity_class
+        assert cls.__qualname__[-4:] == "Data"
+        target_class_name = cls.__module__ + "#" + cls.__qualname__[:-4]
+        cls._entity_class = load_type(target_class_name, Object)
+        return cls._entity_class
+
+    def __new__(cls, op=None, nsplits=None, **kw):
+        if cls is ObjectData:
+            obj_cls = kw.get("object_class")
+            if isinstance(obj_cls, str):
+                obj_cls = load_type(obj_cls, (Object, ObjectData))
+            if isinstance(obj_cls, type) and issubclass(obj_cls, Object):
+                obj_cls = obj_cls.get_data_class()
+
+            if obj_cls is not None and cls is not obj_cls:
+                return obj_cls(op=op, nsplits=nsplits, **kw)
+        return super().__new__(cls)
 
     def __init__(self, op=None, nsplits=None, **kw):
+        obj_cls = kw.pop("object_class", None)
+        if isinstance(obj_cls, type):
+            if isinstance(obj_cls, type) and issubclass(obj_cls, Object):
+                obj_cls = obj_cls.get_data_class()
+            kw["object_class"] = obj_cls.__module__ + "#" + obj_cls.__qualname__
+
         super().__init__(_op=op, _nsplits=nsplits, **kw)
+        if self.object_class is None and type(self) is not ObjectData:
+            cls = type(self)
+            self.object_class = cls.__module__ + "#" + cls.__qualname__
 
     def __repr__(self):
         return f"Object <op={type(self.op).__name__}, key={self.key}>"
@@ -76,7 +70,7 @@ class ObjectData(TileableData, _ToObjectMixin):
     @property
     def params(self):
         # params return the properties which useful to rebuild a new tileable object
-        return dict()
+        return dict(object_class=self.object_class)
 
     @params.setter
     def params(self, new_params: Dict[str, Any]):
@@ -95,6 +89,13 @@ class Object(Entity, _ToObjectMixin):
     _allow_data_type_ = (ObjectData,)
     type_name = "Object"
 
+    @classmethod
+    def get_data_class(cls) -> Type[ObjectData]:
+        if getattr(cls, "_data_class", None) is not None:
+            return cls._data_class
+        target_class_name = cls.__module__ + "#" + cls.__qualname__ + "Data"
+        cls._data_class = load_type(target_class_name, ObjectData)
+        return cls._data_class
+
 
 OBJECT_TYPE = (Object, ObjectData)
-OBJECT_CHUNK_TYPE = (ObjectChunk, ObjectChunkData)

maxframe/core/entity/output_types.py

@@ -15,7 +15,6 @@
 import functools
 from enum import Enum
 
-from .fuse import FUSE_CHUNK_TYPE
 from .objects import OBJECT_TYPE
 
 
@@ -77,8 +76,6 @@ def get_output_types(*objs, unknown_as=None):
     for obj in objs:
         if obj is None:
             continue
-        elif isinstance(obj, FUSE_CHUNK_TYPE):
-            obj = obj.chunk
 
         try:
             output_types.append(_get_output_type_by_cls(type(obj)))

maxframe/core/entity/tests/test_objects.py

@@ -0,0 +1,43 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ..objects import Object, ObjectData
+
+
+class TestSubObjectData(ObjectData):
+    __test__ = False
+
+
+class TestSubObject(Object):
+    __test__ = False
+
+
+def test_object_init():
+    assert TestSubObjectData.get_entity_class() is TestSubObject
+
+    obj = ObjectData(
+        object_class=TestSubObjectData.__module__ + "#" + TestSubObjectData.__name__
+    )
+    assert isinstance(obj, TestSubObjectData)
+
+    obj = ObjectData(object_class=TestSubObjectData)
+    assert isinstance(obj, TestSubObjectData)
+
+    obj = ObjectData(
+        object_class=TestSubObject.__module__ + "#" + TestSubObject.__name__
+    )
+    assert isinstance(obj, TestSubObjectData)
+
+    obj = ObjectData(object_class=TestSubObject)
+    assert isinstance(obj, TestSubObjectData)

maxframe/core/entity/tileables.py

@@ -15,17 +15,15 @@
 import builtins
 import itertools
 from operator import attrgetter
-from typing import Callable, List
 from weakref import WeakKeyDictionary, WeakSet
 
 import numpy as np
 
 from ...serialization.serializables import BoolField, FieldTypes, TupleField
-from ...typing_ import OperatorType, TileableType
+from ...typing_ import TileableType
 from ...utils import on_deserialize_shape, on_serialize_nsplits, on_serialize_shape
 from ..base import Base
 from ..mode import enter_mode
-from .chunks import Chunk
 from .core import Entity, EntityData
 from .executable import _ExecutableMixin
 
@@ -34,79 +32,6 @@ class NotSupportTile(Exception):
     pass
 
 
-class OperatorTilesHandler:
-    _handlers = dict()
-
-    @classmethod
-    def _get_op_cls(cls, op: OperatorType):
-        if isinstance(op, type):
-            return op
-        return type(op)
-
-    @classmethod
-    def register(
-        cls, op: OperatorType, tile_handler: Callable[[OperatorType], TileableType]
-    ):
-        cls._handlers[cls._get_op_cls(op)] = tile_handler
-
-    @classmethod
-    def unregister(cls, op: OperatorType):
-        del cls._handlers[cls._get_op_cls(op)]
-
-    @classmethod
-    def get_handler(
-        cls, op: OperatorType
-    ) -> Callable[[OperatorType], List[TileableType]]:
-        op_cls = cls._get_op_cls(op)
-        return cls._handlers.get(op_cls, op_cls.tile)
-
-    @classmethod
-    def _assign_to(
-        cls,
-        tile_after_tensor_datas: List["TileableData"],
-        tile_before_tensor_datas: List["TileableData"],
-    ):
-        assert len(tile_after_tensor_datas) == len(tile_before_tensor_datas)
-
-        for tile_after_tensor_data, tile_before_tensor_data in zip(
-            tile_after_tensor_datas, tile_before_tensor_datas
-        ):
-            if tile_before_tensor_data is None:
-                # garbage collected
-                continue
-            tile_after_tensor_data.copy_to(tile_before_tensor_data)
-            tile_before_tensor_data.op.outputs = tile_before_tensor_datas
-
-    @enter_mode(kernel=True)
-    def dispatch(self, op: OperatorType):
-        op_cls = self._get_op_cls(op)
-        tiled = None
-        cause = None
-
-        if op_cls in self._handlers:
-            tiled = self._handlers[op_cls](op)
-        else:
-            try:
-                tiled = op_cls.tile(op)
-            except NotImplementedError as ex:
-                cause = ex
-                for super_cls in op_cls.__mro__:
-                    if super_cls in self._handlers:
-                        h = self._handlers[op_cls] = self._handlers[super_cls]
-                        tiled = h(op)
-                        break
-
-        if tiled is not None:
-            return tiled if isinstance(tiled, list) else [tiled]
-        else:
-            raise NotImplementedError(f"{type(op)} does not support tile") from cause
-
-
-handler = OperatorTilesHandler()
-register = OperatorTilesHandler.register
-unregister = OperatorTilesHandler.unregister
-
-
 class _ChunksIndexer:
     __slots__ = ("_tileable",)
 
@@ -231,7 +156,7 @@ entity_view_handler = EntityDataModificationHandler()
 
 
 class TileableData(EntityData, _ExecutableMixin):
-    __slots__ = "_cix", "_entities", "_executed_sessions"
+    __slots__ = "_chunks", "_cix", "_entities", "_executed_sessions"
     _no_copy_attrs_ = Base._no_copy_attrs_ | {"_cix"}
 
     # optional fields
@@ -245,6 +170,8 @@ class TileableData(EntityData, _ExecutableMixin):
     cache = BoolField("cache", default=False)
 
     def __init__(self: TileableType, *args, **kwargs):
+        if kwargs.get("chunks") is not None:
+            self._chunks = kwargs.pop("chunks")
         if kwargs.get("_nsplits", None) is not None:
             kwargs["_nsplits"] = tuple(tuple(s) for s in kwargs["_nsplits"])
 
@@ -270,7 +197,7 @@ class TileableData(EntityData, _ExecutableMixin):
             return tuple(map(len, self._nsplits))
 
     @property
-    def chunks(self) -> List[Chunk]:
+    def chunks(self) -> list:
         return getattr(self, "_chunks", None)
 
     @property

maxframe/core/graph/__init__.py

@@ -12,6 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .builder import ChunkGraphBuilder, TileableGraphBuilder, TileContext, TileStatus
+from .builder import TileableGraphBuilder
 from .core import DAG, DirectedGraph, GraphContainsCycleError
-from .entity import ChunkGraph, EntityGraph, GraphSerializer, TileableGraph
+from .entity import EntityGraph, GraphSerializer, TileableGraph

maxframe/core/graph/builder/__init__.py

@@ -12,5 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .chunk import ChunkGraphBuilder, TileContext, TileStatus
 from .tileable import TileableGraphBuilder

maxframe/core/graph/builder/base.py

@@ -14,10 +14,10 @@
 
 
 from abc import ABC, abstractmethod
-from typing import Generator, List, Set, Union
+from typing import Generator, List, Set
 
 from ....typing_ import EntityType
-from ..entity import ChunkGraph, EntityGraph, TileableGraph
+from ..entity import EntityGraph
 
 
 def _default_inputs_selector(inputs: List[EntityType]) -> List[EntityType]:
@@ -43,7 +43,7 @@ class AbstractGraphBuilder(ABC):
 
     def _add_nodes(
         self,
-        graph: Union[ChunkGraph, TileableGraph],
+        graph: EntityGraph,
         nodes: List[EntityType],
         visited: Set,
     ):
@@ -75,7 +75,7 @@ class AbstractGraphBuilder(ABC):
                         nodes.append(out)
 
     @abstractmethod
-    def build(self) -> Generator[Union[EntityGraph, ChunkGraph], None, None]:
+    def build(self) -> Generator[EntityGraph, None, None]:
         """
         Build a entity graph.
 
@@ -84,3 +84,4 @@ class AbstractGraphBuilder(ABC):
         graph : EntityGraph
             Entity graph.
         """
+        raise NotImplementedError

maxframe/core/graph/builder/tileable.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Generator, Union
+from typing import Generator
 
 from ...mode import enter_mode
-from ..entity import ChunkGraph, TileableGraph
+from ..entity import TileableGraph
 from .base import AbstractGraphBuilder
 
 
@@ -26,9 +26,9 @@ class TileableGraphBuilder(AbstractGraphBuilder):
         super().__init__(graph=graph)
 
     @enter_mode(build=True, kernel=True)
-    def _build(self) -> Union[TileableGraph, ChunkGraph]:
+    def _build(self) -> TileableGraph:
         self._add_nodes(self._graph, list(self._graph.result_tileables), set())
         return self._graph
 
-    def build(self) -> Generator[Union[TileableGraph, ChunkGraph], None, None]:
+    def build(self) -> Generator[TileableGraph, None, None]:
         yield self._build()

maxframe/core/graph/builder/utils.py

@@ -13,12 +13,11 @@
 # limitations under the License.
 
 import itertools
-from typing import List, Union
+from typing import List
 
 from ....typing_ import TileableType
 from ...mode import enter_mode
-from ..entity import ChunkGraph, TileableGraph
-from .chunk import ChunkGraphBuilder
+from ..entity import EntityGraph, TileableGraph
 from .tileable import TileableGraphBuilder
 
 
@@ -28,14 +27,11 @@ def build_graph(
     tile: bool = False,
     fuse_enabled: bool = True,
     **chunk_graph_build_kwargs
-) -> Union[TileableGraph, ChunkGraph]:
+) -> EntityGraph:
     tileables = list(itertools.chain(*(tileable.op.outputs for tileable in tileables)))
     tileable_graph = TileableGraph(tileables)
     tileable_graph_builder = TileableGraphBuilder(tileable_graph)
     tileable_graph = next(tileable_graph_builder.build())
     if not tile:
         return tileable_graph
-    chunk_graph_builder = ChunkGraphBuilder(
-        tileable_graph, fuse_enabled=fuse_enabled, **chunk_graph_build_kwargs
-    )
-    return next(chunk_graph_builder.build())
+    raise NotImplementedError

maxframe/core/graph/core.pyx

@@ -354,10 +354,10 @@ cdef class DirectedGraph:
                         sio.write(f'"Chunk:{self._gen_chunk_key(input_chunk, trunc_key)}" {chunk_style}\n')
                         visited.add(input_chunk.key)
                     if op.key not in visited:
-                        sio.write(f'"{op_name}:{op.key[:trunc_key]}" {operator_style}\n')
+                        sio.write(f'"{op_name}:{op.key[:trunc_key]}_{id(op)}" {operator_style}\n')
                         visited.add(op.key)
                     sio.write(f'"Chunk:{self._gen_chunk_key(input_chunk, trunc_key)}" -> '
-                              f'"{op_name}:{op.key[:trunc_key]}"\n')
+                              f'"{op_name}:{op.key[:trunc_key]}_{id(op)}"\n')
 
                 for output_chunk in (op.outputs or []):
                     if output_chunk.key not in visited:
@@ -367,9 +367,9 @@ cdef class DirectedGraph:
                         sio.write(f'"Chunk:{self._gen_chunk_key(output_chunk, trunc_key)}" {tmp_chunk_style}\n')
                         visited.add(output_chunk.key)
                     if op.key not in visited:
-                        sio.write(f'"{op_name}:{op.key[:trunc_key]}" {operator_style}\n')
+                        sio.write(f'"{op_name}:{op.key[:trunc_key]}_{id(op)}" {operator_style}\n')
                         visited.add(op.key)
-                    sio.write(f'"{op_name}:{op.key[:trunc_key]}" -> '
+                    sio.write(f'"{op_name}:{op.key[:trunc_key]}_{id(op)}" -> '
                               f'"Chunk:{self._gen_chunk_key(output_chunk, trunc_key)}"')
                     if show_columns:
                         sio.write(f' [ label={get_col_names(output_chunk)} ]')

maxframe/core/graph/entity.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 
 from abc import ABCMeta, abstractmethod
-from typing import Dict, Iterable, List, Union
+from typing import Dict, Iterable, List
 
-from ...core import Chunk, Tileable
+from ...core import Tileable
 from ...serialization.core import buffered
 from ...serialization.serializables import BoolField, DictField, ListField, Serializable
 from ...serialization.serializables.core import SerializableSerializer
@@ -97,26 +97,6 @@ class TileableGraph(EntityGraph, Iterable[Tileable]):
         return self._logic_key
 
 
-class ChunkGraph(EntityGraph, Iterable[Chunk]):
-    _result_chunks: List[Chunk]
-
-    def __init__(self, result_chunks: List[Chunk] = None):
-        super().__init__()
-        self._result_chunks = result_chunks
-
-    @property
-    def result_chunks(self):
-        return self._result_chunks
-
-    @property
-    def results(self):
-        return self._result_chunks
-
-    @results.setter
-    def results(self, new_results):
-        self._result_chunks = new_results
-
-
 class SerializableGraph(Serializable):
     _is_chunk = BoolField("is_chunk")
     # TODO(qinxuye): remove this logic when we handle fetch elegantly,
@@ -132,12 +112,11 @@ class SerializableGraph(Serializable):
     _results = ListField("results")
 
     @classmethod
-    def from_graph(cls, graph: Union[TileableGraph, ChunkGraph]) -> "SerializableGraph":
+    def from_graph(cls, graph: EntityGraph) -> "SerializableGraph":
         from ..operator import Fetch
 
-        is_chunk = isinstance(graph, ChunkGraph)
         return SerializableGraph(
-            _is_chunk=is_chunk,
+            _is_chunk=False,
             _fetch_nodes=[chunk for chunk in graph if isinstance(chunk.op, Fetch)],
             _nodes=graph._nodes,
             _predecessors=graph._predecessors,
@@ -145,9 +124,8 @@ class SerializableGraph(Serializable):
             _results=graph.results,
         )
 
-    def to_graph(self) -> Union[TileableGraph, ChunkGraph]:
-        graph_cls = ChunkGraph if self._is_chunk else TileableGraph
-        graph = graph_cls(self._results)
+    def to_graph(self) -> EntityGraph:
+        graph = TileableGraph(self._results)
         graph._nodes.update(self._nodes)
         graph._predecessors.update(self._predecessors)
         graph._successors.update(self._successors)
@@ -156,14 +134,12 @@ class SerializableGraph(Serializable):
 
 class GraphSerializer(SerializableSerializer):
     @buffered
-    def serial(self, obj: Union[TileableGraph, ChunkGraph], context: Dict):
+    def serial(self, obj: EntityGraph, context: Dict):
         serializable_graph = SerializableGraph.from_graph(obj)
         return [], [serializable_graph], False
 
-    def deserial(
-        self, serialized: List, context: Dict, subs: List
-    ) -> Union[TileableGraph, ChunkGraph]:
-        serializable_graph: SerializableGraph = subs[0]
+    def deserial(self, serialized: List, context: Dict, subs: List) -> TileableGraph:
+        serializable_graph: EntityGraph = subs[0]
         return serializable_graph.to_graph()
 
 

maxframe/core/operator/__init__.py

@@ -22,13 +22,6 @@ from .base import (
 )
 from .core import TileableOperatorMixin, estimate_size, execute
 from .fetch import Fetch, FetchMixin, FetchShuffle, ShuffleFetchType
-from .fuse import Fuse, FuseChunkMixin
-from .objects import (
-    MergeDictOperator,
-    ObjectFetch,
-    ObjectFuseChunk,
-    ObjectFuseChunkMixin,
-    ObjectOperator,
-    ObjectOperatorMixin,
-)
+from .objects import MergeDictOperator, ObjectFetch, ObjectOperator, ObjectOperatorMixin
 from .shuffle import MapReduceOperator, ShuffleProxy
+from .utils import add_fetch_builder, build_fetch

maxframe/core/operator/base.py

@@ -12,11 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import functools
 import weakref
 from copy import deepcopy
 from enum import Enum
-from functools import partial
+from functools import lru_cache, partial
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
 from ...serialization.core import Placeholder
@@ -37,7 +36,6 @@ from ...serialization.serializables.core import SerializableSerializer
 from ...typing_ import OperatorType
 from ...utils import AttributeDict, classproperty, get_user_call_point, tokenize
 from ..base import Base
-from ..entity.chunks import Chunk
 from ..entity.core import ENTITY_TYPE, Entity, EntityData
 from ..entity.output_types import OutputType
 from ..entity.tileables import Tileable
@@ -90,7 +88,7 @@ class SchedulingHint(Serializable):
     priority = Int32Field("priority", default=None)
 
     @classproperty
-    @functools.lru_cache(1)
+    @lru_cache(1)
     def all_hint_names(cls):
         return list(cls._FIELDS)
 
@@ -341,7 +339,7 @@ class Operator(Base, OperatorLogicKeyGeneratorMixin, metaclass=OperatorMetaclass
             raise ValueError("Outputs' size exceeds limitation")
 
     @property
-    def outputs(self) -> List[Union[Chunk, Tileable]]:
+    def outputs(self) -> List[Tileable]:
         outputs = self._outputs
         if outputs:
             return [ref() for ref in outputs]

maxframe/core/operator/objects.py

@@ -17,7 +17,6 @@ from ..entity import OutputType, register_fetch_class
 from .base import Operator
 from .core import TileableOperatorMixin
 from .fetch import Fetch, FetchMixin
-from .fuse import Fuse, FuseChunkMixin
 
 
 class ObjectOperator(Operator):
@@ -28,14 +27,6 @@ class ObjectOperatorMixin(TileableOperatorMixin):
     _output_type_ = OutputType.object
 
 
-class ObjectFuseChunkMixin(FuseChunkMixin, ObjectOperatorMixin):
-    __slots__ = ()
-
-
-class ObjectFuseChunk(ObjectFuseChunkMixin, Fuse):
-    pass
-
-
 class ObjectFetch(FetchMixin, ObjectOperatorMixin, Fetch):
     _output_type_ = OutputType.object
 

maxframe/core/operator/utils.py

@@ -0,0 +1,55 @@
+# Copyright 1999-2024 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ...typing_ import EntityType, TileableType
+from ..entity import TILEABLE_TYPE
+
+
+def build_fetch_tileable(tileable: TileableType) -> TileableType:
+    if tileable.is_coarse():
+        chunks = None
+    else:
+        chunks = []
+        for c in tileable.chunks:
+            fetch_chunk = build_fetch(c, index=c.index)
+            chunks.append(fetch_chunk)
+
+    tileable_op = tileable.op
+    params = tileable.params.copy()
+
+    new_op = tileable_op.get_fetch_op_cls(tileable)(_id=tileable_op.id)
+    return new_op.new_tileables(
+        None,
+        chunks=chunks,
+        nsplits=tileable.nsplits,
+        _key=tileable.key,
+        _id=tileable.id,
+        **params,
+    )[0]
+
+
+_type_to_builder = [
+    (TILEABLE_TYPE, build_fetch_tileable),
+]
+
+
+def build_fetch(entity: EntityType, **kw) -> EntityType:
+    for entity_types, func in _type_to_builder:
+        if isinstance(entity, entity_types):
+            return func(entity, **kw)
+    raise TypeError(f"Type {type(entity)} not supported")
+
+
+def add_fetch_builder(entity_type, builder_func):
+    _type_to_builder.append((entity_type, builder_func))