collibra-connector 1.0.9__tar.gz → 1.0.10a0__tar.gz

collibra_connector-1.0.10a0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: collibra-connector
+Version: 1.0.10a0
+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
+Project-URL: Bug Tracker, https://github.com/rauldaal/collibra-python-connector
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.20.0
+Dynamic: license-file
+
+# Collibra Python Connector
+
+An **UNOFFICIAL** comprehensive Python connector for the Collibra Data Governance Center API.
+
+## Features
+
+- 🚀 **Complete API Coverage**: Asset, Community, Domain, User, Responsibility, Workflow, Metadata, and Comment management
+- 🔄 **Automatic Retry Logic**: Built-in retry mechanism for robust API calls
+- ✅ **Input Validation**: Comprehensive parameter validation with clear error messages
+- 🏗️ **Clean Architecture**: Well-structured, extensible codebase with separation of concerns
+- 📝 **Type Hints**: Full type annotations for better IDE support
+- 🛡️ **Error Handling**: Custom exception hierarchy for different error types
+- 🔧 **Utility Functions**: Helper methods for complex operations and bulk operations
+
+## Installation
+
+```bash
+pip install collibra-connector
+```
+
+## Quick Start
+
+```python
+from collibra_connector import CollibraConnector
+
+# Initialize the connector
+connector = CollibraConnector(
+    api="https://your-collibra-instance.com",
+    username="your-username",
+    password="your-password",
+    timeout=30
+)
+
+# Test connection
+if connector.test_connection():
+    print("Connected successfully!")
+
+# Get all metadata
+metadata = connector.metadata.get_collibra_metadata()
+print(f"Found {len(metadata['AssetType'])} asset types")
+
+# Find communities
+communities = connector.community.find_communities()
+for community in communities.get("results", []):
+    print(f"Community: {community['name']}")
+```
+
+## API Reference
+
+### Assets
+
+```python
+# Get an asset
+asset = connector.asset.get_asset("asset-uuid")
+
+# Create an asset
+new_asset = connector.asset.add_asset(
+    name="My New Asset",
+    domain_id="domain-uuid",
+    display_name="My Asset Display Name",
+    type_id="asset-type-uuid"
+)
+
+# Find assets
+assets = connector.asset.find_assets(
+    community_id="community-uuid",
+    asset_type_ids=["type-uuid-1", "type-uuid-2"]
+)
+```
+
+### Communities
+
+```python
+# Get a community
+community = connector.community.get_community("community-uuid")
+
+# Find communities
+communities = connector.community.find_communities()
+```
+
+### Domains
+
+```python
+# Get a domain
+domain = connector.domain.get_domain("domain-uuid")
+
+# Create a domain
+new_domain = connector.domain.create_domain(
+    name="My New Domain",
+    community_id="community-uuid"
+)
+```
+
+### Users
+
+```python
+# Get user by username
+user_id = connector.user.get_user_by_username("username")
+
+# Create a new user
+new_user = connector.user.create_user(
+    username="newuser",
+    email_address="newuser@example.com"
+)
+```
+
+### Complete Documentation
+
+For comprehensive API documentation and examples, see the full README with all available methods for:
+- Asset management (CRUD operations, attributes, activities)
+- Community and Domain operations
+- User management
+- Responsibility assignments
+- Workflow operations
+- Comment management
+- Metadata retrieval
+- Utility functions for bulk operations
+
+## Error Handling
+
+```python
+from collibra_connector.api.Exceptions import (
+    CollibraAPIError,
+    UnauthorizedError,
+    NotFoundError
+)
+
+try:
+    asset = connector.asset.get_asset("invalid-uuid")
+except NotFoundError:
+    print("Asset not found")
+except CollibraAPIError as e:
+    print(f"API error: {e}")
+```
+
+## Requirements
+
+- Python 3.8+
+- requests >= 2.20.0

collibra_connector-1.0.10a0/README.md

@@ -0,0 +1,139 @@
+# Collibra Python Connector
+
+An **UNOFFICIAL** comprehensive Python connector for the Collibra Data Governance Center API.
+
+## Features
+
+- 🚀 **Complete API Coverage**: Asset, Community, Domain, User, Responsibility, Workflow, Metadata, and Comment management
+- 🔄 **Automatic Retry Logic**: Built-in retry mechanism for robust API calls
+- ✅ **Input Validation**: Comprehensive parameter validation with clear error messages
+- 🏗️ **Clean Architecture**: Well-structured, extensible codebase with separation of concerns
+- 📝 **Type Hints**: Full type annotations for better IDE support
+- 🛡️ **Error Handling**: Custom exception hierarchy for different error types
+- 🔧 **Utility Functions**: Helper methods for complex operations and bulk operations
+
+## Installation
+
+```bash
+pip install collibra-connector
+```
+
+## Quick Start
+
+```python
+from collibra_connector import CollibraConnector
+
+# Initialize the connector
+connector = CollibraConnector(
+    api="https://your-collibra-instance.com",
+    username="your-username",
+    password="your-password",
+    timeout=30
+)
+
+# Test connection
+if connector.test_connection():
+    print("Connected successfully!")
+
+# Get all metadata
+metadata = connector.metadata.get_collibra_metadata()
+print(f"Found {len(metadata['AssetType'])} asset types")
+
+# Find communities
+communities = connector.community.find_communities()
+for community in communities.get("results", []):
+    print(f"Community: {community['name']}")
+```
+
+## API Reference
+
+### Assets
+
+```python
+# Get an asset
+asset = connector.asset.get_asset("asset-uuid")
+
+# Create an asset
+new_asset = connector.asset.add_asset(
+    name="My New Asset",
+    domain_id="domain-uuid",
+    display_name="My Asset Display Name",
+    type_id="asset-type-uuid"
+)
+
+# Find assets
+assets = connector.asset.find_assets(
+    community_id="community-uuid",
+    asset_type_ids=["type-uuid-1", "type-uuid-2"]
+)
+```
+
+### Communities
+
+```python
+# Get a community
+community = connector.community.get_community("community-uuid")
+
+# Find communities
+communities = connector.community.find_communities()
+```
+
+### Domains
+
+```python
+# Get a domain
+domain = connector.domain.get_domain("domain-uuid")
+
+# Create a domain
+new_domain = connector.domain.create_domain(
+    name="My New Domain",
+    community_id="community-uuid"
+)
+```
+
+### Users
+
+```python
+# Get user by username
+user_id = connector.user.get_user_by_username("username")
+
+# Create a new user
+new_user = connector.user.create_user(
+    username="newuser",
+    email_address="newuser@example.com"
+)
+```
+
+### Complete Documentation
+
+For comprehensive API documentation and examples, see the full README with all available methods for:
+- Asset management (CRUD operations, attributes, activities)
+- Community and Domain operations
+- User management
+- Responsibility assignments
+- Workflow operations
+- Comment management
+- Metadata retrieval
+- Utility functions for bulk operations
+
+## Error Handling
+
+```python
+from collibra_connector.api.Exceptions import (
+    CollibraAPIError,
+    UnauthorizedError,
+    NotFoundError
+)
+
+try:
+    asset = connector.asset.get_asset("invalid-uuid")
+except NotFoundError:
+    print("Asset not found")
+except CollibraAPIError as e:
+    print(f"API error: {e}")
+```
+
+## Requirements
+
+- Python 3.8+
+- requests >= 2.20.0

collibra_connector-1.0.10a0/collibra_connector/api/Asset.py

@@ -0,0 +1,272 @@
+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):
+        """
+        Makes a GET request to the asset API.
+        :param url: The URL to send the GET request to.
+        :param params: Optional parameters to include in the GET request.
+        :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 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)
+
+    def add_asset(
+        self,
+        name: str,
+        domain_id: str,
+        display_name: str = None,
+        type_id: str = None,
+        _id: str = None,
+        status_id: str = None,
+        excluded_from_auto_hyperlink: bool = False,
+        type_public_id: str = None,
+    ):
+        """
+        Adds a new asset.
+        :param name: The name of the asset.
+        :param domain_id: The ID of the domain to which the asset belongs.
+        :param display_name: Optional display name for the asset.
+        :param type_id: Optional type ID for the asset.
+        :param id: Optional ID for the asset.
+        :param status_id: Optional status ID for the asset.
+        :param excluded_from_auto_hyperlink: Whether the asset is excluded from auto hyperlinking.
+        :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,
+            "displayName": display_name,
+            "typeId": type_id,
+            "id": id,
+            "statusId": status_id,
+            "excludedFromAutoHyperlink": excluded_from_auto_hyperlink,
+            "typePublicId": type_public_id
+        }
+        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", [])