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

collibra_connector/api/Asset.py

@@ -17,21 +17,6 @@ class Asset(BaseAPI):
         """
         return super()._get(self.__base_api if not url else url, params, headers)
 
-    def _post(self, url: str, data: dict):
-        """
-        Makes a POST request to the asset API.
-        :param url: The URL to send the POST request to.
-        :param data: The data to send in the POST request.
-        :return: The response from the POST request.
-        """
-        return super()._post(url, data)
-
-    def _handle_response(self, response):
-        return super()._handle_response(response)
-
-    def _uuid_validation(self, id):
-        return super()._uuid_validation(id)
-
     def get_asset(self, asset_id):
         """
         Retrieves an asset by its ID.
@@ -47,7 +32,7 @@ class Asset(BaseAPI):
         domain_id: str,
         display_name: str = None,
         type_id: str = None,
-        id: str = None,
+        _id: str = None,
         status_id: str = None,
         excluded_from_auto_hyperlink: bool = False,
         type_public_id: str = None,
@@ -71,15 +56,15 @@ class Asset(BaseAPI):
             raise ValueError("excluded_from_auto_hyperlink must be a boolean value.")
         if type_id and not isinstance(type_id, str):
             raise ValueError("type_id must be a string if provided.")
-        if id and not isinstance(id, str):
-            raise ValueError("id must be a string if provided.")
+        if _id and not isinstance(_id, str):
+            raise ValueError("_id must be a string if provided.")
         if status_id and not isinstance(status_id, str):
             raise ValueError("status_id must be a string if provided.")
         if type_public_id and not isinstance(type_public_id, str):
             raise ValueError("type_public_id must be a string if provided.")
 
         # Check Ids are UUIDS
-        if id and self._uuid_validation(id) is False:
+        if _id and self._uuid_validation(_id) is False:
             raise ValueError("id must be a valid UUID.")
         if domain_id and self._uuid_validation(domain_id) is False:
             raise ValueError("domain_id must be a valid UUID.")
@@ -100,3 +85,188 @@ class Asset(BaseAPI):
         }
         response = self._post(url=self.__base_api, data=data)
         return self._handle_response(response)
+
+    def update_asset_properties(
+        self,
+        asset_id: str,
+        name: str = None,
+        display_name: str = None,
+        type_id: str = None,
+        status_id: str = None,
+        domain_id: str = None,
+        excluded_from_auto_hyperlinking: bool = None,
+        type_public_id: str = None
+    ):
+        """
+        Update asset properties.
+        :param asset_id: The ID of the asset to update.
+        :param name: Optional new name for the asset.
+        :param display_name: Optional new display name.
+        :param type_id: Optional new type ID.
+        :param status_id: Optional new status ID.
+        :param domain_id: Optional new domain ID.
+        :param excluded_from_auto_hyperlinking: Optional auto-hyperlinking setting.
+        :param type_public_id: Optional new type public ID.
+        :return: Updated asset details.
+        """
+        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
+
+        # Validate UUID fields if provided
+        uuid_fields = [
+            ("type_id", type_id),
+            ("status_id", status_id),
+            ("domain_id", domain_id)
+        ]
+
+        for field_name, field_value in uuid_fields:
+            if field_value:
+                if not isinstance(field_value, str):
+                    raise ValueError(f"{field_name} must be a string")
+                try:
+                    uuid.UUID(field_value)
+                except ValueError as exc:
+                    raise ValueError(f"{field_name} must be a valid UUID") from exc
+
+        data = {
+            "id": asset_id,
+            "name": name,
+            "displayName": display_name,
+            "typeId": type_id,
+            "statusId": status_id,
+            "domainId": domain_id,
+            "excludedFromAutoHyperlinking": excluded_from_auto_hyperlinking,
+            "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
+        )
+
+        return self._handle_response(response)
+
+    def update_asset_attribute(self, asset_id: str, attribute_id: str, value):
+        """
+        Update an asset attribute.
+        :param asset_id: The ID of the asset.
+        :param attribute_id: The ID of the attribute type.
+        :param value: The new value for the attribute.
+        :return: The response from updating the attribute.
+        """
+        if not all([asset_id, attribute_id]):
+            raise ValueError("asset_id and attribute_id are required")
+
+        for param_name, param_value in [("asset_id", asset_id), ("attribute_id", attribute_id)]:
+            if not isinstance(param_value, str):
+                raise ValueError(f"{param_name} must be a string")
+            try:
+                uuid.UUID(param_value)
+            except ValueError as exc:
+                raise ValueError(f"{param_name} must be a valid UUID") from exc
+
+        data = {
+            "values": [value],
+            "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
+        )
+
+        return self._handle_response(response)
+
+    def find_assets(
+        self,
+        community_id: str = None,
+        asset_type_ids: list = None,
+        domain_id: str = None,
+        limit: int = 1000
+    ):
+        """
+        Find assets with optional filters.
+        :param community_id: Optional community ID to filter by.
+        :param asset_type_ids: Optional list of asset type IDs to filter by.
+        :param domain_id: Optional domain ID to filter by.
+        :param limit: Maximum number of results per page.
+        :return: List of assets matching the criteria.
+        """
+        params = {"limit": limit}
+
+        if community_id:
+            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
+            params["communityId"] = community_id
+
+        if asset_type_ids:
+            if not isinstance(asset_type_ids, list):
+                raise ValueError("asset_type_ids must be a list")
+            for type_id in asset_type_ids:
+                if not isinstance(type_id, str):
+                    raise ValueError("All asset_type_ids must be strings")
+                try:
+                    uuid.UUID(type_id)
+                except ValueError as exc:
+                    raise ValueError("All asset_type_ids must be valid UUIDs") from exc
+            params["typeIds"] = asset_type_ids
+
+        if domain_id:
+            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
+            params["domainId"] = domain_id
+
+        response = self._get(params=params)
+        return self._handle_response(response)
+
+    def get_asset_activities(self, asset_id: str, limit: int = 50):
+        """
+        Get activities for a specific asset.
+        :param asset_id: The ID of the asset.
+        :param limit: Maximum number of activities to retrieve.
+        :return: List of activities for 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
+
+        params = {
+            "contextId": asset_id,
+            "resourceTypes": ["Asset"],
+            "limit": limit
+        }
+
+        response = self._get(url=f"{self.__base_api}/activities", params=params)
+        result = self._handle_response(response)
+        return result.get("results", [])

collibra_connector/api/Base.py

@@ -9,6 +9,7 @@ from .Exceptions import (
 
 
 class BaseAPI:
+
     def __init__(self, connector):
         self.__connector = connector
         self.__base_api = connector.api
@@ -33,7 +34,8 @@ class BaseAPI:
             url,
             auth=self.__connector.auth,
             params=params,
-            headers=headers
+            headers=headers,
+            timeout=self.__connector.timeout
         )
 
     def _post(self, url: str, data: dict, headers: dict = None):
@@ -53,7 +55,65 @@ class BaseAPI:
             url,
             auth=self.__connector.auth,
             json=data,
-            headers=headers
+            headers=headers,
+            timeout=self.__connector.timeout
+        )
+
+    def _put(self, url: str, data: dict, headers: dict = None):
+        """
+        Makes a PUT request to the specified URL with the given data.
+        :param url: The URL to send the PUT request to.
+        :param data: The data to send in the PUT request.
+        :return: The response from the PUT request.
+        """
+        url = self.__base_api if not url else url
+        headers = self.__header if not headers else headers
+        if not isinstance(data, dict):
+            raise ValueError("Data must be a dictionary")
+        if not data:
+            raise ValueError("Data cannot be empty")
+        return requests.put(
+            url,
+            auth=self.__connector.auth,
+            json=data,
+            headers=headers,
+            timeout=self.__connector.timeout
+        )
+
+    def _delete(self, url: str, headers: dict = None):
+        """
+        Makes a DELETE request to the specified URL.
+        :param url: The URL to send the DELETE request to.
+        :return: The response from the DELETE request.
+        """
+        url = self.__base_api if not url else url
+        headers = self.__header if not headers else headers
+        return requests.delete(
+            url,
+            auth=self.__connector.auth,
+            headers=headers,
+            timeout=self.__connector.timeout
+        )
+
+    def _patch(self, url: str, data: dict, headers: dict = None):
+        """
+        Makes a PATCH request to the specified URL with the given data.
+        :param url: The URL to send the PATCH request to.
+        :param data: The data to send in the PATCH request.
+        :return: The response from the PATCH request.
+        """
+        url = self.__base_api if not url else url
+        headers = self.__header if not headers else headers
+        if not isinstance(data, dict):
+            raise ValueError("Data must be a dictionary")
+        if not data:
+            raise ValueError("Data cannot be empty")
+        return requests.patch(
+            url,
+            auth=self.__connector.auth,
+            json=data,
+            headers=headers,
+            timeout=self.__connector.timeout
         )
 
     def _handle_response(self, response):
@@ -62,22 +122,32 @@ class BaseAPI:
         :param response: The response object from the API request.
         :return: The JSON content of the response if successful, otherwise raises an error.
         """
-        if response.status_code == 200 or response.status_code == 201:
-            return response.json()
+        if response.status_code in [200, 201]:
+            # Check if response has content before trying to parse JSON
+            if response.text.strip():
+                try:
+                    return response.json()
+                except ValueError as e:
+                    raise ValueError(f"Invalid JSON response: {e}") from e
+            return {}
         elif response.status_code == 401:
-            raise UnauthorizedError("Unauthorized access - invalid credentials" + response.text)
+            raise UnauthorizedError("Unauthorized access - invalid credentials: " + response.text)
         elif response.status_code == 403:
-            raise ForbiddenError("Forbidden access - insufficient permissions" + response.text)
+            raise ForbiddenError("Forbidden access - insufficient permissions: " + response.text)
         elif response.status_code == 404:
-            raise NotFoundError("The specified resource was not found" + response.text)
+            raise NotFoundError("The specified resource was not found: " + response.text)
         elif response.status_code >= 500:
-            raise ServerError("Internal server error - something went wrong on the server" + response.text)
+            raise ServerError("Internal server error - something went wrong on the server: " + response.text)
+        else:
+            raise Exception(f"Unexpected status code {response.status_code}: {response.text}")
 
     def _uuid_validation(self, id: str):
         """
         Validates if the provided ID is a valid UUID.
         :param id: The ID to validate.
-        :return: True if the ID is a valid UUID, otherwise raises ValueError.
+        :return: True if the ID is a valid UUID, False otherwise.
         """
+        if not id or not isinstance(id, str):
+            return False
         pattern = re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$")
         return bool(pattern.match(id))

collibra_connector/api/Comment.py

@@ -0,0 +1,125 @@
+import uuid
+from .Base import BaseAPI
+
+
+class Comment(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api + "/comments"
+
+    def add_comment(self, asset_id: str, content: str):
+        """
+        Add a comment to an asset.
+        :param asset_id: The ID of the asset to comment on.
+        :param content: The content of the comment.
+        :return: The created comment details.
+        """
+        if not asset_id or not content:
+            raise ValueError("asset_id and content are required parameters")
+        if not isinstance(asset_id, str) or not isinstance(content, str):
+            raise ValueError("asset_id and content must be strings")
+
+        try:
+            uuid.UUID(asset_id)
+        except ValueError as exc:
+            raise ValueError("asset_id must be a valid UUID") from exc
+
+        data = {
+            "content": content,
+            "baseResource": {
+                "id": asset_id,
+                "resourceType": "Asset"
+            },
+        }
+
+        response = self._post(url=self.__base_api, data=data)
+        return self._handle_response(response)
+
+    def find_comments(
+        self,
+        base_resource_id: str = None,
+        count_limit: int = -1,
+        limit: int = 0,
+        offset: int = 0,
+        parent_id: str = None,
+        resolved: bool = None,
+        root_comment: bool = None,
+        sort_order: str = "DESC",
+        user_id: str = None,
+        user_threads: bool = False
+    ):
+        """
+        Find comments matching the given search criteria.
+        :param base_resource_id: The ID of the resource which the searched comments refer to.
+        :param count_limit: Limit the number of elements counted. -1 counts everything, 0 skips count.
+        :param limit: Maximum number of results to retrieve. 0 uses default, max 1000.
+        :param offset: First result to retrieve. 0 starts from beginning.
+        :param parent_id: ID of the comment for which reply comments should be searched.
+        :param resolved: Whether the searched comments should be resolved.
+        :param root_comment: Whether the searched comments should be root comments.
+        :param sort_order: Sort order on creation date. 'ASC' or 'DESC'.
+        :param user_id: ID of the user to filter comments by.
+        :param user_threads: Whether to search for root comments created by or mentioning the user.
+        :return: List of comments matching the criteria.
+        """
+        # Validate base_resource_id if provided
+        if base_resource_id is not None:
+            if not isinstance(base_resource_id, str):
+                raise ValueError("base_resource_id must be a string")
+            try:
+                uuid.UUID(base_resource_id)
+            except ValueError as exc:
+                raise ValueError("base_resource_id must be a valid UUID") from exc
+
+        # 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 user_id if provided
+        if user_id is not None:
+            if not isinstance(user_id, str):
+                raise ValueError("user_id must be a string")
+            try:
+                uuid.UUID(user_id)
+            except ValueError as exc:
+                raise ValueError("user_id must be a valid UUID") from exc
+
+        # 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")
+
+        # Build parameters - only include non-None values
+        params = {}
+
+        if base_resource_id is not None:
+            params["baseResourceId"] = base_resource_id
+        if count_limit != -1:  # Only add if different from default
+            params["countLimit"] = count_limit
+        if limit != 0:  # Only add if different from default
+            params["limit"] = limit
+        if offset != 0:  # Only add if different from default
+            params["offset"] = offset
+        if parent_id is not None:
+            params["parentId"] = parent_id
+        if resolved is not None:
+            params["resolved"] = resolved
+        if root_comment is not None:
+            params["rootComment"] = root_comment
+        if sort_order != "DESC":  # Only add if different from default
+            params["sortOrder"] = sort_order
+        if user_id is not None:
+            params["userId"] = user_id
+        if user_threads is not False:  # Only add if different from default
+            params["userThreads"] = user_threads
+
+        response = self._get(params=params)
+        return self._handle_response(response)

collibra_connector/api/Community.py

@@ -0,0 +1,112 @@
+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)