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

collibra_connector/__init__.py

@@ -1,27 +1,27 @@
 #
 #
-#                           ███                   
-#                     ██    ███   ███             
-#                    ████         ███             
-#              ███   ████   ██    ███   ████      
-#              ███   ████   ███   ███   ████      
-#                           ███   ███             
-#                           ███   ███             
-#          ██████████████   ███   ███   ████████  
-#           ███████████      █    ███    ██████   
+#                           ███
+#                     ██    ███   ███
+#                    ████         ███
+#              ███   ████   ██    ███   ████
+#              ███   ████   ███   ███   ████
+#                           ███   ███
+#                           ███   ███
+#          ██████████████   ███   ███   ████████
+#           ███████████      █    ███    ██████
 #
-#         ███  █████████████   ████████████   ███ 
-#         ███  █████████████   ████████████   ███ 
+#         ███  █████████████   ████████████   ███
+#         ███  █████████████   ████████████   ███
 #
-#           ██████           █     █████████████ 
-#          ███████   ████   ███   ██████████████  
-#                    ████   ███                   
-#                    ████   ███                   
-#              ███   ████   ███   ███   ████      
-#               ██   ████   ██    ███    ██       
-#                    ████         ███             
-#                     ██    ███   ███             
-#                            █                
+#           ██████           █     █████████████
+#          ███████   ████   ███   ██████████████
+#                    ████   ███
+#                    ████   ███
+#              ███   ████   ███   ███   ████
+#               ██   ████   ██    ███    ██
+#                    ████         ███
+#                     ██    ███   ███
+#                            █
 #
 #
 """
@@ -36,4 +36,4 @@ This library provides a simple interface to handle connection and URLs
 
 from .connector import CollibraConnector
 
-__version__ = "0.1.0"
+__version__ = "0.1.0"

collibra_connector/api/Asset.py

@@ -1,11 +1,13 @@
+import uuid
 from .Base import BaseAPI
 
+
 class Asset(BaseAPI):
     def __init__(self, connector):
         super().__init__(connector)
         self.__base_api = connector.api + "/assets"
 
-    def __get(self, url: str = None, params: dict = None, headers: dict = None):
+    def _get(self, url: str = None, params: dict = None, headers: dict = None):
         """
         Makes a GET request to the asset API.
         :param url: The URL to send the GET request to.
@@ -13,28 +15,16 @@ class Asset(BaseAPI):
         :param headers: Optional headers to include in the GET request.
         :return: The response from the GET request.
         """
-        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)
+        return super()._get(self.__base_api if not url else url, params, headers)
 
-    def __handle_response(self, response):
-        return super().__handle_response(response)
-    
     def get_asset(self, asset_id):
         """
         Retrieves an asset by its ID.
         :param asset_id: The ID of the asset to retrieve.
         :return: Asset details.
         """
-        response = self.__get(url=f"{self.__base_api}/{asset_id}")
-        return self.__handle_response(response)
+        response = self._get(url=f"{self.__base_api}/{asset_id}")
+        return self._handle_response(response)
 
     def add_asset(
         self,
@@ -42,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,
@@ -59,6 +49,30 @@ class Asset(BaseAPI):
         :param type_public_id: Optional public ID for the asset type.
         :return: Details of the created asset.
         """
+        # Parameter type validation
+        if not name or not domain_id:
+            raise ValueError("Name and domain_id are required parameters.")
+        if not isinstance(excluded_from_auto_hyperlink, bool):
+            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 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:
+            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.")
+        if type_id and self._uuid_validation(type_id) is False:
+            raise ValueError("type_id must be a valid UUID.")
+        if status_id and self._uuid_validation(status_id) is False:
+            raise ValueError("status_id must be a valid UUID.")
+
         data = {
             "name": name,
             "domainId": domain_id,
@@ -69,5 +83,190 @@ class Asset(BaseAPI):
             "excludedFromAutoHyperlink": excluded_from_auto_hyperlink,
             "typePublicId": type_public_id
         }
-        response = self.__post(url=self.__base_api, data=data)
-        return self.__handle_response(response)
+        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

@@ -1,3 +1,4 @@
+import re
 import requests
 from .Exceptions import (
     UnauthorizedError,
@@ -6,7 +7,9 @@ from .Exceptions import (
     ServerError
 )
 
+
 class BaseAPI:
+
     def __init__(self, connector):
         self.__connector = connector
         self.__base_api = connector.api
@@ -16,7 +19,7 @@ class BaseAPI:
         }
         self.__params = None
 
-    def __get(self, url: str = None, params: dict = None, headers: dict = None):
+    def _get(self, url: str = None, params: dict = None, headers: dict = None):
         """
         Makes a GET request to the specified URL.
         :param url: The URL to send the GET request to.
@@ -31,10 +34,11 @@ 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):
+    def _post(self, url: str, data: dict, headers: dict = None):
         """
         Makes a POST request to the specified URL with the given data.
         :param url: The URL to send the POST request to.
@@ -51,22 +55,99 @@ class BaseAPI:
             url,
             auth=self.__connector.auth,
             json=data,
-            headers=self.__header
+            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 __handle_response(self, response):
+    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):
         """
         Handles the response from the API.
         :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")
+            raise UnauthorizedError("Unauthorized access - invalid credentials: " + response.text)
         elif response.status_code == 403:
-            raise ForbiddenError("Forbidden access - insufficient permissions")
+            raise ForbiddenError("Forbidden access - insufficient permissions: " + response.text)
         elif response.status_code == 404:
-            raise NotFoundError("The specified resource was not found")
+            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")
+            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, 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)