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

collibra_connector/api/Asset.py

@@ -86,7 +86,7 @@ class Asset(BaseAPI):
         response = self._post(url=self.__base_api, data=data)
         return self._handle_response(response)
 
-    def update_asset_properties(
+    def change_asset(
         self,
         asset_id: str,
         name: str = None,
@@ -146,16 +146,7 @@ class Asset(BaseAPI):
             "typePublicId": type_public_id,
         }
 
-        # Use PATCH method through requests directly since BaseAPI doesn't have _patch
-        import requests
-        response = requests.patch(
-            f"{self.__base_api}/{asset_id}",
-            auth=self.__connector.auth,
-            json=data,
-            headers=self.__header,
-            timeout=30
-        )
-
+        response = self._patch(url=f"{self.__base_api}/{asset_id}", data=data)
         return self._handle_response(response)
 
     def update_asset_attribute(self, asset_id: str, attribute_id: str, value):
@@ -182,16 +173,203 @@ class Asset(BaseAPI):
             "typeId": attribute_id
         }
 
-        # Use PUT method through requests directly since BaseAPI doesn't have _put
-        import requests
-        response = requests.put(
-            f"{self.__base_api}/{asset_id}/attributes",
-            auth=self.__connector.auth,
-            json=data,
-            headers=self.__header,
-            timeout=30
-        )
+        response = self._put(url=f"{self.__base_api}/{asset_id}/attributes", data=data)
+        return self._handle_response(response)
+
+    def set_asset_attributes(self, asset_id: str, type_id: str = None, type_public_id: str = None, values: list = None):
+        """
+        Set asset attributes. Replaces all attributes of the asset with the given ID
+        (of given attribute type) with the attributes from the request.
+        :param asset_id: The ID of the asset.
+        :param type_id: The ID of the attribute type for the new attribute.
+        :param type_public_id: The public ID of the attribute type for the new attribute.
+        :param values: The values for the new attribute (list of objects).
+        :return: The response from setting the attributes.
+        """
+        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
+
+        if not values:
+            raise ValueError("values is required")
+        if not isinstance(values, list):
+            raise ValueError("values must be a list")
+
+        # Validate that either type_id or type_public_id is provided
+        if not type_id and not type_public_id:
+            raise ValueError("Either type_id or type_public_id must be provided")
+
+        # Validate type_id if provided
+        if type_id:
+            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 type_public_id if provided
+        if type_public_id and not isinstance(type_public_id, str):
+            raise ValueError("type_public_id must be a string")
+
+        data = {
+            "values": values
+        }
+
+        # Add type_id or type_public_id to the data
+        if type_id:
+            data["typeId"] = type_id
+        if type_public_id:
+            data["typePublicId"] = type_public_id
+
+        response = self._put(url=f"{self.__base_api}/{asset_id}/attributes", data=data)
+        return self._handle_response(response)
+
+    def remove_asset(self, asset_id: str):
+        """
+        Remove an asset identified by given ID.
+        :param asset_id: The ID of the asset to remove.
+        :return: The response from removing the asset.
+        """
+        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
+
+        response = self._delete(url=f"{self.__base_api}/{asset_id}")
+        return self._handle_response(response)
+
+    def set_asset_relations(self, asset_id: str, related_asset_ids: list, relation_direction: str,
+                            type_id: str = None, type_public_id: str = None):
+        """
+        Set relations for the asset with the given ID. All relations described by this request
+        will replace the existing ones (identified with asset as one end, relation type and direction).
+        :param asset_id: The ID of the asset.
+        :param related_asset_ids: The IDs of the related assets (list of UUIDs).
+        :param relation_direction: The relation direction ('TO_TARGET' or 'TO_SOURCE').
+        :param type_id: The ID of the relation type for the relations to be set.
+        :param type_public_id: The public ID of the relation type for the relations to be set.
+        :return: The response from setting the relations.
+        """
+        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
+
+        if not related_asset_ids:
+            raise ValueError("related_asset_ids is required")
+        if not isinstance(related_asset_ids, list):
+            raise ValueError("related_asset_ids must be a list")
+
+        # Validate all related asset IDs are valid UUIDs
+        for i, related_id in enumerate(related_asset_ids):
+            if not isinstance(related_id, str):
+                raise ValueError(f"related_asset_ids[{i}] must be a string")
+            try:
+                uuid.UUID(related_id)
+            except ValueError as exc:
+                raise ValueError(f"related_asset_ids[{i}] must be a valid UUID") from exc
+
+        if not relation_direction:
+            raise ValueError("relation_direction is required")
+        if relation_direction not in ["TO_TARGET", "TO_SOURCE"]:
+            raise ValueError("relation_direction must be either 'TO_TARGET' or 'TO_SOURCE'")
+
+        # Validate that either type_id or type_public_id is provided
+        if not type_id and not type_public_id:
+            raise ValueError("Either type_id or type_public_id must be provided")
+
+        # Validate type_id if provided
+        if type_id:
+            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 type_public_id if provided
+        if type_public_id and not isinstance(type_public_id, str):
+            raise ValueError("type_public_id must be a string")
+
+        data = {
+            "relatedAssetIds": related_asset_ids,
+            "relationDirection": relation_direction
+        }
+
+        # Add type_id or type_public_id to the data
+        if type_id:
+            data["typeId"] = type_id
+        if type_public_id:
+            data["typePublicId"] = type_public_id
+
+        response = self._put(url=f"{self.__base_api}/{asset_id}/relations", data=data)
+        return self._handle_response(response)
+
+    def set_asset_responsibilities(self, asset_id: str, role_id: str, owner_ids: list):
+        """
+        Set responsibilities for the asset with the given ID.
+        :param asset_id: The ID of the asset.
+        :param role_id: The ID of the role for the responsibilities to be set.
+        :param owner_ids: The IDs of the owners (list of UUIDs). An owner is either user or group.
+        :return: The response from setting the 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
+
+        if not role_id:
+            raise ValueError("role_id is required")
+        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
+
+        if not owner_ids:
+            raise ValueError("owner_ids is required")
+        if not isinstance(owner_ids, list):
+            raise ValueError("owner_ids must be a list")
+
+        # Validate all owner IDs are valid UUIDs
+        for i, owner_id in enumerate(owner_ids):
+            if not isinstance(owner_id, str):
+                raise ValueError(f"owner_ids[{i}] must be a string")
+            try:
+                uuid.UUID(owner_id)
+            except ValueError as exc:
+                raise ValueError(f"owner_ids[{i}] must be a valid UUID") from exc
+
+        data = {
+            "roleId": role_id,
+            "ownerIds": owner_ids
+        }
 
+        response = self._put(url=f"{self.__base_api}/{asset_id}/responsibilities", data=data)
         return self._handle_response(response)
 
     def find_assets(

collibra_connector/api/Base.py

@@ -38,7 +38,7 @@ class BaseAPI:
             timeout=self.__connector.timeout
         )
 
-    def _post(self, url: str, data: dict, headers: dict = None):
+    def _post(self, url: str, data: dict, headers: dict = None, params: dict = None):
         """
         Makes a POST request to the specified URL with the given data.
         :param url: The URL to send the POST request to.
@@ -56,6 +56,7 @@ class BaseAPI:
             auth=self.__connector.auth,
             json=data,
             headers=headers,
+            params=params,
             timeout=self.__connector.timeout
         )
 

collibra_connector/api/Community.py

@@ -110,3 +110,183 @@ class Community(BaseAPI):
 
         response = self._get(params=params)
         return self._handle_response(response)
+
+    def add_community(
+        self,
+        name: str,
+        parent_id: str = None,
+        description: str = None,
+        community_id: str = None
+    ):
+        """
+        Adds a new community with the given parameters.
+        :param name: The name of the new community. Should be unique across all communities
+                    (required, 1-255 characters).
+        :param parent_id: The ID of the parent for the new community (optional UUID).
+        :param description: The description of the new community (optional).
+        :param community_id: The ID of the new community. Should be unique within all communities
+                           (optional UUID).
+        :return: Details of the created community.
+        """
+        # Validate required parameters
+        if not name:
+            raise ValueError("name is required")
+        if not isinstance(name, str):
+            raise ValueError("name must be a string")
+        if len(name.strip()) < 1 or len(name) > 255:
+            raise ValueError("name must be between 1 and 255 characters")
+
+        # Validate parent_id if provided
+        if parent_id is not None:
+            if not isinstance(parent_id, str):
+                raise ValueError("parent_id must be a string")
+            try:
+                uuid.UUID(parent_id)
+            except ValueError as exc:
+                raise ValueError("parent_id must be a valid UUID") from exc
+
+        # Validate description if provided
+        if description is not None and not isinstance(description, str):
+            raise ValueError("description must be a string")
+
+        # 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:
+                parsed_uuid = uuid.UUID(community_id)
+                # Check if UUID starts with reserved prefix
+                if str(parsed_uuid).startswith("00000000-0000-0000-"):
+                    raise ValueError("community_id cannot start with reserved prefix '00000000-0000-0000-'")
+            except ValueError as exc:
+                if "reserved prefix" in str(exc):
+                    raise exc
+                raise ValueError("community_id must be a valid UUID") from exc
+
+        # Build request body - only include provided values
+        data = {"name": name.strip()}
+
+        if parent_id is not None:
+            data["parentId"] = parent_id
+        if description is not None:
+            data["description"] = description
+        if community_id is not None:
+            data["id"] = community_id
+
+        response = self._post(url=self.__base_api, data=data)
+        return self._handle_response(response)
+
+    def change_community(
+        self,
+        community_id: str,
+        name: str = None,
+        parent_id: str = None,
+        description: str = None,
+        remove_scope_overlap_on_move: bool = None
+    ):
+        """
+        Changes the community with the information that is present in the request.
+        Only properties that are specified in this request and have non-null values are updated.
+        :param community_id: The ID of the community to be changed (required UUID).
+        :param name: The new name for the community (optional, 1-255 characters).
+        :param parent_id: The ID of the new parent community (optional UUID).
+        :param description: The new description for the community (optional).
+        :param remove_scope_overlap_on_move: Whether scopes assigned to domain community
+                                           and its children should be removed on move if there
+                                           are any inherited scopes in new parent community.
+        :return: Details of the updated community.
+        """
+        # Validate required parameters
+        if not community_id:
+            raise ValueError("community_id is required")
+        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 name if provided
+        if name is not None:
+            if not isinstance(name, str):
+                raise ValueError("name must be a string")
+            if len(name.strip()) < 1 or len(name) > 255:
+                raise ValueError("name must be between 1 and 255 characters")
+
+        # Validate parent_id if provided
+        if parent_id is not None:
+            if not isinstance(parent_id, str):
+                raise ValueError("parent_id must be a string")
+            try:
+                uuid.UUID(parent_id)
+            except ValueError as exc:
+                raise ValueError("parent_id must be a valid UUID") from exc
+
+        # Validate description if provided
+        if description is not None and not isinstance(description, str):
+            raise ValueError("description must be a string")
+
+        # Validate remove_scope_overlap_on_move if provided
+        if remove_scope_overlap_on_move is not None and not isinstance(remove_scope_overlap_on_move, bool):
+            raise ValueError("remove_scope_overlap_on_move must be a boolean")
+
+        # Build request body - only include provided values
+        # Include the community_id in the body as required by the API
+        data = {"id": community_id}
+
+        if name is not None:
+            data["name"] = name.strip()
+        if parent_id is not None:
+            data["parentId"] = parent_id
+        if description is not None:
+            data["description"] = description
+        if remove_scope_overlap_on_move is not None:
+            data["removeScopeOverlapOnMove"] = remove_scope_overlap_on_move
+
+        response = self._patch(url=f"{self.__base_api}/{community_id}", data=data)
+        return self._handle_response(response)
+
+    def remove_community(self, community_id: str):
+        """
+        Remove a community by its ID.
+
+        **DEPRECATED**: This endpoint will be removed in the future.
+        Please use POST /communities/removalJobs instead.
+
+        :param community_id: The ID of the community to remove (required UUID).
+        :return: Response from the removal operation.
+        """
+        # Validate required parameters
+        if not community_id:
+            raise ValueError("community_id is required")
+        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
+
+        response = self._delete(url=f"{self.__base_api}/{community_id}")
+        return self._handle_response(response)
+
+    def change_to_root_community(self, community_id: str):
+        """
+        Changes the community with given ID to a root community.
+        :param community_id: The ID of the community that will be changed to a root community (required UUID).
+        :return: Details of the updated community.
+        """
+        # Validate required parameters
+        if not community_id:
+            raise ValueError("community_id is required")
+        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
+
+        response = self._post(url=f"{self.__base_api}/{community_id}/root", data={})
+        return self._handle_response(response)

collibra_connector/api/Domain.py

@@ -112,5 +112,200 @@ class Domain(BaseAPI):
         if type_public_id is not None:
             params["typePublicId"] = type_public_id
 
-        response = self._get(params=params)
+        response = self._get(url=self.__base_api, params=params)
+        return self._handle_response(response)
+
+    def add_domain(
+        self,
+        name: str,
+        community_id: str,
+        type_id: str = None,
+        description: str = None,
+        domain_id: str = None,
+        excluded_from_auto_hyperlinking: bool = None,
+        type_public_id: str = None
+    ):
+        """
+        Adds a new domain with given data into a community.
+        :param name: The name of the new domain. Should be unique within the community
+                    (required, 1-255 characters).
+        :param community_id: The ID of the community that the new domain should be added to (required UUID).
+        :param type_id: The ID of the domain type of the new domain (optional UUID).
+        :param description: The description of the new domain (optional).
+        :param domain_id: The ID of the new domain. Should be unique within all domains (optional UUID).
+        :param excluded_from_auto_hyperlinking: Whether to exclude from auto hyperlinking (optional boolean).
+        :param type_public_id: The public ID of the domain type of the new domain (optional).
+        :return: Details of the created domain.
+        """
+        # Validate required parameters
+        if not name:
+            raise ValueError("name is required")
+        if not isinstance(name, str):
+            raise ValueError("name must be a string")
+        if len(name.strip()) < 1 or len(name) > 255:
+            raise ValueError("name must be between 1 and 255 characters")
+
+        if not community_id:
+            raise ValueError("community_id is required")
+        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 description if provided
+        if description is not None and not isinstance(description, str):
+            raise ValueError("description must be a string")
+
+        # Validate domain_id if provided
+        if domain_id is not None:
+            if not isinstance(domain_id, str):
+                raise ValueError("domain_id must be a string")
+            try:
+                parsed_uuid = uuid.UUID(domain_id)
+                # Check if UUID starts with reserved prefix
+                if str(parsed_uuid).startswith("00000000-0000-0000-"):
+                    raise ValueError("domain_id cannot start with reserved prefix '00000000-0000-0000-'")
+            except ValueError as exc:
+                if "reserved prefix" in str(exc):
+                    raise exc
+                raise ValueError("domain_id must be a valid UUID") from exc
+
+        # Validate excluded_from_auto_hyperlinking if provided
+        if excluded_from_auto_hyperlinking is not None and not isinstance(excluded_from_auto_hyperlinking, bool):
+            raise ValueError("excluded_from_auto_hyperlinking must be a boolean")
+
+        # Validate type_public_id if provided
+        if type_public_id is not None and not isinstance(type_public_id, str):
+            raise ValueError("type_public_id must be a string")
+
+        # Build request body - only include provided values
+        data = {
+            "name": name.strip(),
+            "communityId": community_id
+        }
+
+        if type_id is not None:
+            data["typeId"] = type_id
+        if description is not None:
+            data["description"] = description
+        if domain_id is not None:
+            data["id"] = domain_id
+        if excluded_from_auto_hyperlinking is not None:
+            data["excludedFromAutoHyperlinking"] = excluded_from_auto_hyperlinking
+        if type_public_id is not None:
+            data["typePublicId"] = type_public_id
+
+        response = self._post(url=self.__base_api, data=data)
+        return self._handle_response(response)
+
+    def remove_domain(self, domain_id: str):
+        """
+        Remove a domain by its ID.
+
+        **DEPRECATED**: This endpoint will be removed in the future.
+        Please use POST /domains/removalJobs instead.
+
+        :param domain_id: The ID of the domain to remove (required UUID).
+        :return: Response from the removal operation.
+        """
+        # Validate required parameters
+        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._delete(url=f"{self.__base_api}/{domain_id}")
+        return self._handle_response(response)
+
+    def change_domain(
+        self,
+        domain_id: str,
+        name: str = None,
+        description: str = None,
+        type_id: str = None,
+        type_public_id: str = None,
+        excluded_from_auto_hyperlinking: bool = None
+    ):
+        """
+        Changes the domain with the information that is present in the request.
+        Only properties that are specified in this request and have non-null values are updated.
+        :param domain_id: The ID of the domain to be changed (required UUID).
+        :param name: The new name for the domain (optional, 1-255 characters).
+        :param description: The new description for the domain (optional).
+        :param type_id: The ID of the domain type (optional UUID).
+        :param type_public_id: The public ID of the domain type (optional).
+        :param excluded_from_auto_hyperlinking: Whether to exclude from auto hyperlinking (optional boolean).
+        :return: Details of the updated domain.
+        """
+        # Validate required parameters
+        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
+
+        # Validate name if provided
+        if name is not None:
+            if not isinstance(name, str):
+                raise ValueError("name must be a string")
+            if len(name.strip()) < 1 or len(name) > 255:
+                raise ValueError("name must be between 1 and 255 characters")
+
+        # Validate description if provided
+        if description is not None and not isinstance(description, str):
+            raise ValueError("description must be a string")
+
+        # 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 type_public_id if provided
+        if type_public_id is not None and not isinstance(type_public_id, str):
+            raise ValueError("type_public_id must be a string")
+
+        # Validate excluded_from_auto_hyperlinking if provided
+        if excluded_from_auto_hyperlinking is not None and not isinstance(excluded_from_auto_hyperlinking, bool):
+            raise ValueError("excluded_from_auto_hyperlinking must be a boolean")
+
+        # Build request body - only include provided values
+        # Include the domain_id in the body as required by the API
+        data = {"id": domain_id}
+
+        if name is not None:
+            data["name"] = name.strip()
+        if description is not None:
+            data["description"] = description
+        if type_id is not None:
+            data["typeId"] = type_id
+        if type_public_id is not None:
+            data["typePublicId"] = type_public_id
+        if excluded_from_auto_hyperlinking is not None:
+            data["excludedFromAutoHyperlinking"] = excluded_from_auto_hyperlinking
+
+        response = self._patch(url=f"{self.__base_api}/{domain_id}", data=data)
         return self._handle_response(response)

