cognite-toolkit 0.6.97__py3-none-any.whl → 0.7.39__py3-none-any.whl

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/datamodel.py

@@ -34,29 +34,26 @@ from cognite.client.data_classes.capabilities import (
 from cognite.client.data_classes.data_modeling import (
     Container,
     ContainerApply,
-    ContainerApplyList,
     ContainerList,
     DataModel,
     DataModelApply,
-    DataModelApplyList,
     DataModelList,
+    DirectRelation,
     Edge,
     EdgeApply,
-    EdgeApplyList,
     EdgeApplyResultList,
     EdgeList,
+    MappedProperty,
     Node,
     NodeApply,
-    NodeApplyList,
     NodeApplyResultList,
     NodeList,
+    RequiresConstraint,
     Space,
     SpaceApply,
-    SpaceApplyList,
     SpaceList,
     View,
     ViewApply,
-    ViewApplyList,
     ViewList,
 )
 from cognite.client.data_classes.data_modeling.graphql import DMLApplyResult
@@ -74,12 +71,12 @@ from rich.console import Console
 from rich.markup import escape
 from rich.panel import Panel
 
+from cognite_toolkit._cdf_tk import constants
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.graphql_data_models import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.graphql_data_models import (
     GraphQLDataModel,
     GraphQLDataModelList,
     GraphQLDataModelWrite,
-    GraphQLDataModelWriteList,
 )
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING, HAS_DATA_FILTER_LIMIT
 from cognite_toolkit._cdf_tk.cruds._base_cruds import (
@@ -114,14 +111,11 @@ from .auth import GroupAllScopedCRUD
 
 
 @final
-class SpaceCRUD(ResourceContainerCRUD[str, SpaceApply, Space, SpaceApplyList, SpaceList]):
+class SpaceCRUD(ResourceContainerCRUD[str, SpaceApply, Space]):
     item_name = "nodes and edges"
-    folder_name = "data_models"
-    filename_pattern = r"^.*space$"
+    folder_name = "data_modeling"
     resource_cls = Space
     resource_write_cls = SpaceApply
-    list_write_cls = SpaceApplyList
-    list_cls = SpaceList
     kind = "Space"
     yaml_cls = SpaceYAML
     dependencies = frozenset({GroupAllScopedCRUD})
@@ -246,18 +240,26 @@ class SpaceCRUD(ResourceContainerCRUD[str, SpaceApply, Space, SpaceApplyList, Sp
             yield instances.as_ids()
 
 
-class ContainerCRUD(ResourceContainerCRUD[ContainerId, ContainerApply, Container, ContainerApplyList, ContainerList]):
+class ContainerCRUD(ResourceContainerCRUD[ContainerId, ContainerApply, Container]):
     item_name = "nodes and edges"
-    folder_name = "data_models"
-    filename_pattern = r"^.*container$"
+    folder_name = "data_modeling"
     resource_cls = Container
     resource_write_cls = ContainerApply
-    list_cls = ContainerList
-    list_write_cls = ContainerApplyList
     kind = "Container"
     dependencies = frozenset({SpaceCRUD})
     yaml_cls = ContainerYAML
     _doc_url = "Containers/operation/ApplyContainers"
+    sub_folder_name = "containers"
+
+    def __init__(
+        self,
+        client: ToolkitClient,
+        build_dir: Path | None,
+        console: Console | None = None,
+        topological_sort_implements: bool = False,
+    ) -> None:
+        super().__init__(client, build_dir, console)
+        self._container_by_id: dict[ContainerId, Container] = {}
 
     @property
     def display_name(self) -> str:
@@ -314,6 +316,7 @@ class ContainerCRUD(ResourceContainerCRUD[ContainerId, ContainerApply, Container
 
     def dump_resource(self, resource: Container, local: dict[str, Any] | None = None) -> dict[str, Any]:
         dumped = resource.as_write().dump()
+        has_local = local is not None
         local = local or {}
         for key in ["constraints", "indexes"]:
             if not dumped.get(key) and key not in local:
@@ -325,15 +328,16 @@ class ContainerCRUD(ResourceContainerCRUD[ContainerId, ContainerApply, Container
                 continue
             local_prop = local_prop_by_id[prop_id]
             for key, default in [("immutable", False), ("autoIncrement", False), ("nullable", True)]:
-                if cdf_prop.get(key) is default and key not in local_prop:
+                if has_local and cdf_prop.get(key) is default and key not in local_prop:
                     cdf_prop.pop(key, None)
             cdf_type = cdf_prop.get("type", {})
             local_type = local_prop.get("type", {})
             for key, type_default in [("list", False), ("collation", "ucs_basic")]:
-                if cdf_type.get(key) == type_default and key not in local_type:
+                if has_local and cdf_type.get(key) == type_default and key not in local_type:
                     cdf_type.pop(key, None)
-        if "usedFor" not in local:
-            dumped.pop("usedFor", None)
+            if has_local and "usedFor" not in local and dumped.get("usedFor") == "node":
+                # Only drop if set to default by server.
+                dumped.pop("usedFor", None)
         return dumped
 
     def create(self, items: Sequence[ContainerApply]) -> ContainerList:
@@ -425,6 +429,71 @@ class ContainerCRUD(ResourceContainerCRUD[ContainerId, ContainerApply, Container
             ):
                 yield instances.as_ids()
 
+    def _lookup_containers(self, container_ids: Sequence[ContainerId]) -> dict[ContainerId, Container]:
+        ids_to_lookup = [container_id for container_id in container_ids if container_id not in self._container_by_id]
+        if ids_to_lookup:
+            retrieved_containers = self.client.data_modeling.containers.retrieve(ids_to_lookup)
+            for container in retrieved_containers:
+                self._container_by_id[container.as_id()] = container
+        if missing_container_ids := set(container_ids) - set(self._container_by_id.keys()):
+            MediumSeverityWarning(
+                f"Containers {missing_container_ids} not found or you don't have permission to access them."
+            ).print_warning(console=self.console)
+        return {
+            container_id: self._container_by_id[container_id]
+            for container_id in container_ids
+            if container_id in self._container_by_id
+        }
+
+    def _find_direct_container_dependencies(
+        self, container_ids: Sequence[ContainerId]
+    ) -> dict[ContainerId, set[ContainerId]]:
+        containers_by_id = self._lookup_containers(container_ids)
+        container_dependencies: dict[ContainerId, set[ContainerId]] = defaultdict(set)
+        for container_id, container in containers_by_id.items():
+            for constraint in container.constraints.values():
+                if not isinstance(constraint, RequiresConstraint):
+                    continue
+                container_dependencies[container_id].add(constraint.require)
+            for property in container.properties.values():
+                if not isinstance(property.type, DirectRelation) or property.type.container is None:
+                    continue
+                container_dependencies[container_id].add(property.type.container)
+        return container_dependencies
+
+    def _propagate_indirect_container_dependencies(
+        self, container_dependencies_by_id: dict[ContainerId, set[ContainerId]], dependants: Sequence[ContainerId]
+    ) -> dict[ContainerId, set[ContainerId]]:
+        """Propagate indirect container dependencies using a recursive approach.
+
+        Args:
+            container_dependencies_by_id: Mapping of container IDs to their direct dependencies
+            dependants: Chain of dependant containers to propagate dependencies to
+
+        Returns:
+            Updated dictionary mapping each container ID to all its direct and indirect dependencies
+        """
+        current_container_id = dependants[0]
+        dependencies_to_propagate: set[ContainerId] = set()
+        for container_dependency in container_dependencies_by_id[current_container_id]:
+            if container_dependency in container_dependencies_by_id:
+                # If already processed, propagate its dependencies to current container instead of revisiting it
+                dependencies_to_propagate.update(container_dependencies_by_id[container_dependency])
+                continue
+            self._propagate_indirect_container_dependencies(
+                container_dependencies_by_id, [container_dependency, *dependants]
+            )
+        container_dependencies_by_id[current_container_id].update(dependencies_to_propagate)
+        return container_dependencies_by_id
+
+    def _find_direct_and_indirect_container_dependencies(
+        self, container_ids: Sequence[ContainerId]
+    ) -> dict[ContainerId, set[ContainerId]]:
+        container_dependencies_by_id = self._find_direct_container_dependencies(container_ids)
+        for container_id in list(container_dependencies_by_id.keys()):
+            self._propagate_indirect_container_dependencies(container_dependencies_by_id, [container_id])
+        return container_dependencies_by_id
+
     @staticmethod
     def _chunker(seq: Sequence, size: int) -> Iterable[Sequence]:
         return (seq[pos : pos + size] for pos in range(0, len(seq), size))
@@ -434,17 +503,15 @@ class ContainerCRUD(ResourceContainerCRUD[ContainerId, ContainerApply, Container
         return sanitize_filename(f"{id.space}_{id.external_id}")
 
 
-class ViewCRUD(ResourceCRUD[ViewId, ViewApply, View, ViewApplyList, ViewList]):
-    folder_name = "data_models"
-    filename_pattern = r"^.*view$"
+class ViewCRUD(ResourceCRUD[ViewId, ViewApply, View]):
+    folder_name = "data_modeling"
     resource_cls = View
     resource_write_cls = ViewApply
-    list_cls = ViewList
-    list_write_cls = ViewApplyList
     kind = "View"
     dependencies = frozenset({SpaceCRUD, ContainerCRUD})
     yaml_cls = ViewYAML
     _doc_url = "Views/operation/ApplyViews"
+    sub_folder_name = "views"
 
     def __init__(
         self,
@@ -556,7 +623,9 @@ class ViewCRUD(ResourceCRUD[ViewId, ViewApply, View, ViewApplyList, ViewList]):
             # We sort the implements in topological order to ensure that the child view get the order grandparent,
             # parent, such that the parent's source is used.
             try:
-                dumped["implements"] = [view_id.dump() for view_id in self.topological_sort(resource.implements)]
+                dumped["implements"] = [
+                    view_id.dump() for view_id in self.topological_sort_implements(resource.implements)
+                ]
             except ToolkitCycleError as e:
                 warning = MediumSeverityWarning(f"Failed to sort implements for view {resource.as_id()}: {e}")
                 warning.print_warning(console=self.console)
@@ -669,14 +738,51 @@ class ViewCRUD(ResourceCRUD[ViewId, ViewApply, View, ViewApplyList, ViewList]):
                 self._view_by_id[view.as_id()] = view
         return {view_id: self._view_by_id[view_id] for view_id in view_ids if view_id in self._view_by_id}
 
-    def topological_sort(self, view_ids: list[ViewId]) -> list[ViewId]:
+    def get_readonly_properties(self, view_id: ViewId) -> set[str]:
+        """Retrieve the set of read-only properties for a given view."""
+
+        readonly_properties: set[str] = set()
+
+        # Retrieve the view to check its properties
+        view = self._lookup_views([view_id]).get(view_id)
+        if view is None:
+            return readonly_properties
+
+        # Check each property in the view
+        for property_identifier, property in view.properties.items():
+            if isinstance(
+                property, MappedProperty
+            ) and property.container_property_identifier in constants.READONLY_CONTAINER_PROPERTIES.get(
+                property.container, set()
+            ):
+                readonly_properties.add(property_identifier)
+        return readonly_properties
+
+    def _build_view_implements_dependencies(
+        self, view_by_ids: dict[ViewId, View], include: set[ViewId] | None = None
+    ) -> dict[ViewId, set[ViewId]]:
+        """Build a dependency graph based on view implements relationships.
+
+        Args:
+            view_by_ids: Mapping of view IDs to View objects
+            include: Optional set of view IDs to include in the dependencies, if None, all views are included.
+
+        Returns:
+            Dictionary mapping each view ID to the set of view IDs it depends on (implements)
+        """
+        dependencies: dict[ViewId, set[ViewId]] = {}
+        for view_id, view in view_by_ids.items():
+            dependencies[view_id] = set()
+            for implemented_view_id in view.implements or []:
+                if include is None or implemented_view_id in include:
+                    dependencies[view_id].add(implemented_view_id)
+        return dependencies
+
+    def topological_sort_implements(self, view_ids: list[ViewId]) -> list[ViewId]:
         """Sorts the views in topological order based on their implements and through properties."""
         view_by_ids = self._lookup_views(view_ids)
-        parents_by_child: dict[ViewId, set[ViewId]] = {}
-        for child, view in view_by_ids.items():
-            parents_by_child[child] = set()
-            for parent in view.implements or []:
-                parents_by_child[child].add(parent)
+        parents_by_child = self._build_view_implements_dependencies(view_by_ids)
+
         try:
             sorted_views = list(TopologicalSorter(parents_by_child).static_order())
         except CycleError as e:
@@ -686,15 +792,60 @@ class ViewCRUD(ResourceCRUD[ViewId, ViewApply, View, ViewApplyList, ViewList]):
 
         return sorted_views
 
+    def topological_sort_container_constraints(self, view_ids: list[ViewId]) -> list[ViewId]:
+        """Sorts the views in topological order based on their container constraints."""
+
+        view_by_ids = self._lookup_views(view_ids)
+        if missing_view_ids := set(view_ids) - set(view_by_ids.keys()):
+            MediumSeverityWarning(
+                f"Views {missing_view_ids} not found or you don't have permission to access them, skipping dependency check."
+            ).print_warning(console=self.console)
+            return view_ids
+
+        view_to_containers: dict[ViewId, set[ContainerId]] = {}
+        container_to_views: defaultdict[ContainerId, set[ViewId]] = defaultdict(set)
+        for view_id, view in view_by_ids.items():
+            view_to_containers[view_id] = view.referenced_containers()
+            for container_id in view_to_containers[view_id]:
+                container_to_views[container_id].add(view_id)
+
+        container_crud = ContainerCRUD.create_loader(self.client)
+        container_dependencies_by_id = container_crud._find_direct_and_indirect_container_dependencies(
+            list(container_to_views.keys())
+        )
+
+        # First, add view dependencies based on implements relationships
+        view_dependencies = self._build_view_implements_dependencies(view_by_ids, set(view_to_containers.keys()))
+
+        # Then, add view dependencies based on mapped container constraints
+        for view_id, mapped_containers in view_to_containers.items():
+            for container_id in mapped_containers:
+                # Get all containers this container depends on
+                if container_id not in container_dependencies_by_id:
+                    continue
+                for required_container in container_dependencies_by_id[container_id]:
+                    if required_container not in container_to_views:
+                        continue
+                    # If this view already implements the required container, the requirement is self-satisfied
+                    # and we don't need to depend on other views that also implement it (they are peers).
+                    if required_container in mapped_containers:
+                        continue
+                    # This view doesn't implement the required container, so depend on all views that do
+                    view_dependencies[view_id].update(container_to_views[required_container])
+        try:
+            sorted_views = list(TopologicalSorter(view_dependencies).static_order())
+        except CycleError as e:
+            raise ToolkitCycleError(
+                f"Failed to sort views topologically. This likely due to a cycle in implements. {e.args[1]}"
+            )
+        return sorted_views
+
 
 @final
-class DataModelCRUD(ResourceCRUD[DataModelId, DataModelApply, DataModel, DataModelApplyList, DataModelList]):
-    folder_name = "data_models"
-    filename_pattern = r"^.*datamodel$"
+class DataModelCRUD(ResourceCRUD[DataModelId, DataModelApply, DataModel]):
+    folder_name = "data_modeling"
     resource_cls = DataModel
     resource_write_cls = DataModelApply
-    list_cls = DataModelList
-    list_write_cls = DataModelApplyList
     kind = "DataModel"
     dependencies = frozenset({SpaceCRUD, ViewCRUD})
     yaml_cls = DataModelYAML
@@ -771,13 +922,13 @@ class DataModelCRUD(ResourceCRUD[DataModelId, DataModelApply, DataModel, DataMod
             return diff_list_identifiable(local, cdf, get_identifier=dm_identifier)
         return super().diff_list(local, cdf, json_path)
 
-    def create(self, items: DataModelApplyList) -> DataModelList:
+    def create(self, items: Sequence[DataModelApply]) -> DataModelList:
         return self.client.data_modeling.data_models.apply(items)
 
     def retrieve(self, ids: SequenceNotStr[DataModelId]) -> DataModelList:
         return self.client.data_modeling.data_models.retrieve(cast(Sequence, ids))
 
-    def update(self, items: DataModelApplyList) -> DataModelList:
+    def update(self, items: Sequence[DataModelApply]) -> DataModelList:
         updated = self.create(items)
         # There is a bug in the API not raising an exception if view is removed from a data model.
         # So we check here that the update was fixed.
@@ -821,18 +972,16 @@ class DataModelCRUD(ResourceCRUD[DataModelId, DataModelApply, DataModel, DataMod
 
 
 @final
-class NodeCRUD(ResourceContainerCRUD[NodeId, NodeApply, Node, NodeApplyList, NodeList]):
+class NodeCRUD(ResourceContainerCRUD[NodeId, NodeApply, Node]):
     item_name = "nodes"
-    folder_name = "data_models"
-    filename_pattern = r"^.*node$"
+    folder_name = "data_modeling"
     resource_cls = Node
     resource_write_cls = NodeApply
-    list_cls = NodeList
-    list_write_cls = NodeApplyList
     kind = "Node"
     yaml_cls = NodeYAML
     dependencies = frozenset({SpaceCRUD, ViewCRUD, ContainerCRUD})
     _doc_url = "Instances/operation/applyNodeAndEdges"
+    sub_folder_name = "nodes"
 
     def __init__(
         self,
@@ -928,7 +1077,7 @@ class NodeCRUD(ResourceContainerCRUD[NodeId, NodeApply, Node, NodeApplyList, Nod
 
         return dumped
 
-    def create(self, items: NodeApplyList) -> NodeApplyResultList:
+    def create(self, items: Sequence[NodeApply]) -> NodeApplyResultList:
         result = self.client.data_modeling.instances.apply(
             # Note replace should never be relevant as Toolkit always checks whether the node exists before applying.
             nodes=items,
@@ -940,7 +1089,7 @@ class NodeCRUD(ResourceContainerCRUD[NodeId, NodeApply, Node, NodeApplyList, Nod
     def retrieve(self, ids: SequenceNotStr[NodeId]) -> NodeList:
         return self.client.data_modeling.instances.retrieve(nodes=cast(Sequence, ids), sources=self.view_id).nodes
 
-    def update(self, items: NodeApplyList) -> NodeApplyResultList:
+    def update(self, items: Sequence[NodeApply]) -> NodeApplyResultList:
         result = self.client.data_modeling.instances.apply(
             nodes=items, auto_create_direct_relations=True, replace=False
         )
@@ -977,17 +1126,10 @@ class NodeCRUD(ResourceContainerCRUD[NodeId, NodeApply, Node, NodeApplyList, Nod
         return sanitize_filename(f"{id.space}_{id.external_id}")
 
 
-class GraphQLCRUD(
-    ResourceContainerCRUD[
-        DataModelId, GraphQLDataModelWrite, GraphQLDataModel, GraphQLDataModelWriteList, GraphQLDataModelList
-    ]
-):
-    folder_name = "data_models"
-    filename_pattern = r"^.*GraphQLSchema"
+class GraphQLCRUD(ResourceContainerCRUD[DataModelId, GraphQLDataModelWrite, GraphQLDataModel]):
+    folder_name = "data_modeling"
     resource_cls = GraphQLDataModel
     resource_write_cls = GraphQLDataModelWrite
-    list_cls = GraphQLDataModelList
-    list_write_cls = GraphQLDataModelWriteList
     kind = "GraphQLSchema"
     dependencies = frozenset({SpaceCRUD, ContainerCRUD})
     item_name = "views"
@@ -1101,7 +1243,7 @@ class GraphQLCRUD(
             dumped["graphqlFile"] = match.group(3)
         return dumped
 
-    def create(self, items: GraphQLDataModelWriteList) -> list[DMLApplyResult]:
+    def create(self, items: Sequence[GraphQLDataModelWrite]) -> list[DMLApplyResult]:
         creation_order = self._topological_sort(items)
 
         created_list: list[DMLApplyResult] = []
@@ -1132,7 +1274,7 @@ class GraphQLCRUD(
         result = self.client.data_modeling.data_models.retrieve(list(ids), inline_views=False)
         return GraphQLDataModelList([GraphQLDataModel._load(d.dump()) for d in result])
 
-    def update(self, items: GraphQLDataModelWriteList) -> list[DMLApplyResult]:
+    def update(self, items: Sequence[GraphQLDataModelWrite]) -> list[DMLApplyResult]:
         return self.create(items)
 
     def delete(self, ids: SequenceNotStr[DataModelId]) -> int:
@@ -1157,7 +1299,7 @@ class GraphQLCRUD(
     def drop_data(self, ids: SequenceNotStr[DataModelId]) -> int:
         return self.delete(ids)
 
-    def _topological_sort(self, items: GraphQLDataModelWriteList) -> list[GraphQLDataModelWrite]:
+    def _topological_sort(self, items: Sequence[GraphQLDataModelWrite]) -> list[GraphQLDataModelWrite]:
         to_sort = {item.as_id(): item for item in items}
         dependencies: dict[DataModelId, set[DataModelId]] = {}
         for item in items:
@@ -1180,14 +1322,11 @@ class GraphQLCRUD(
 
 
 @final
-class EdgeCRUD(ResourceContainerCRUD[EdgeId, EdgeApply, Edge, EdgeApplyList, EdgeList]):
+class EdgeCRUD(ResourceContainerCRUD[EdgeId, EdgeApply, Edge]):
     item_name = "edges"
-    folder_name = "data_models"
-    filename_pattern = r"^.*edge"
+    folder_name = "data_modeling"
     resource_cls = Edge
     resource_write_cls = EdgeApply
-    list_cls = EdgeList
-    list_write_cls = EdgeApplyList
     kind = "Edge"
     yaml_cls = EdgeYAML
     dependencies = frozenset({SpaceCRUD, ViewCRUD, ContainerCRUD, NodeCRUD})
@@ -1278,7 +1417,7 @@ class EdgeCRUD(ResourceContainerCRUD[EdgeId, EdgeApply, Edge, EdgeApplyList, Edg
 
         return dumped
 
-    def create(self, items: EdgeApplyList) -> EdgeApplyResultList:
+    def create(self, items: Sequence[EdgeApply]) -> EdgeApplyResultList:
         result = self.client.data_modeling.instances.apply(
             edges=items, auto_create_direct_relations=True, replace=False
         )
@@ -1287,7 +1426,7 @@ class EdgeCRUD(ResourceContainerCRUD[EdgeId, EdgeApply, Edge, EdgeApplyList, Edg
     def retrieve(self, ids: SequenceNotStr[EdgeId]) -> EdgeList:
         return self.client.data_modeling.instances.retrieve(nodes=cast(Sequence, ids)).edges
 
-    def update(self, items: EdgeApplyList) -> EdgeApplyResultList:
+    def update(self, items: Sequence[EdgeApply]) -> EdgeApplyResultList:
         result = self.client.data_modeling.instances.apply(
             edges=items, auto_create_direct_relations=False, replace=True
         )

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/extraction_pipeline.py

@@ -30,14 +30,12 @@ from cognite.client.data_classes.capabilities import (
 from cognite.client.data_classes.extractionpipelines import (
     ExtractionPipelineConfigList,
     ExtractionPipelineConfigWrite,
-    ExtractionPipelineConfigWriteList,
     ExtractionPipelineWrite,
-    ExtractionPipelineWriteList,
 )
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase, RawTable
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawDatabase, RawTable
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
@@ -61,15 +59,10 @@ from .raw import RawDatabaseCRUD, RawTableCRUD
 
 
 @final
-class ExtractionPipelineCRUD(
-    ResourceCRUD[str, ExtractionPipelineWrite, ExtractionPipeline, ExtractionPipelineWriteList, ExtractionPipelineList]
-):
+class ExtractionPipelineCRUD(ResourceCRUD[str, ExtractionPipelineWrite, ExtractionPipeline]):
     folder_name = "extraction_pipelines"
-    filename_pattern = r"^(?:(?!\.config).)*$"  # Matches all yaml files except file names who's stem contain *.config.
     resource_cls = ExtractionPipeline
     resource_write_cls = ExtractionPipelineWrite
-    list_cls = ExtractionPipelineList
-    list_write_cls = ExtractionPipelineWriteList
     kind = "ExtractionPipeline"
     dependencies = frozenset({DataSetsCRUD, RawDatabaseCRUD, RawTableCRUD, GroupAllScopedCRUD})
     yaml_cls = ExtractionPipelineYAML
@@ -177,7 +170,7 @@ class ExtractionPipelineCRUD(
     def retrieve(self, ids: SequenceNotStr[str]) -> ExtractionPipelineList:
         return self.client.extraction_pipelines.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: ExtractionPipelineWriteList) -> ExtractionPipelineList:
+    def update(self, items: Sequence[ExtractionPipelineWrite]) -> ExtractionPipelineList:
         # Bug in SDK overload so need the ignore.
         return self.client.extraction_pipelines.update(items, mode="replace")  # type: ignore[call-overload]
 
@@ -218,16 +211,11 @@ class ExtractionPipelineConfigCRUD(
         str,
         ExtractionPipelineConfigWrite,
         ExtractionPipelineConfig,
-        ExtractionPipelineConfigWriteList,
-        ExtractionPipelineConfigList,
     ]
 ):
     folder_name = "extraction_pipelines"
-    filename_pattern = r"^.*config$"
     resource_cls = ExtractionPipelineConfig
     resource_write_cls = ExtractionPipelineConfigWrite
-    list_cls = ExtractionPipelineConfigList
-    list_write_cls = ExtractionPipelineConfigWriteList
     kind = "Config"
     dependencies = frozenset({ExtractionPipelineCRUD})
     _doc_url = "Extraction-Pipelines-Config/operation/createExtPipeConfig"
@@ -347,18 +335,18 @@ class ExtractionPipelineConfigCRUD(
             return diff_list_force_hashable(local, cdf)
         return super().diff_list(local, cdf, json_path)
 
-    def _upsert(self, items: ExtractionPipelineConfigWriteList) -> ExtractionPipelineConfigList:
+    def _upsert(self, items: Sequence[ExtractionPipelineConfigWrite]) -> ExtractionPipelineConfigList:
         upserted = ExtractionPipelineConfigList([])
         for item in items:
             created = self.client.extraction_pipelines.config.create(item)
             upserted.append(created)
         return upserted
 
-    def create(self, items: ExtractionPipelineConfigWriteList) -> ExtractionPipelineConfigList:
+    def create(self, items: Sequence[ExtractionPipelineConfigWrite]) -> ExtractionPipelineConfigList:
         return self._upsert(items)
 
     # configs cannot be updated, instead new revision is created
-    def update(self, items: ExtractionPipelineConfigWriteList) -> ExtractionPipelineConfigList:
+    def update(self, items: Sequence[ExtractionPipelineConfigWrite]) -> ExtractionPipelineConfigList:
         return self._upsert(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> ExtractionPipelineConfigList: