collibra-connector 1.0.10a0__py3-none-any.whl → 1.0.10rc0__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/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

@@ -114,3 +114,198 @@ class Domain(BaseAPI):
 
         response = self._get(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/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/__init__.py

@@ -7,6 +7,7 @@ from .Responsibility import Responsibility
 from .Workflow import Workflow
 from .Metadata import Metadata
 from .Comment import Comment
+from .Relation import Relation
 from .Exceptions import (
     CollibraAPIError,
     UnauthorizedError,

collibra_connector/connector.py

@@ -10,9 +10,9 @@ from .api import (
     Responsibility,
     Workflow,
     Metadata,
-    Comment
+    Comment,
+    Relation
 )
-from .api.Utils import CollibraUtils
 
 
 class CollibraConnector():
@@ -43,7 +43,7 @@ class CollibraConnector():
         self.workflow = Workflow(self)
         self.metadata = Metadata(self)
         self.comment = Comment(self)
-        self.utils = CollibraUtils(self)
+        self.relation = Relation(self)
 
         logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(__name__)
@@ -75,3 +75,7 @@ class CollibraConnector():
     @property
     def base_url(self):
         return self.__base_url
+
+    @property
+    def timeout(self):
+        return self.__timeout

{collibra_connector-1.0.10a0.dist-info → collibra_connector-1.0.10rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collibra-connector
-Version: 1.0.10a0
+Version: 1.0.10rc0
 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.10rc0.dist-info/RECORD

@@ -0,0 +1,19 @@
+collibra_connector/__init__.py,sha256=vzF9epFfmdnFjOcr_qZhvfiN9Z0cIBB48xldnvIiKjo,1694
+collibra_connector/connector.py,sha256=oNN8WCI1TI6ffSEfl6_SX7SdrznwA5UeN7U13m-O_hU,2224
+collibra_connector/api/Asset.py,sha256=uGv5S0jPJ8gTeZCh4AcmttLKW0gXk8yeROM3MdeCD6w,17935
+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=kM4j0LGYCXQygOZ4zHuu10JzJzvXtbUDz9litzKeKUI,12132
+collibra_connector/api/Domain.py,sha256=tNqqNiATjiAiPe_lfWebO_8vxtmr3fFds8sd-hy_eD4,12991
+collibra_connector/api/Exceptions.py,sha256=lX8yU3BnlOiWWifIBKlZdXVZaTI5pvtbrffyDtEUtoc,429
+collibra_connector/api/Metadata.py,sha256=lOVXu0pcHSZNhInb4nR4q7lBB1MwtRuoL4Qb-2sr8aI,5213
+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/Workflow.py,sha256=rsD9mPut69eEy35TNGf2mUKTrgWUmoakgnsXa85XzNY,10417
+collibra_connector/api/__init__.py,sha256=WTeTeK4LS2fQXcNyAg3yKjlf2jTbLnaOusNRZItQPWM,427
+collibra_connector-1.0.10rc0.dist-info/licenses/LICENSE,sha256=6KmWWtAu_q58gerPlrnkgsmGM2l8j6Wc_VL0y4S_ip4,1079
+collibra_connector-1.0.10rc0.dist-info/METADATA,sha256=NU4lLlGO1ao73yx8YiJZYbeaJ1Cy3aZyL4omFpy7kzI,4084
+collibra_connector-1.0.10rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+collibra_connector-1.0.10rc0.dist-info/top_level.txt,sha256=Vs-kR64zf__ebL2j3_AEx7rhO6xkwgmHUFRzxlQPgTQ,19
+collibra_connector-1.0.10rc0.dist-info/RECORD,,

collibra_connector-1.0.10a0.dist-info/RECORD

@@ -1,18 +0,0 @@
-collibra_connector/__init__.py,sha256=vzF9epFfmdnFjOcr_qZhvfiN9Z0cIBB48xldnvIiKjo,1694
-collibra_connector/connector.py,sha256=8RONkOmdP2J-4-AXbTT9en6sYN9kfxNX5D9eu8GBFaM,2181
-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.10a0.dist-info/licenses/LICENSE,sha256=6KmWWtAu_q58gerPlrnkgsmGM2l8j6Wc_VL0y4S_ip4,1079
-collibra_connector-1.0.10a0.dist-info/METADATA,sha256=K5ANgMlX-DV3pEmcTditAyVz4BdFZ_j18FghxVtHIi4,4083
-collibra_connector-1.0.10a0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-collibra_connector-1.0.10a0.dist-info/top_level.txt,sha256=Vs-kR64zf__ebL2j3_AEx7rhO6xkwgmHUFRzxlQPgTQ,19
-collibra_connector-1.0.10a0.dist-info/RECORD,,