collibra_connector/api/Metadata.py

@@ -72,8 +72,8 @@ class Metadata(BaseAPI):
                 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)
+                    domains_data.get("offset", 0) + domains_data.get("limit", 0)
+                    >= domains_data.get("total", 0)
                 ):
                     break
                 domains_params["offset"] += domains_params["limit"]

collibra_connector/api/OutputModule.py

@@ -0,0 +1,48 @@
+import requests
+from typing import Optional, Dict, Any
+from .Base import BaseAPI
+
+
+class OutputModule(BaseAPI):
+    """
+    Output Module API endpoints for Collibra DGC.
+    """
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api + "/outputModule"
+
+    def export_json(
+        self,
+        body: str,
+        validation_enabled: bool = False
+    ) -> Dict[Any, Any]:
+        """
+        Exports results in JSON format, returns the results immediately.
+
+        Performs an Output Module query and exports the returns results immediately in JSON format.
+
+        Please note that the ViewConfig/TableViewConfig's syntax validation is not executed by default.
+        DGC admin console settings may impact the execution of the query (especially in terms of timeout
+        and a limit on the number of results).
+
+        Args:
+            view_config (str): The JSON/YAML representation of ViewConfig/TableViewConfig
+                             that describes the query to be performed.
+            validation_enabled (bool): Determines if the ViewConfig's syntax should be validated
+                                     (True) or not (False). Default value is False for backward
+                                     compatibility reasons but it is strongly advised to always
+                                     enable this validation.
+
+        Returns:
+            Dict[Any, Any]: The exported results in JSON format.
+
+        Raises:
+            requests.exceptions.RequestException: If the API request fails.
+        """
+        endpoint = f"{self.__base_api}/export/json"
+
+        headers = {
+            'Content-Type': 'application/json'
+        }
+
+        return self._post(url=endpoint, data=body, headers=headers).json()

