collibra-connector 1.0.9__py3-none-any.whl → 1.0.10b0__py3-none-any.whl

collibra_connector/api/Domain.py

@@ -0,0 +1,116 @@
+import uuid
+from .Base import BaseAPI
+
+
+class Domain(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api + "/domains"
+
+    def get_domain(self, domain_id: str):
+        """
+        Get a domain by its ID.
+        :param domain_id: The ID of the domain to retrieve.
+        :return: Domain details.
+        """
+        if not domain_id:
+            raise ValueError("domain_id is required")
+        if not isinstance(domain_id, str):
+            raise ValueError("domain_id must be a string")
+
+        try:
+            uuid.UUID(domain_id)
+        except ValueError as exc:
+            raise ValueError("domain_id must be a valid UUID") from exc
+
+        response = self._get(url=f"{self.__base_api}/{domain_id}")
+        return self._handle_response(response)
+
+    def find_domains(
+        self,
+        community_id: str = None,
+        count_limit: int = -1,
+        cursor: str = None,
+        exclude_meta: bool = True,
+        include_sub_communities: bool = False,
+        limit: int = 0,
+        name: str = None,
+        name_match_mode: str = "ANYWHERE",
+        offset: int = 0,
+        type_id: str = None,
+        type_public_id: str = None
+    ):
+        """
+        Find domains matching the given search criteria.
+        :param community_id: ID of the community to find domains in.
+        :param count_limit: Limit elements counted. -1 counts all, 0 skips count. Ignored with cursor pagination.
+        :param cursor: Cursor for pagination. Pass empty string for first page, use nextCursor for subsequent pages.
+        :param exclude_meta: Whether to exclude meta domains (not manually created by users).
+        :param include_sub_communities: Whether to search in sub-communities of the specified community.
+        :param limit: Maximum results to retrieve. 0 uses default, max 1000.
+        :param name: Name of domain to search for.
+        :param name_match_mode: Name matching mode. Options: START, END, ANYWHERE, EXACT
+        :param offset: First result to retrieve (deprecated, use cursor instead).
+        :param type_id: Domain type ID to filter by.
+        :param type_public_id: Domain type public ID to filter by.
+        :return: List of domains matching criteria.
+        """
+        # Validate name_match_mode
+        valid_match_modes = ["START", "END", "ANYWHERE", "EXACT"]
+        if name_match_mode not in valid_match_modes:
+            raise ValueError(f"name_match_mode must be one of: {', '.join(valid_match_modes)}")
+
+        # Validate limit
+        if limit < 0 or limit > 1000:
+            raise ValueError("limit must be between 0 and 1000")
+
+        # Validate community_id if provided
+        if community_id is not None:
+            if not isinstance(community_id, str):
+                raise ValueError("community_id must be a string")
+            try:
+                uuid.UUID(community_id)
+            except ValueError as exc:
+                raise ValueError("community_id must be a valid UUID") from exc
+
+        # Validate type_id if provided
+        if type_id is not None:
+            if not isinstance(type_id, str):
+                raise ValueError("type_id must be a string")
+            try:
+                uuid.UUID(type_id)
+            except ValueError as exc:
+                raise ValueError("type_id must be a valid UUID") from exc
+
+        # Validate cursor and offset usage
+        if cursor is not None and offset != 0:
+            raise ValueError("Cannot use both cursor and offset in the same request")
+
+        # Build parameters - only include non-default values
+        params = {}
+
+        if community_id is not None:
+            params["communityId"] = community_id
+        if count_limit != -1:
+            params["countLimit"] = count_limit
+        if cursor is not None:
+            params["cursor"] = cursor
+        if exclude_meta is not True:
+            params["excludeMeta"] = exclude_meta
+        if include_sub_communities is not False:
+            params["includeSubCommunities"] = include_sub_communities
+        if limit != 0:
+            params["limit"] = limit
+        if name is not None:
+            params["name"] = name
+        if name_match_mode != "ANYWHERE":
+            params["nameMatchMode"] = name_match_mode
+        if offset != 0:
+            params["offset"] = offset
+        if type_id is not None:
+            params["typeId"] = type_id
+        if type_public_id is not None:
+            params["typePublicId"] = type_public_id
+
+        response = self._get(params=params)
+        return self._handle_response(response)

collibra_connector/api/Exceptions.py

@@ -1,24 +1,19 @@
 
 class CollibraAPIError(Exception):
     """Base exception for Collibra API errors"""
-    pass
 
 
 class UnauthorizedError(CollibraAPIError):
     """Raised when authentication fails"""
-    pass
 
 
 class ForbiddenError(CollibraAPIError):
     """Raised when access is forbidden"""
-    pass
 
 
 class NotFoundError(CollibraAPIError):
     """Raised when resource is not found"""
-    pass
 
 
 class ServerError(CollibraAPIError):
     """Raised when server returns 5xx errors"""
-    pass

collibra_connector/api/Metadata.py

@@ -0,0 +1,120 @@
+from .Base import BaseAPI
+
+
+class Metadata(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api
+
+    def get_collibra_metadata(self):
+        """
+        Retrieve comprehensive metadata from Collibra including asset types,
+        relation types, responsibilities, statuses, attributes, communities,
+        domains, and domain types.
+        :return: Dictionary containing all metadata with names as keys and UUIDs as values.
+        """
+        metadata = {
+            "AssetType": {},
+            "Relation": {},
+            "Responsibility": {},
+            "Status": {},
+            "StringAttribute": {},
+            "Community": {},
+            "Domain": {},
+            "DomainType": {},
+        }
+
+        try:
+            # Get Asset Types
+            asset_types_response = self._get(url=f"{self.__base_api}/assetTypes")
+            asset_types_data = self._handle_response(asset_types_response)
+            for asset_type in asset_types_data.get("results", []):
+                metadata["AssetType"][asset_type["name"]] = asset_type["id"]
+
+            # Get Relation Types
+            relation_types_response = self._get(url=f"{self.__base_api}/relationTypes")
+            relation_types_data = self._handle_response(relation_types_response)
+            for relation_type in relation_types_data.get("results", []):
+                import re
+                source_name = re.sub(" ", "", relation_type["sourceType"]["name"])
+                target_name = re.sub(" ", "", relation_type["targetType"]["name"])
+                metadata["Relation"][f"{source_name}_{target_name}"] = relation_type["id"]
+
+            # Get Roles/Responsibilities
+            roles_response = self._get(url=f"{self.__base_api}/roles")
+            roles_data = self._handle_response(roles_response)
+            for role in roles_data.get("results", []):
+                metadata["Responsibility"][role["name"]] = role["id"]
+
+            # Get Statuses
+            statuses_response = self._get(url=f"{self.__base_api}/statuses")
+            statuses_data = self._handle_response(statuses_response)
+            for status in statuses_data.get("results", []):
+                metadata["Status"][status["name"]] = status["id"]
+
+            # Get Attribute Types
+            attributes_response = self._get(url=f"{self.__base_api}/attributeTypes")
+            attributes_data = self._handle_response(attributes_response)
+            for attribute in attributes_data.get("results", []):
+                metadata["StringAttribute"][attribute["name"]] = attribute["id"]
+
+            # Get Communities
+            communities_response = self._get(url=f"{self.__base_api}/communities")
+            communities_data = self._handle_response(communities_response)
+            for community in communities_data.get("results", []):
+                metadata["Community"][community["name"]] = community["id"]
+
+            # Get Domains (with pagination)
+            domains_params = {"limit": 1000, "offset": 0}
+            while True:
+                domains_response = self._get(url=f"{self.__base_api}/domains", params=domains_params)
+                domains_data = self._handle_response(domains_response)
+                for domain in domains_data.get("results", []):
+                    metadata["Domain"][domain["name"]] = domain["id"]
+                if (
+                    domains_data.get("offset", 0) + domains_data.get("limit", 0) >=
+                    domains_data.get("total", 0)
+                ):
+                    break
+                domains_params["offset"] += domains_params["limit"]
+
+            # Get Domain Types
+            domain_types_response = self._get(url=f"{self.__base_api}/domainTypes")
+            domain_types_data = self._handle_response(domain_types_response)
+            for domain_type in domain_types_data.get("results", []):
+                metadata["DomainType"][domain_type["name"]] = domain_type["id"]
+
+            return metadata
+
+        except Exception as e:
+            raise Exception(f"Error fetching Collibra metadata: {str(e)}") from e
+
+    def get_asset_types(self):
+        """Get all asset types."""
+        response = self._get(url=f"{self.__base_api}/assetTypes")
+        return self._handle_response(response)
+
+    def get_relation_types(self):
+        """Get all relation types."""
+        response = self._get(url=f"{self.__base_api}/relationTypes")
+        return self._handle_response(response)
+
+    def get_statuses(self):
+        """Get all statuses."""
+        response = self._get(url=f"{self.__base_api}/statuses")
+        return self._handle_response(response)
+
+    def get_attribute_types(self):
+        """Get all attribute types."""
+        response = self._get(url=f"{self.__base_api}/attributeTypes")
+        return self._handle_response(response)
+
+    def get_domain_types(self):
+        """Get all domain types."""
+        response = self._get(url=f"{self.__base_api}/domainTypes")
+        return self._handle_response(response)
+
+    def get_roles(self):
+        """Get all roles."""
+        response = self._get(url=f"{self.__base_api}/roles")
+        return self._handle_response(response)

collibra_connector/api/Responsibility.py

@@ -0,0 +1,303 @@
+import uuid
+from .Base import BaseAPI
+
+
+class Responsibility(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api + "/responsibilities"
+
+    def add_responsibility(
+        self,
+        role_id: str,
+        owner_id: str,
+        resource_id: str = None,
+        resource_type: str = None,
+        resource_discriminator: str = None
+    ):
+        """
+        Add a new responsibility. Assigns given user to resource with given role.
+        :param role_id: The ID of the role that should be assigned to user.
+        :param owner_id: The ID of the user who the responsibility is created for.
+        :param resource_id: The ID of the resource which the responsibility is created for.
+            If None, creates global responsibility.
+        :param resource_type: The type of the resource (e.g., Asset, Community, Domain, etc.).
+        :param resource_discriminator: The discriminator for resource type. Valid values: "Community", "Domain", "Asset"
+        :return: The responsibility ID.
+        """
+        # Validate required parameters
+        if not role_id or not owner_id:
+            raise ValueError("role_id and owner_id are required parameters")
+
+        # Validate UUIDs
+        for param_name, param_value in [("role_id", role_id), ("owner_id", owner_id)]:
+            if not isinstance(param_value, str):
+                raise ValueError(f"{param_name} must be a string")
+            try:
+                uuid.UUID(param_value)
+            except ValueError as exc:
+                raise ValueError(f"{param_name} must be a valid UUID") from exc
+
+        # Validate resource_id if provided
+        if resource_id is not None:
+            if not isinstance(resource_id, str):
+                raise ValueError("resource_id must be a string")
+            try:
+                uuid.UUID(resource_id)
+            except ValueError as exc:
+                raise ValueError("resource_id must be a valid UUID") from exc
+
+        # Validate resource_type if provided
+        valid_resource_types = [
+            "View", "Asset", "Community", "Domain", "AssetType", "DomainType", "Status", "User",
+            "Classification", "MatchUser", "Group", "Attribute", "StringAttribute", "ScriptAttribute",
+            "BooleanAttribute", "DateAttribute", "NumericAttribute", "SingleValueListAttribute",
+            "MultiValueListAttribute", "Comment", "Attachment", "Responsibility", "Workflow", "Job",
+            "Relation", "RelationType", "ComplexRelation", "ComplexRelationType", "ArticulationRule",
+            "Assignment", "ScopeRelation", "Trace", "ValidationRule", "DataQualityRule", "DataQualityMetric",
+            "Address", "InstantMessagingAccount", "Email", "PhoneNumber", "Website", "Activity",
+            "FormProperty", "WorkflowTask", "ActivityChange", "WorkflowInstance", "Role", "AttributeType",
+            "BooleanAttributeType", "DateAttributeType", "DateTimeAttributeType", "MultiValueListAttributeType",
+            "NumericAttributeType", "ScriptAttributeType", "SingleValueListAttributeType", "StringAttributeType",
+            "ViewSharingRule", "ViewAssignmentRule", "JdbcDriver", "File", "JdbcDriverJdbcIngestionProperties",
+            "CsvIngestionProperties", "ExcelIngestionProperties", "ConnectionStringParameter",
+            "AssignedCharacteristicType", "Notification", "Tag", "ComplexRelationLegType",
+            "ComplexRelationAttributeType", "ComplexRelationLeg", "BaseDataType", "AdvancedDataType",
+            "Diagram", "Picture", "DiagramPictureSharingRule", "DiagramPictureAssignmentRule", "Rating",
+            "ClassificationPhysicalData", "ConnectorContext"
+        ]
+
+        if resource_type is not None and resource_type not in valid_resource_types:
+            raise ValueError(
+                "resource_type must be one of the valid resource types. See API documentation for full list."
+            )
+
+        # Validate resource_discriminator if provided
+        valid_discriminators = ["Community", "Domain", "Asset"]
+        if resource_discriminator is not None and resource_discriminator not in valid_discriminators:
+            raise ValueError(f"resource_discriminator must be one of: {', '.join(valid_discriminators)}")
+
+        # Build request data - only include non-None values
+        data = {
+            "roleId": role_id,
+            "ownerId": owner_id
+        }
+
+        if resource_id is not None:
+            data["resourceId"] = resource_id
+        if resource_type is not None:
+            data["resourceType"] = resource_type
+        if resource_discriminator is not None:
+            data["resourceDiscriminator"] = resource_discriminator
+
+        response = self._post(url=self.__base_api, data=data)
+        result = self._handle_response(response)
+        return result.get("id")
+
+    def get_responsibility(self, responsibility_id: str):
+        """
+        Get details of a specific responsibility.
+        :param responsibility_id: The ID of the responsibility.
+        :return: Responsibility details.
+        """
+        if not responsibility_id:
+            raise ValueError("responsibility_id is required")
+        if not isinstance(responsibility_id, str):
+            raise ValueError("responsibility_id must be a string")
+
+        try:
+            uuid.UUID(responsibility_id)
+        except ValueError as exc:
+            raise ValueError("responsibility_id must be a valid UUID") from exc
+
+        response = self._get(url=f"{self.__base_api}/{responsibility_id}")
+        return self._handle_response(response)
+
+    def find_responsibilities(
+        self,
+        count_limit: int = -1,
+        exclude_empty_groups: bool = None,
+        global_only: bool = None,
+        include_inherited: bool = True,
+        limit: int = 0,
+        offset: int = 0,
+        owner_ids: list = None,
+        resource_ids: list = None,
+        role_ids: list = None,
+        sort_field: str = "LAST_MODIFIED",
+        sort_order: str = "DESC",
+        _type: str = None
+    ):
+        """
+        Find responsibilities matching the given search criteria.
+        :param count_limit: Limit the number of elements counted. -1 counts everything, 0 skips count.
+        :param exclude_empty_groups: Whether responsibilities assigned to empty groups should be excluded.
+        :param global_only: Whether only global responsibilities should be searched (deprecated).
+        :param include_inherited: Whether inherited responsibilities should be included.
+        :param limit: Maximum number of results to retrieve. 0 uses default, max 1000.
+        :param offset: First result to retrieve. 0 starts from beginning.
+        :param owner_ids: List of owner IDs to filter responsibilities by.
+        :param resource_ids: List of resource IDs to filter responsibilities by.
+        :param role_ids: List of role IDs to filter responsibilities by.
+        :param sort_field: Field to sort results by. Options: CREATED_BY, CREATED_ON, LAST_MODIFIED, NAME
+        :param sort_order: Sort order. Options: ASC, DESC
+        :param type: Type of responsibilities. Options: ALL, GLOBAL, RESOURCE
+        :return: List of responsibilities matching the criteria.
+        """
+        # Validate sort_field
+        valid_sort_fields = ["CREATED_BY", "CREATED_ON", "LAST_MODIFIED", "NAME"]
+        if sort_field not in valid_sort_fields:
+            raise ValueError(f"sort_field must be one of: {', '.join(valid_sort_fields)}")
+
+        # Validate sort_order
+        if sort_order not in ["ASC", "DESC"]:
+            raise ValueError("sort_order must be 'ASC' or 'DESC'")
+
+        # Validate limit
+        if limit < 0 or limit > 1000:
+            raise ValueError("limit must be between 0 and 1000")
+
+        # Validate type if provided
+        valid_types = ["ALL", "GLOBAL", "RESOURCE"]
+        if _type is not None and _type not in valid_types:
+            raise ValueError(f"type must be one of: {', '.join(valid_types)}")
+
+        # Validate that globalOnly and type are mutually exclusive
+        if global_only is not None and type is not None:
+            raise ValueError("globalOnly and type parameters are mutually exclusive")
+
+        # Validate owner_ids if provided
+        if owner_ids is not None:
+            if not isinstance(owner_ids, list):
+                raise ValueError("owner_ids must be a list")
+            for owner_id in owner_ids:
+                if not isinstance(owner_id, str):
+                    raise ValueError("owner_id must be a string")
+                try:
+                    uuid.UUID(owner_id)
+                except ValueError as exc:
+                    raise ValueError("owner_id must be a valid UUID") from exc
+
+        # Validate resource_ids if provided
+        if resource_ids is not None:
+            if not isinstance(resource_ids, list):
+                raise ValueError("resource_ids must be a list")
+            for resource_id in resource_ids:
+                if not isinstance(resource_id, str):
+                    raise ValueError("resource_id must be a string")
+                try:
+                    uuid.UUID(resource_id)
+                except ValueError as exc:
+                    raise ValueError("resource_id must be a valid UUID") from exc
+
+        # Validate role_ids if provided
+        if role_ids is not None:
+            if not isinstance(role_ids, list):
+                raise ValueError("role_ids must be a list")
+            for role_id in role_ids:
+                if not isinstance(role_id, str):
+                    raise ValueError("role_id must be a string")
+                try:
+                    uuid.UUID(role_id)
+                except ValueError as exc:
+                    raise ValueError("role_id must be a valid UUID") from exc
+
+        # Build parameters - only include non-default values
+        params = {}
+
+        if count_limit != -1:
+            params["countLimit"] = count_limit
+        if exclude_empty_groups is not None:
+            params["excludeEmptyGroups"] = exclude_empty_groups
+        if global_only is not None:
+            params["globalOnly"] = global_only
+        if include_inherited is not True:
+            params["includeInherited"] = include_inherited
+        if limit != 0:
+            params["limit"] = limit
+        if offset != 0:
+            params["offset"] = offset
+        if owner_ids is not None:
+            params["ownerIds"] = owner_ids
+        if resource_ids is not None:
+            params["resourceIds"] = resource_ids
+        if role_ids is not None:
+            params["roleIds"] = role_ids
+        if sort_field != "LAST_MODIFIED":
+            params["sortField"] = sort_field
+        if sort_order != "DESC":
+            params["sortOrder"] = sort_order
+        if type is not None:
+            params["type"] = type
+
+        response = self._get(params=params)
+        return self._handle_response(response)
+
+    def get_asset_responsibilities(self, asset_id: str, role_ids: list = None):
+        """
+        Get responsibilities for an asset (convenience method).
+        :param asset_id: The ID of the asset.
+        :param role_ids: Optional list of role IDs to filter by.
+        :return: List of responsibilities.
+        """
+        if not asset_id:
+            raise ValueError("asset_id is required")
+        if not isinstance(asset_id, str):
+            raise ValueError("asset_id must be a string")
+
+        try:
+            uuid.UUID(asset_id)
+        except ValueError as exc:
+            raise ValueError("asset_id must be a valid UUID") from exc
+
+        return self.find_responsibilities(
+            resource_ids=[asset_id],
+            role_ids=role_ids
+        )
+
+    def get_user_responsibilities(self, user_id: str, role_id: str = None):
+        """
+        Get responsibilities for a user (convenience method).
+        :param user_id: The ID of the user.
+        :param role_id: Optional role ID to filter by.
+        :return: List of responsibilities.
+        """
+        if not user_id:
+            raise ValueError("user_id is required")
+        if not isinstance(user_id, str):
+            raise ValueError("user_id must be a string")
+
+        try:
+            uuid.UUID(user_id)
+        except ValueError as exc:
+            raise ValueError("user_id must be a valid UUID") from exc
+
+        role_ids = [role_id] if role_id else None
+        return self.find_responsibilities(
+            owner_ids=[user_id],
+            role_ids=role_ids
+        )
+
+    def get_global_responsibilities(self, role_ids: list = None):
+        """
+        Get global responsibilities (convenience method).
+        :param role_ids: Optional list of role IDs to filter by.
+        :return: List of global responsibilities.
+        """
+        return self.find_responsibilities(
+            _type="GLOBAL",
+            role_ids=role_ids
+        )
+
+    def get_resource_responsibilities(self, resource_ids: list = None, role_ids: list = None):
+        """
+        Get resource-specific responsibilities (convenience method).
+        :param resource_ids: Optional list of resource IDs to filter by.
+        :param role_ids: Optional list of role IDs to filter by.
+        :return: List of resource responsibilities.
+        """
+        return self.find_responsibilities(
+            _type="RESOURCE",
+            resource_ids=resource_ids,
+            role_ids=role_ids
+        )