gooddata-pipelines 1.49.1.dev1__py3-none-any.whl → 1.50.0__py3-none-any.whl

gooddata_pipelines/provisioning/entities/users/models/permissions.py

@@ -1,7 +1,7 @@
 # (C) 2025 GoodData Corporation
-from abc import abstractmethod
+
 from enum import Enum
-from typing import Any, Iterator, TypeAlias, TypeVar
+from typing import Iterator, TypeAlias
 
 import attrs
 from gooddata_sdk.catalog.identifier import CatalogAssigneeIdentifier
@@ -14,85 +14,29 @@ from pydantic import BaseModel
 from gooddata_pipelines.provisioning.utils.exceptions import BaseUserException
 
 TargetsPermissionDict: TypeAlias = dict[str, dict[str, bool]]
-ConstructorType = TypeVar("ConstructorType", bound="ConstructorMixin")
 
 
-class PermissionType(str, Enum):
+class EntityType(str, Enum):
     # NOTE: Start using StrEnum with Python 3.11
     user = "user"
     user_group = "userGroup"
 
 
-class ConstructorMixin:
-    @staticmethod
-    def _get_id_and_type(
-        permission: dict[str, Any],
-    ) -> tuple[str, PermissionType]:
-        user_id: str | None = permission.get("user_id")
-        user_group_id: str | None = permission.get("ug_id")
-        if user_id and user_group_id:
-            raise ValueError("Only one of user_id or ug_id must be present")
-        elif user_id:
-            return user_id, PermissionType.user
-        elif user_group_id:
-            return user_group_id, PermissionType.user_group
-        else:
-            raise ValueError("Either user_id or ug_id must be present")
-
-    @classmethod
-    def from_list_of_dicts(
-        cls: type[ConstructorType], data: list[dict[str, Any]]
-    ) -> list[ConstructorType]:
-        """Creates a list of instances from list of dicts."""
-        # NOTE: We can use typing.Self for the return type in Python 3.11
-        permissions = []
-        for permission in data:
-            permissions.append(cls.from_dict(permission))
-        return permissions
-
-    @classmethod
-    @abstractmethod
-    def from_dict(cls, data: dict[str, Any]) -> Any:
-        """Construction form a dictionary to be implemented by subclasses."""
-        pass
-
-
-class PermissionIncrementalLoad(BaseModel, ConstructorMixin):
+class BasePermission(BaseModel):
     permission: str
     workspace_id: str
-    id_: str
-    type_: PermissionType
-    is_active: bool
+    entity_id: str
+    entity_type: EntityType
 
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "PermissionIncrementalLoad":
-        """Returns an instance of PermissionIncrementalLoad from a dictionary."""
-        id_, target_type = cls._get_id_and_type(data)
-        return cls(
-            permission=data["ws_permissions"],
-            workspace_id=data["ws_id"],
-            id_=id_,
-            type_=target_type,
-            is_active=data["is_active"],
-        )
 
+class PermissionFullLoad(BasePermission):
+    """Input validator for full load of workspace permissions provisioning."""
 
-class PermissionFullLoad(BaseModel, ConstructorMixin):
-    permission: str
-    workspace_id: str
-    id_: str
-    type_: PermissionType
 
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "PermissionFullLoad":
-        """Returns an instance of PermissionFullLoad from a dictionary."""
-        id_, target_type = cls._get_id_and_type(data)
-        return cls(
-            permission=data["ws_permissions"],
-            workspace_id=data["ws_id"],
-            id_=id_,
-            type_=target_type,
-        )
+class PermissionIncrementalLoad(BasePermission):
+    """Input validator for incremental load of workspace permissions provisioning."""
+
+    is_active: bool
 
 
 @attrs.define
@@ -117,7 +61,7 @@ class PermissionDeclaration:
                 permission.assignee.id,
             )
 
-            if permission_type == PermissionType.user.value:
+            if permission_type == EntityType.user.value:
                 target_dict = users
             else:
                 target_dict = user_groups
