collibra-connector 1.0.10b0__tar.gz → 1.0.11__tar.gz

{collibra_connector-1.0.10b0 → collibra_connector-1.0.11}/PKG-INFO

@@ -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.10b0 → collibra_connector-1.0.11}/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-1.0.10b0 → collibra_connector-1.0.11}/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-1.0.11/collibra_connector/api/Community.py

@@ -0,0 +1,292 @@
+import uuid
+from .Base import BaseAPI
+
+
+class Community(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api + "/communities"
+
+    def get_community(self, community_id: str):
+        """
+        Get a community by its ID.
+        :param community_id: The ID of the community to retrieve.
+        :return: Community details.
+        """
+        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._get(url=f"{self.__base_api}/{community_id}")
+        return self._handle_response(response)
+
+    def find_communities(
+        self,
+        sort_field: str = "NAME",
+        count_limit: int = -1,
+        cursor: str = None,
+        exclude_meta: bool = True,
+        limit: int = 0,
+        name: str = None,
+        name_match_mode: str = "ANYWHERE",
+        offset: int = 0,
+        parent_id: str = None,
+        sort_order: str = "ASC"
+    ):
+        """
+        Find communities matching the given search criteria.
+        :param sort_field: Field to sort results by. Options: NAME, CREATED_BY, CREATED_ON, LAST_MODIFIED, ID
+        :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 communities (not manually created by users).
+        :param limit: Maximum results to retrieve. 0 uses default, max 1000.
+        :param name: Name of community 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 parent_id: Parent community ID to filter by.
+        :param sort_order: Sort order. Options: ASC, DESC
+        :return: List of communities matching criteria.
+        """
+        # Validate sort_field
+        valid_sort_fields = ["NAME", "CREATED_BY", "CREATED_ON", "LAST_MODIFIED", "ID"]
+        if sort_field not in valid_sort_fields:
+            raise ValueError(f"sort_field must be one of: {', '.join(valid_sort_fields)}")
+
+        # 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 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 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 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 sort_field != "NAME":
+            params["sortField"] = sort_field
+        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 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 parent_id is not None:
+            params["parentId"] = parent_id
+        if sort_order != "ASC":
+            params["sortOrder"] = sort_order
+
+        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)