collibra_connector/api/Relation.py

@@ -0,0 +1,206 @@
+import uuid
+from .Base import BaseAPI
+
+
+class Relation(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api + "/relations"
+
+    def add_relation(
+        self,
+        source_id: str,
+        target_id: str,
+        type_id: str = None,
+        starting_date: int = None,
+        ending_date: int = None,
+        type_public_id: str = None
+    ):
+        """
+        Adds a new relation.
+        :param source_id: The ID of the source of the relation (required UUID).
+        :param target_id: The ID of the target of the relation (required UUID).
+        :param type_id: The ID of the type of the relation (optional UUID).
+        :param starting_date: The starting date of the relation (deprecated, int64).
+        :param ending_date: The ending date of the relation (deprecated, int64).
+        :param type_public_id: The public ID of the type of the relation (optional).
+        :return: Details of the created relation.
+        """
+        # Validate required parameters
+        if not source_id:
+            raise ValueError("source_id is required")
+        if not isinstance(source_id, str):
+            raise ValueError("source_id must be a string")
+        try:
+            uuid.UUID(source_id)
+        except ValueError as exc:
+            raise ValueError("source_id must be a valid UUID") from exc
+
+        if not target_id:
+            raise ValueError("target_id is required")
+        if not isinstance(target_id, str):
+            raise ValueError("target_id must be a string")
+        try:
+            uuid.UUID(target_id)
+        except ValueError as exc:
+            raise ValueError("target_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 starting_date if provided
+        if starting_date is not None:
+            if not isinstance(starting_date, int):
+                raise ValueError("starting_date must be an integer")
+            if starting_date < 0:
+                raise ValueError("starting_date must be a positive integer")
+
+        # Validate ending_date if provided
+        if ending_date is not None:
+            if not isinstance(ending_date, int):
+                raise ValueError("ending_date must be an integer")
+            if ending_date < 0:
+                raise ValueError("ending_date must be a positive integer")
+
+        # Validate type_public_id if provided
+        if type_public_id is not None and not isinstance(type_public_id, str):
+            raise ValueError("type_public_id must be a string")
+
+        # Build request data - only include provided values
+        data = {
+            "sourceId": source_id,
+            "targetId": target_id
+        }
+
+        if type_id is not None:
+            data["typeId"] = type_id
+        if starting_date is not None:
+            data["startingDate"] = starting_date
+        if ending_date is not None:
+            data["endingDate"] = ending_date
+        if type_public_id is not None:
+            data["typePublicId"] = type_public_id
+
+        response = self._post(url=self.__base_api, data=data)
+        return self._handle_response(response)
+
+    def get_relation(self, relation_id: str):
+        """
+        Returns a relation identified by given id.
+        :param relation_id: The ID of the relation (required UUID).
+        :return: Relation details.
+        """
+        if not relation_id:
+            raise ValueError("relation_id is required")
+        if not isinstance(relation_id, str):
+            raise ValueError("relation_id must be a string")
+
+        try:
+            uuid.UUID(relation_id)
+        except ValueError as exc:
+            raise ValueError("relation_id must be a valid UUID") from exc
+
+        response = self._get(url=f"{self.__base_api}/{relation_id}")
+        return self._handle_response(response)
+
+    def remove_relation(self, relation_id: str):
+        """
+        Removes a relation identified by given id.
+        :param relation_id: The ID of the relation to remove (required UUID).
+        :return: Response from the removal operation.
+        """
+        if not relation_id:
+            raise ValueError("relation_id is required")
+        if not isinstance(relation_id, str):
+            raise ValueError("relation_id must be a string")
+
+        try:
+            uuid.UUID(relation_id)
+        except ValueError as exc:
+            raise ValueError("relation_id must be a valid UUID") from exc
+
+        response = self._delete(url=f"{self.__base_api}/{relation_id}")
+        return self._handle_response(response)
+
+    def change_relation(
+        self,
+        relation_id: str,
+        source_id: str = None,
+        target_id: str = None,
+        starting_date: int = None,
+        ending_date: int = None
+    ):
+        """
+        Changes the relation with the information that is present in the request.
+        Only properties that are specified in this request and have non-null values are updated.
+        :param relation_id: The ID of the relation to be changed (required UUID).
+        :param source_id: The ID of the new source for the relation (optional UUID).
+        :param target_id: The ID of the new target for the relation (optional UUID).
+        :param starting_date: The new starting date for the relation (deprecated, int64).
+        :param ending_date: The new ending date for the relation (deprecated, int64).
+        :return: Details of the updated relation.
+        """
+        # Validate required parameters
+        if not relation_id:
+            raise ValueError("relation_id is required")
+        if not isinstance(relation_id, str):
+            raise ValueError("relation_id must be a string")
+
+        try:
+            uuid.UUID(relation_id)
+        except ValueError as exc:
+            raise ValueError("relation_id must be a valid UUID") from exc
+
+        # Validate source_id if provided
+        if source_id is not None:
+            if not isinstance(source_id, str):
+                raise ValueError("source_id must be a string")
+            try:
+                uuid.UUID(source_id)
+            except ValueError as exc:
+                raise ValueError("source_id must be a valid UUID") from exc
+
+        # Validate target_id if provided
+        if target_id is not None:
+            if not isinstance(target_id, str):
+                raise ValueError("target_id must be a string")
+            try:
+                uuid.UUID(target_id)
+            except ValueError as exc:
+                raise ValueError("target_id must be a valid UUID") from exc
+
+        # Validate starting_date if provided
+        if starting_date is not None:
+            if not isinstance(starting_date, int):
+                raise ValueError("starting_date must be an integer")
+            if starting_date < 0:
+                raise ValueError("starting_date must be a positive integer")
+
+        # Validate ending_date if provided
+        if ending_date is not None:
+            if not isinstance(ending_date, int):
+                raise ValueError("ending_date must be an integer")
+            if ending_date < 0:
+                raise ValueError("ending_date must be a positive integer")
+
+        # Build request body - only include provided values
+        # Include the relation_id in the body as required by the API
+        data = {"id": relation_id}
+
+        if source_id is not None:
+            data["sourceId"] = source_id
+        if target_id is not None:
+            data["targetId"] = target_id
+        if starting_date is not None:
+            data["startingDate"] = starting_date
+        if ending_date is not None:
+            data["endingDate"] = ending_date
+
+        response = self._patch(url=f"{self.__base_api}/{relation_id}", data=data)
+        return self._handle_response(response)

collibra_connector/api/Responsibility.py

@@ -113,6 +113,25 @@ class Responsibility(BaseAPI):
         response = self._get(url=f"{self.__base_api}/{responsibility_id}")
         return self._handle_response(response)
 
+    def delete_responsibility(self, responsibility_id: str):
+        """
+        Remove the responsibility identified by the given id.
+        :param responsibility_id: The unique identifier of the responsibility.
+        :return: None
+        """
+        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._delete(url=f"{self.__base_api}/{responsibility_id}")
+        self._handle_response(response)
+
     def find_responsibilities(
         self,
         count_limit: int = -1,

collibra_connector/api/Utils.py

@@ -0,0 +1,103 @@
+import re
+import logging
+from .Base import BaseAPI
+
+logger = logging.getLogger(__name__)
+
+
+class Utils(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api
+
+    def get_uuids(self):
+        """
+        Retrieves UUIDs of asset types, relation types, responsibilities, statuses, and attributes from Collibra,
+        returning a dictionary with names as keys and UUIDs as values. Relation type names are used.
+
+        Returns:
+            A dictionary containing dictionaries of named UUIDs for asset types, relation types,
+            responsibilities, statuses, and attributes.
+        """
+        metadata = {
+            "AssetType": {},
+            "Relation": {},
+            "Responsability": {},
+            "Status": {},
+            "Attribute": {},
+            "Community": {},
+            "Domain": {},
+            "DomainType": {},
+        }
+        try:
+            # Get Asset Type UUIDs
+            asset_types_url = f"{self.__base_api}/assetTypes"
+            asset_types_response = self._get(url=asset_types_url)
+            asset_types_data = self._handle_response(asset_types_response)
+            for asset_type in asset_types_data["results"]:
+                metadata["AssetType"][asset_type["name"]] = asset_type["id"]
+
+            # Get Relation Type UUIDs
+            relation_types_url = f"{self.__base_api}/relationTypes"
+            relation_types_response = self._get(url=relation_types_url)
+            relation_types_data = self._handle_response(relation_types_response)
+            for relation_type in relation_types_data["results"]:
+                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
+            resource_roles_url = f"{self.__base_api}/roles"
+            resource_roles_response = self._get(url=resource_roles_url)
+            resource_roles_data = self._handle_response(resource_roles_response)
+            for resource_role in resource_roles_data["results"]:
+                metadata["Responsability"][resource_role["name"]] = resource_role["id"]
+
+            # Get Status UUIDs
+            statuses_url = f"{self.__base_api}/statuses"
+            statuses_response = self._get(url=statuses_url)
+            statuses_data = self._handle_response(statuses_response)
+            for status in statuses_data["results"]:
+                metadata["Status"][status["name"]] = status["id"]
+
+            # Get Attribute UUIDs
+            attributes_url = f"{self.__base_api}/attributeTypes"
+            attributes_response = self._get(url=attributes_url)
+            attributes_data = self._handle_response(attributes_response)
+            for attribute in attributes_data["results"]:
+                metadata["Attribute"][attribute["name"]] = attribute["id"]
+
+            # Get Community UUIDs
+            communities_url = f"{self.__base_api}/communities"
+            communities_response = self._get(url=communities_url)
+            communities_data = self._handle_response(communities_response)
+            for community in communities_data["results"]:
+                metadata["Community"][community["name"]] = community["id"]
+
+            # Get Domain UUIDs
+            domains_url = f"{self.__base_api}/domains"
+            domains_params = {"limit": 1000, "offset": 0}
+            while True:
+                domains_response = self._get(url=domains_url, params=domains_params)
+                domains_data = self._handle_response(domains_response)
+                for domain in domains_data["results"]:
+                    metadata["Domain"][domain["name"]] = domain["id"]
+                if domains_data.get("offset") + domains_data.get(
+                    "limit"
+                ) >= domains_data.get("total"):
+                    break
+                domains_params["offset"] += domains_params["limit"]
+
+            # Get Domain Type UUIDs
+            domain_types_url = f"{self.__base_api}/domainTypes"
+            domain_types_response = self._get(url=domain_types_url)
+            domain_types_data = self._handle_response(domain_types_response)
+            for domain_type in domain_types_data["results"]:
+                metadata["DomainType"][domain_type["name"]] = domain_type["id"]
+
+            logger.info("Collibra UUIDS fetched successfully")
+            return metadata
+
+        except (KeyError, ValueError, AttributeError) as e:
+            logger.error("Error fetching Collibra UUIDs: %s", e)
+            return None

collibra_connector/api/__init__.py

@@ -1,12 +1,8 @@
 from .Asset import Asset
 from .Base import BaseAPI
 from .Community import Community
-from .Domain import Domain
-from .User import User
-from .Responsibility import Responsibility
-from .Workflow import Workflow
-from .Metadata import Metadata
 from .Comment import Comment
+from .Domain import Domain
 from .Exceptions import (
     CollibraAPIError,
     UnauthorizedError,
@@ -14,3 +10,10 @@ from .Exceptions import (
     NotFoundError,
     ServerError
 )
+from .Metadata import Metadata
+from .OutputModule import OutputModule
+from .Relation import Relation
+from .Responsibility import Responsibility
+from .User import User
+from .Utils import Utils
+from .Workflow import Workflow

collibra_connector/connector.py

@@ -10,7 +10,8 @@ from .api import (
     Responsibility,
     Workflow,
     Metadata,
-    Comment
+    Comment,
+    Relation
 )
 
 
@@ -42,6 +43,7 @@ class CollibraConnector():
         self.workflow = Workflow(self)
         self.metadata = Metadata(self)
         self.comment = Comment(self)
+        self.relation = Relation(self)
 
         logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(__name__)

{collibra_connector-1.0.10b0.dist-info → collibra_connector-1.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collibra-connector
-Version: 1.0.10b0
+Version: 1.0.11
 Summary: An UNOFFICIAL standard Python connector for the Collibra Data Governance Center API.
 Author-email: Raül Dalgamonni <rauldalgamonnialonso@gmail.com>
 Project-URL: Homepage, https://github.com/rauldaal/collibra-python-connector

collibra_connector-1.0.11.dist-info/RECORD

@@ -0,0 +1,21 @@
+collibra_connector/__init__.py,sha256=vzF9epFfmdnFjOcr_qZhvfiN9Z0cIBB48xldnvIiKjo,1694
+collibra_connector/connector.py,sha256=oNN8WCI1TI6ffSEfl6_SX7SdrznwA5UeN7U13m-O_hU,2224
+collibra_connector/api/Asset.py,sha256=aPhnsRxzdGGFtaytpLueDgMrELMpIs4cuOJoc2DR-p4,17927
+collibra_connector/api/Base.py,sha256=2gHpieP8N_PK-R63zUv38Wpdfqdw9tHcH59hlXUZOWM,5929
+collibra_connector/api/Comment.py,sha256=4ZzXiKj3pDOw_JRhfrUj-gcF8nZVdW_z7X2jJnq7LcU,4994
+collibra_connector/api/Community.py,sha256=kM4j0LGYCXQygOZ4zHuu10JzJzvXtbUDz9litzKeKUI,12132
+collibra_connector/api/Domain.py,sha256=U0i103g1WceCn9qAFUWDLgeXrtOvfBqX3vMCn4sQqRE,13012
+collibra_connector/api/Exceptions.py,sha256=lX8yU3BnlOiWWifIBKlZdXVZaTI5pvtbrffyDtEUtoc,429
+collibra_connector/api/Metadata.py,sha256=4uzb4vnZuMOg_ISCEnCfmAEVbsIcuD4FvupDlcxrfT4,5213
+collibra_connector/api/OutputModule.py,sha256=97TzIbeoC5V63x5fi5fEcGfviUydwKwJC3NobLuNF5w,1791
+collibra_connector/api/Relation.py,sha256=Hw0PlAQrU2Zv-RAbvHZhZpZb2_m6uDWngx2ySwo_mv0,8079
+collibra_connector/api/Responsibility.py,sha256=PJu1Pe1u8mKzgpGGjzHtZNfRTfpgWWbaQn5bSifZOMo,14123
+collibra_connector/api/User.py,sha256=nPl8q6l-H8hq2sR7gLelXq09jl3QRWFzI_WU3OUIHhQ,7755
+collibra_connector/api/Utils.py,sha256=F8ZWrW8urzDX8QfiL16kWRnBYGRiLqeKUbYXlQpXNiM,4674
+collibra_connector/api/Workflow.py,sha256=rsD9mPut69eEy35TNGf2mUKTrgWUmoakgnsXa85XzNY,10417
+collibra_connector/api/__init__.py,sha256=yBJcKzcRraE-UYbBviisbdvQ1asFBnud5Vo1oJcCv_w,491
+collibra_connector-1.0.11.dist-info/licenses/LICENSE,sha256=6KmWWtAu_q58gerPlrnkgsmGM2l8j6Wc_VL0y4S_ip4,1079
+collibra_connector-1.0.11.dist-info/METADATA,sha256=HXkSXZVVmm1z57evuwsuWoOzFI6lSjrVuhd2hZKSHEU,4081
+collibra_connector-1.0.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+collibra_connector-1.0.11.dist-info/top_level.txt,sha256=Vs-kR64zf__ebL2j3_AEx7rhO6xkwgmHUFRzxlQPgTQ,19
+collibra_connector-1.0.11.dist-info/RECORD,,

collibra_connector-1.0.10b0.dist-info/RECORD

@@ -1,18 +0,0 @@
-collibra_connector/__init__.py,sha256=vzF9epFfmdnFjOcr_qZhvfiN9Z0cIBB48xldnvIiKjo,1694
-collibra_connector/connector.py,sha256=VjoFk0Jouz6vEhP74_9MJv6f8EQxKg_durmkbDLKxbI,2171
-collibra_connector/api/Asset.py,sha256=JJkImmgxYN3zGacSlnXegVnO2xHZqUhTiOyjhQFnvEU,10359
-collibra_connector/api/Base.py,sha256=8sYTPrIlHZP8smfYKl2rWSL63aKqHrtFca_M6gEOVns,5881
-collibra_connector/api/Comment.py,sha256=4ZzXiKj3pDOw_JRhfrUj-gcF8nZVdW_z7X2jJnq7LcU,4994
-collibra_connector/api/Community.py,sha256=yEDbYEmEi7ZhVsodTtCTi2DpEa-NOojgsOK3ihn7wfY,4463
-collibra_connector/api/Domain.py,sha256=CXDVheIcJ_7cU_h_gOozAg2nliFoAEMoeprZRIba_i8,4605
-collibra_connector/api/Exceptions.py,sha256=lX8yU3BnlOiWWifIBKlZdXVZaTI5pvtbrffyDtEUtoc,429
-collibra_connector/api/Metadata.py,sha256=lOVXu0pcHSZNhInb4nR4q7lBB1MwtRuoL4Qb-2sr8aI,5213
-collibra_connector/api/Responsibility.py,sha256=s9W2oa11CS2_CEDYrgdjpHOjX83ysXnQ9CNDUFlzGTQ,13372
-collibra_connector/api/User.py,sha256=nPl8q6l-H8hq2sR7gLelXq09jl3QRWFzI_WU3OUIHhQ,7755
-collibra_connector/api/Workflow.py,sha256=rsD9mPut69eEy35TNGf2mUKTrgWUmoakgnsXa85XzNY,10417
-collibra_connector/api/__init__.py,sha256=61ZNTfMTMRMPCy8WABptw152RriLZ_B1HV455vipFDk,396
-collibra_connector-1.0.10b0.dist-info/licenses/LICENSE,sha256=6KmWWtAu_q58gerPlrnkgsmGM2l8j6Wc_VL0y4S_ip4,1079
-collibra_connector-1.0.10b0.dist-info/METADATA,sha256=jIfBXEZlypct5cyb9E1H878_-MhF9gbxesqoOQTEPUQ,4083
-collibra_connector-1.0.10b0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-collibra_connector-1.0.10b0.dist-info/top_level.txt,sha256=Vs-kR64zf__ebL2j3_AEx7rhO6xkwgmHUFRzxlQPgTQ,19
-collibra_connector-1.0.10b0.dist-info/RECORD,,