@@ -170,7 +114,7 @@ class PermissionDeclaration:
 
         for user_id, permissions in self.users.items():
             assignee = CatalogAssigneeIdentifier(
-                id=user_id, type=PermissionType.user.value
+                id=user_id, type=EntityType.user.value
             )
             for declaration in self._permissions_for_target(
                 permissions, assignee
@@ -179,7 +123,7 @@ class PermissionDeclaration:
 
         for ug_id, permissions in self.user_groups.items():
             assignee = CatalogAssigneeIdentifier(
-                id=ug_id, type=PermissionType.user_group.value
+                id=ug_id, type=EntityType.user_group.value
             )
             for declaration in self._permissions_for_target(
                 permissions, assignee
@@ -200,15 +144,15 @@ class PermissionDeclaration:
         """
         target_dict = (
             self.users
-            if permission.type_ == PermissionType.user
+            if permission.entity_type == EntityType.user
             else self.user_groups
         )
 
-        if permission.id_ not in target_dict:
-            target_dict[permission.id_] = {}
+        if permission.entity_id not in target_dict:
+            target_dict[permission.entity_id] = {}
 
         is_active = permission.is_active
-        target_permissions = target_dict[permission.id_]
+        target_permissions = target_dict[permission.entity_id]
         permission_value = permission.permission
 
         if permission_value not in target_permissions:
@@ -233,14 +177,14 @@ class PermissionDeclaration:
         """
         target_dict = (
             self.users
-            if permission.type_ == PermissionType.user
+            if permission.entity_type == EntityType.user
             else self.user_groups
         )
 
-        if permission.id_ not in target_dict:
-            target_dict[permission.id_] = {}
+        if permission.entity_id not in target_dict:
+            target_dict[permission.entity_id] = {}
 
-        target_permissions = target_dict[permission.id_]
+        target_permissions = target_dict[permission.entity_id]
         permission_value = permission.permission
 
         if permission_value not in target_permissions:

gooddata_pipelines/provisioning/entities/users/models/user_groups.py

@@ -1,64 +1,37 @@
 # (C) 2025 GoodData Corporation
 
-from typing import Any
+from pydantic import BaseModel, Field, ValidationInfo, field_validator
 
-from pydantic import BaseModel
 
-from gooddata_pipelines.provisioning.utils.utils import SplitMixin
-
-
-class BaseUserGroup(BaseModel, SplitMixin):
+class UserGroupBase(BaseModel):
     user_group_id: str
     user_group_name: str
-    parent_user_groups: list[str]
+    parent_user_groups: list[str] = Field(default_factory=list)
 
+    @field_validator("user_group_name", mode="before")
     @classmethod
-    def _create_from_dict_data(
-        cls, user_group_data: dict[str, Any], delimiter: str = ","
-    ) -> dict[str, Any]:
-        """Helper method to extract common data from dict."""
-        parent_user_groups = cls.split(
-            user_group_data["parent_user_groups"], delimiter=delimiter
-        )
-        user_group_name = user_group_data["user_group_name"]
-        if not user_group_name:
-            user_group_name = user_group_data["user_group_id"]
-
-        return {
-            "user_group_id": user_group_data["user_group_id"],
-            "user_group_name": user_group_name,
-            "parent_user_groups": parent_user_groups,
-        }
-
-
-class UserGroupIncrementalLoad(BaseUserGroup):
-    is_active: bool
-
+    def validate_user_group_name(
+        cls, v: str | None, info: ValidationInfo
+    ) -> str:
+        """If user_group_name is None or empty, default to user_group_id."""
+        if not v:  # handles None and empty string
+            return info.data.get("user_group_id", "")
+        return v
+
+    @field_validator("parent_user_groups", mode="before")
     @classmethod
-    def from_list_of_dicts(
-        cls, data: list[dict[str, Any]], delimiter: str = ","
-    ) -> list["UserGroupIncrementalLoad"]:
-        """Creates a list of User objects from list of dicts."""
-        user_groups = []
-        for user_group in data:
-            base_data = cls._create_from_dict_data(user_group, delimiter)
-            base_data["is_active"] = user_group["is_active"]
+    def validate_parent_user_groups(cls, v: list[str] | None) -> list[str]:
+        """If parent_user_groups is None or empty, default to empty list."""
+        if not v:
+            return []
+        return v
 
-            user_groups.append(UserGroupIncrementalLoad(**base_data))
 
-        return user_groups
+class UserGroupFullLoad(UserGroupBase):
+    """Input validator for full load of user group provisioning."""
 
 
-class UserGroupFullLoad(BaseUserGroup):
-    @classmethod
-    def from_list_of_dicts(
-        cls, data: list[dict[str, Any]], delimiter: str = ","
-    ) -> list["UserGroupFullLoad"]:
-        """Creates a list of User objects from list of dicts."""
-        user_groups = []
-        for user_group in data:
-            base_data = cls._create_from_dict_data(user_group, delimiter)
+class UserGroupIncrementalLoad(UserGroupBase):
+    """Input validator for incremental load of user group provisioning."""
 
-            user_groups.append(UserGroupFullLoad(**base_data))
-
-        return user_groups
+    is_active: bool

gooddata_pipelines/provisioning/entities/users/models/users.py

@@ -5,10 +5,8 @@ from typing import Any
 from gooddata_sdk.catalog.user.entity_model.user import CatalogUser
 from pydantic import BaseModel
 
-from gooddata_pipelines.provisioning.utils.utils import SplitMixin
 
-
-class BaseUser(BaseModel, SplitMixin):
+class BaseUser(BaseModel):
     """Base class containing shared user fields and functionality."""
 
     user_id: str
@@ -18,21 +16,6 @@ class BaseUser(BaseModel, SplitMixin):
     auth_id: str | None
     user_groups: list[str]
 
-    @classmethod
-    def _create_from_dict_data(
-        cls, user_data: dict[str, Any], delimiter: str = ","
-    ) -> dict[str, Any]:
-        """Helper method to extract common data from dict."""
-        user_groups = cls.split(user_data["user_groups"], delimiter=delimiter)
-        return {
-            "user_id": user_data["user_id"],
-            "firstname": user_data["firstname"],
-            "lastname": user_data["lastname"],
-            "email": user_data["email"],
-            "auth_id": user_data["auth_id"],
-            "user_groups": user_groups,
-        }
-
     @classmethod
     def _create_from_sdk_data(cls, obj: CatalogUser) -> dict[str, Any]:
         """Helper method to extract common data from SDK object."""
@@ -68,47 +51,24 @@ class BaseUser(BaseModel, SplitMixin):
         )
 
 
-class UserIncrementalLoad(BaseUser):
-    """User model for incremental load operations with active status tracking."""
-
-    is_active: bool
-
-    @classmethod
-    def from_list_of_dicts(
-        cls, data: list[dict[str, Any]], delimiter: str = ","
-    ) -> list["UserIncrementalLoad"]:
-        """Creates a list of User objects from list of dicts."""
-        converted_users = []
-        for user in data:
-            base_data = cls._create_from_dict_data(user, delimiter)
-            base_data["is_active"] = user["is_active"]
-            converted_users.append(cls(**base_data))
-        return converted_users
+class UserFullLoad(BaseUser):
+    """Input validator for full load of user provisioning."""
 
     @classmethod
-    def from_sdk_obj(cls, obj: CatalogUser) -> "UserIncrementalLoad":
+    def from_sdk_obj(cls, obj: CatalogUser) -> "UserFullLoad":
         """Creates GDUserTarget from CatalogUser SDK object."""
         base_data = cls._create_from_sdk_data(obj)
-        base_data["is_active"] = True
         return cls(**base_data)
 
 
-class UserFullLoad(BaseUser):
-    """User model for full load operations."""
+class UserIncrementalLoad(BaseUser):
+    """Input validator for incremental load of user provisioning."""
 
-    @classmethod
-    def from_list_of_dicts(
-        cls, data: list[dict[str, Any]], delimiter: str = ","
-    ) -> list["UserFullLoad"]:
-        """Creates a list of User objects from list of dicts."""
-        converted_users = []
-        for user in data:
-            base_data = cls._create_from_dict_data(user, delimiter)
-            converted_users.append(cls(**base_data))
-        return converted_users
+    is_active: bool
 
     @classmethod
-    def from_sdk_obj(cls, obj: CatalogUser) -> "UserFullLoad":
+    def from_sdk_obj(cls, obj: CatalogUser) -> "UserIncrementalLoad":
         """Creates GDUserTarget from CatalogUser SDK object."""
         base_data = cls._create_from_sdk_data(obj)
+        base_data["is_active"] = True
         return cls(**base_data)

gooddata_pipelines/provisioning/entities/users/permissions.py

@@ -6,10 +6,10 @@ from typing import TypeVar
 
 from gooddata_pipelines.api.exceptions import GoodDataApiException
 from gooddata_pipelines.provisioning.entities.users.models.permissions import (
+    EntityType,
     PermissionDeclaration,
     PermissionFullLoad,
     PermissionIncrementalLoad,
-    PermissionType,
     TargetsPermissionDict,
     WSPermissionsDeclarations,
 )
@@ -28,12 +28,18 @@ class PermissionProvisioner(
     """Provisioning class for user permissions in GoodData workspaces.
 
     This class handles the provisioning of user permissions based on the provided
-    source data.
+    source data. Use the `full_load` or `incremental_load`
+    methods to run the provisioning.
     """
 
     source_group_incremental: list[PermissionIncrementalLoad]
     source_group_full: list[PermissionFullLoad]
 
+    FULL_LOAD_TYPE: type[PermissionFullLoad] = PermissionFullLoad
+    INCREMENTAL_LOAD_TYPE: type[PermissionIncrementalLoad] = (
+        PermissionIncrementalLoad
+    )
+
     def _get_ws_declaration(self, ws_id: str) -> PermissionDeclaration:
         users: TargetsPermissionDict = {}
         user_groups: TargetsPermissionDict = {}
@@ -47,7 +53,7 @@ class PermissionProvisioner(
             )
             target_dict = (
                 users
-                if permission_type == PermissionType.user.value
+                if permission_type == EntityType.user.value
                 else user_groups
             )
 
@@ -105,11 +111,13 @@ class PermissionProvisioner(
         self, permission: PermissionFullLoad | PermissionIncrementalLoad
     ) -> None:
         """Validates if the permission is correctly defined."""
-        if permission.type_ == PermissionType.user:
-            self._api.get_user(permission.id_, error_message="User not found")
+        if permission.entity_type == EntityType.user:
+            self._api.get_user(
+                permission.entity_id, error_message="User not found"
+            )
         else:
             self._api.get_user_group(
-                permission.id_, error_message="User group not found"
+                permission.entity_id, error_message="User group not found"
             )
 
         self._api.get_workspace(

gooddata_pipelines/provisioning/entities/users/user_groups.py

@@ -21,13 +21,19 @@ class UserGroupProvisioner(
     """Provisioning class for user groups in GoodData workspaces.
 
     This class handles the creation, update, and deletion of user groups
-    based on the provided source data.
+    based on the provided source data. Use the `full_load` or `incremental_load`
+    methods to run the provisioning.
     """
 
     source_group_incremental: list[UserGroupIncrementalLoad]
     source_group_full: list[UserGroupFullLoad]
     upstream_user_groups: list[CatalogUserGroup]
 
+    FULL_LOAD_TYPE: type[UserGroupFullLoad] = UserGroupFullLoad
+    INCREMENTAL_LOAD_TYPE: type[UserGroupIncrementalLoad] = (
+        UserGroupIncrementalLoad
+    )
+
     @staticmethod
     def _is_changed(
         group: UserGroupModel, existing_group: CatalogUserGroup

gooddata_pipelines/provisioning/entities/users/users.py

@@ -30,6 +30,9 @@ class UserProvisioner(Provisioning[UserFullLoad, UserIncrementalLoad]):
     source_group_incremental: list[UserIncrementalLoad]
     source_group_full: list[UserFullLoad]
 
+    FULL_LOAD_TYPE: type[UserFullLoad] = UserFullLoad
+    INCREMENTAL_LOAD_TYPE: type[UserIncrementalLoad] = UserIncrementalLoad
+
     def __init__(self, host: str, token: str) -> None:
         super().__init__(host, token)
         self.upstream_user_cache: dict[UserId, UserModel] = {}

gooddata_pipelines/provisioning/entities/workspaces/models.py

@@ -1,29 +1,27 @@
 # (C) 2025 GoodData Corporation
 """Module containing models related to workspace provisioning in GoodData Cloud."""
 
-from dataclasses import dataclass, field
 from typing import Literal
 
+import attrs
 from pydantic import BaseModel, ConfigDict
 
 
-@dataclass
+@attrs.define
 class WorkspaceDataMaps:
     """Dataclass to hold various mappings related to workspace data."""
 
-    child_to_parent_id_map: dict[str, str] = field(default_factory=dict)
-    workspace_id_to_wdf_map: dict[str, dict[str, list[str]]] = field(
-        default_factory=dict
+    child_to_parent_id_map: dict[str, str] = attrs.field(factory=dict)
+    workspace_id_to_wdf_map: dict[str, dict[str, list[str]]] = attrs.field(
+        factory=dict
     )
-    parent_ids: set[str] = field(default_factory=set)
-    source_ids: set[str] = field(default_factory=set)
-    workspace_id_to_name_map: dict[str, str] = field(default_factory=dict)
-    upstream_ids: set[str] = field(default_factory=set)
+    parent_ids: set[str] = attrs.field(factory=set)
+    source_ids: set[str] = attrs.field(factory=set)
+    workspace_id_to_name_map: dict[str, str] = attrs.field(factory=dict)
+    upstream_ids: set[str] = attrs.field(factory=set)
 
 
-class WorkspaceFullLoad(BaseModel):
-    """Model representing input for provisioning of workspaces in GoodData Cloud."""
-
+class WorkspaceBase(BaseModel):
     model_config = ConfigDict(coerce_numbers_to_str=True)
 
     parent_id: str
@@ -33,10 +31,13 @@ class WorkspaceFullLoad(BaseModel):
     workspace_data_filter_values: list[str] | None = None
 
 
-class WorkspaceIncrementalLoad(WorkspaceFullLoad):
-    """Model representing input for incremental provisioning of workspaces in GoodData Cloud."""
+class WorkspaceFullLoad(WorkspaceBase):
+    """Input validator for full load of workspace provisioning."""
+
+
+class WorkspaceIncrementalLoad(WorkspaceBase):
+    """Input validator for incremental load of workspace provisioning."""
 
-    # TODO: double check that the model loads the data correctly, write a test
     is_active: bool
 
 

gooddata_pipelines/provisioning/entities/workspaces/workspace.py

@@ -35,11 +35,19 @@ class WorkspaceProvisioner(
     source_group_full: list[WorkspaceFullLoad]
     source_group_incremental: list[WorkspaceIncrementalLoad]
 
+    FULL_LOAD_TYPE: type[WorkspaceFullLoad] = WorkspaceFullLoad
+    INCREMENTAL_LOAD_TYPE: type[WorkspaceIncrementalLoad] = (
+        WorkspaceIncrementalLoad
+    )
+
+    upstream_group: list[CatalogWorkspace]
+
     def __init__(self, *args: str, **kwargs: str) -> None:
         """Creates an instance of the WorkspaceProvisioner.
 
         Calls the superclass constructor and initializes the validator, parser,
-        and maps for workspace data.
+        and maps for workspace data. Use the `full_load` or `incremental_load`
+        methods to run the provisioning.
         """
         super().__init__(*args, **kwargs)
         self.validator: WorkspaceDataValidator = WorkspaceDataValidator(
@@ -91,10 +99,11 @@ class WorkspaceProvisioner(
         workspace_ids_to_update: set[str],
         child_to_parent_map: dict[str, str],
         workspace_id_to_wdf_map: dict[str, dict[str, list[str]]],
+        source_group: list[WorkspaceFullLoad] | list[WorkspaceIncrementalLoad],
     ) -> None:
         action: Literal["CREATE", "UPDATE"]
 
-        for source_workspace in self.source_group_full:
+        for source_workspace in source_group:
             if source_workspace.workspace_id in workspace_ids_to_update:
                 action = "UPDATE"
             elif source_workspace.workspace_id in workspace_ids_to_create:
@@ -199,8 +208,8 @@ class WorkspaceProvisioner(
         )
 
         # Get upstream children of all parent workspaces.
-        self.upstream_group: list[CatalogWorkspace] = (
-            self._api.get_panther_children_workspaces(self.maps.parent_ids)
+        self.upstream_group = self._api.get_panther_children_workspaces(
+            self.maps.parent_ids
         )
 
         # Set maps that require upstream data.
@@ -234,6 +243,7 @@ class WorkspaceProvisioner(
             self.ids_to_update,
             self.maps.child_to_parent_id_map,
             self.maps.workspace_id_to_wdf_map,
+            self.source_group_full,
         )
 
         # Check WDF settings of ignored workspaces.
@@ -259,5 +269,42 @@ class WorkspaceProvisioner(
 
     def _provision_incremental_load(self) -> None:
         """Incremental workspace provisioning."""
+        # Set the maps based on the source data.
+        self.maps = self.parser.set_maps_based_on_source(
+            self.maps, self.source_group_incremental
+        )
+
+        # Get upstream children of all parent workspaces.
+        self.upstream_group = self._api.get_panther_children_workspaces(
+            self.maps.parent_ids
+        )
+
+        # Set maps that require upstream data.
+        self.maps = self.parser.set_maps_with_upstream_data(
+            self.maps, self.source_group_incremental, self.upstream_group
+        )
 
-        raise NotImplementedError("Not implemented yet.")
+        # Create an instance of WDF manager with the created maps.
+        self.wdf_manager = WorkspaceDataFilterManager(self._api, self.maps)
+
+        # Iterate through the source data and sort workspace ID to groups
+        ids_to_update: set[str] = set()
+        ids_to_delete: set[str] = set()
+
+        for workspace in self.source_group_incremental:
+            if workspace.is_active:
+                ids_to_update.add(workspace.workspace_id)
+            else:
+                ids_to_delete.add(workspace.workspace_id)
+
+        self._create_or_update_panther_workspaces(
+            set(),
+            ids_to_update,
+            self.maps.child_to_parent_id_map,
+            self.maps.workspace_id_to_wdf_map,
+            self.source_group_incremental,
+        )
+
+        self.delete_panther_workspaces(
+            ids_to_delete, self.maps.workspace_id_to_name_map
+        )

gooddata_pipelines/provisioning/entities/workspaces/workspace_data_parser.py

@@ -9,6 +9,7 @@ from gooddata_sdk.catalog.workspace.entity_model.workspace import (
 from gooddata_pipelines.provisioning.entities.workspaces.models import (
     WorkspaceDataMaps,
     WorkspaceFullLoad,
+    WorkspaceIncrementalLoad,
 )
 
 
@@ -17,7 +18,7 @@ class WorkspaceDataParser:
 
     @staticmethod
     def _get_id_to_name_map(
-        source_group: list[WorkspaceFullLoad],
+        source_group: list[WorkspaceFullLoad] | list[WorkspaceIncrementalLoad],
         upstream_group: list[CatalogWorkspace],
     ) -> dict[str, str]:
         """Creates a map of workspace IDs to their names for all known workspaces."""
@@ -33,7 +34,7 @@ class WorkspaceDataParser:
 
     @staticmethod
     def _get_child_to_parent_map(
-        source_group: list[WorkspaceFullLoad],
+        source_group: list[WorkspaceFullLoad] | list[WorkspaceIncrementalLoad],
     ) -> dict[str, str]:
         """Creates a map of child workspace IDs to their parent workspace IDs."""
         child_to_parent_map: dict[str, str] = {
@@ -45,7 +46,8 @@ class WorkspaceDataParser:
 
     @staticmethod
     def _get_set_of_ids_from_source(
-        source_group: list[WorkspaceFullLoad], column_name: str
+        source_group: list[WorkspaceFullLoad] | list[WorkspaceIncrementalLoad],
+        column_name: str,
     ) -> set[str]:
         """Creates a set of unique parent workspace IDs."""
         set_of_ids: set[str] = {
@@ -64,7 +66,8 @@ class WorkspaceDataParser:
         return set_of_ids
 
     def _get_child_to_wdfs_map(
-        self, source_group: list[WorkspaceFullLoad]
+        self,
+        source_group: list[WorkspaceFullLoad] | list[WorkspaceIncrementalLoad],
     ) -> dict[str, dict[str, list[str]]]:
         """Creates a map of child workspace IDs to their WDF IDs."""
         # TODO: Use objects or a more transparent data structure instead of this.
@@ -88,7 +91,7 @@ class WorkspaceDataParser:
     def set_maps_based_on_source(
         self,
         map_object: WorkspaceDataMaps,
-        source_group: list[WorkspaceFullLoad],
+        source_group: list[WorkspaceFullLoad] | list[WorkspaceIncrementalLoad],
     ) -> WorkspaceDataMaps:
         """Creates maps which are dependent on the source group only."""
         map_object.child_to_parent_id_map = self._get_child_to_parent_map(
@@ -109,7 +112,7 @@ class WorkspaceDataParser:
     def set_maps_with_upstream_data(
         self,
         map_object: WorkspaceDataMaps,
-        source_group: list[WorkspaceFullLoad],
+        source_group: list[WorkspaceFullLoad] | list[WorkspaceIncrementalLoad],
         upstream_group: list[CatalogWorkspace],
     ) -> WorkspaceDataMaps:
         """Creates maps which are dependent on both the source group and upstream group."""