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

collibra_connector/api/User.py

@@ -0,0 +1,203 @@
+import uuid
+from .Base import BaseAPI
+
+
+class User(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api + "/users"
+
+    def get_user(self, user_id: str):
+        """
+        Get user information by user ID.
+        :param user_id: The ID of the user.
+        :return: User details.
+        """
+        if not user_id:
+            raise ValueError("user_id is required")
+        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
+
+        response = self._get(url=f"{self.__base_api}/{user_id}")
+        return self._handle_response(response)
+
+    def get_user_by_username(self, username: str):
+        """
+        Get user ID by username (convenience method).
+        :param username: The username to search for.
+        :return: User ID if found, None otherwise.
+        """
+        if not username:
+            raise ValueError("username is required")
+        if not isinstance(username, str):
+            raise ValueError("username must be a string")
+
+        result = self.find_users(
+            name=username,
+            name_search_fields=["USERNAME"],
+            include_disabled=True,
+            limit=1
+        )
+
+        if result.get("total", 0) > 0:
+            return result.get("results", [{}])[0].get("id", "")
+        return None
+
+    def create_user(self, username: str, email_address: str):
+        """
+        Create a new user.
+        :param username: The username for the new user.
+        :param email_address: The email address for the new user.
+        :return: The created user details.
+        """
+        if not username or not email_address:
+            raise ValueError("username and email_address are required")
+        if not isinstance(username, str) or not isinstance(email_address, str):
+            raise ValueError("username and email_address must be strings")
+
+        data = {
+            "userName": username,
+            "emailAddress": email_address
+        }
+
+        response = self._post(url=self.__base_api, data=data)
+        return self._handle_response(response)
+
+    def find_users(
+        self,
+        count_limit: int = -1,
+        group_id: str = None,
+        include_disabled: bool = None,
+        limit: int = 0,
+        name: str = None,
+        name_search_fields: list = None,
+        offset: int = 0,
+        only_logged_in: bool = None,
+        sort_field: str = "USERNAME",
+        sort_order: str = "ASC",
+        user_ids: list = None
+    ):
+        """
+        Find users based on various criteria.
+        :param count_limit: Limit the number of elements that will be counted. -1 counts everything, 0 skips count.
+        :param group_id: The ID of the group the searched users should belong to.
+        :param include_disabled: Whether disabled users should be included in the search results.
+        :param limit: Maximum number of results to retrieve (0 = default limit, max 1000).
+        :param name: Name to search for in the fields specified by name_search_fields.
+        :param name_search_fields: User fields to search for the 'name' parameter.
+        :param offset: First result to retrieve (0-based).
+        :param only_logged_in: Whether only currently logged in users should be returned.
+        :param sort_field: Field for sorting.
+        :param sort_order: Order of sorting (ASC/DESC).
+        :param user_ids: List of user IDs to look for.
+        :return: Search results with users matching the criteria.
+        """
+        # Validate count_limit
+        if not isinstance(count_limit, int):
+            raise ValueError("count_limit must be an integer")
+
+        # Validate group_id if provided
+        if group_id is not None:
+            if not isinstance(group_id, str):
+                raise ValueError("group_id must be a string")
+            try:
+                uuid.UUID(group_id)
+            except ValueError as exc:
+                raise ValueError("group_id must be a valid UUID") from exc
+
+        # Validate include_disabled
+        if include_disabled is not None and not isinstance(include_disabled, bool):
+            raise ValueError("include_disabled must be a boolean")
+
+        # Validate limit
+        if not isinstance(limit, int) or limit < 0:
+            raise ValueError("limit must be a non-negative integer")
+        if limit > 1000:
+            raise ValueError("limit cannot exceed 1000")
+
+        # Validate name
+        if name is not None and not isinstance(name, str):
+            raise ValueError("name must be a string")
+
+        # Validate name_search_fields
+        valid_name_search_fields = [
+            "USERNAME", "FIRSTNAME", "LASTNAME", "LASTNAME_FIRSTNAME",
+            "FIRSTNAME_LASTNAME", "EMAIL"
+        ]
+        if name_search_fields is not None:
+            if not isinstance(name_search_fields, list):
+                raise ValueError("name_search_fields must be a list")
+            for field in name_search_fields:
+                if field not in valid_name_search_fields:
+                    raise ValueError(f"Invalid name search field: {field}. "
+                                     f"Allowed values: {valid_name_search_fields}")
+        # Validate offset
+        if not isinstance(offset, int) or offset < 0:
+            raise ValueError("offset must be a non-negative integer")
+
+        # Validate only_logged_in
+        if only_logged_in is not None and not isinstance(only_logged_in, bool):
+            raise ValueError("only_logged_in must be a boolean")
+        # Validate sort_field
+        valid_sort_fields = [
+            "USERNAME", "FIRSTNAME", "LASTNAME", "LASTNAME_FIRSTNAME",
+            "FIRSTNAME_LASTNAME", "EMAIL"
+        ]
+        if sort_field not in valid_sort_fields:
+            raise ValueError(f"Invalid sort field: {sort_field}. "
+                             f"Allowed values: {valid_sort_fields}")
+        # Validate sort_order
+        if sort_order not in ["ASC", "DESC"]:
+            raise ValueError("sort_order must be 'ASC' or 'DESC'")
+
+        # Validate user_ids
+        if user_ids is not None:
+            if not isinstance(user_ids, list):
+                raise ValueError("user_ids must be a list")
+            for user_id in user_ids:
+                if not isinstance(user_id, str):
+                    raise ValueError("All user IDs must be strings")
+                try:
+                    uuid.UUID(user_id)
+                except ValueError as exc:
+                    raise ValueError(f"Invalid UUID in user_ids: {user_id}") from exc
+
+        # Build parameters
+        params = {
+            "countLimit": count_limit,
+            "limit": limit,
+            "offset": offset,
+            "sortField": sort_field,
+            "sortOrder": sort_order
+        }
+
+        # Add optional parameters
+        if group_id is not None:
+            params["groupId"] = group_id
+
+        if include_disabled is not None:
+            params["includeDisabled"] = include_disabled
+
+        if name is not None:
+            params["name"] = name
+
+        if name_search_fields is not None:
+            params["nameSearchFields"] = name_search_fields
+
+        if only_logged_in is not None:
+            params["onlyLoggedIn"] = only_logged_in
+
+        if user_ids is not None:
+            # The API expects multiple userId parameters for each ID
+            for user_id in user_ids:
+                if "userId" not in params:
+                    params["userId"] = []
+                params["userId"].append(user_id)
+
+        response = self._get(params=params)
+        return self._handle_response(response)

collibra_connector/api/Workflow.py

@@ -0,0 +1,260 @@
+import uuid
+from .Base import BaseAPI
+
+
+class Workflow(BaseAPI):
+    def __init__(self, connector):
+        super().__init__(connector)
+        self.__base_api = connector.api
+
+    def start_workflow_instance(
+        self,
+        workflow_definition_id: str,
+        asset_id: str = None,
+        return_all: bool = False
+    ):
+        """
+        Start a workflow instance.
+        :param workflow_definition_id: The ID of the workflow definition.
+        :param asset_id: Optional asset ID to associate with the workflow.
+        :param return_all: Whether to return all workflow data or just the ID.
+        :return: Workflow instance ID or full response data.
+        """
+        if not workflow_definition_id:
+            raise ValueError("workflow_definition_id is required")
+        if not isinstance(workflow_definition_id, str):
+            raise ValueError("workflow_definition_id must be a string")
+
+        try:
+            uuid.UUID(workflow_definition_id)
+        except ValueError as exc:
+            raise ValueError("workflow_definition_id must be a valid UUID") from exc
+
+        data = {
+            "workflowDefinitionId": workflow_definition_id,
+            "sendNotification": True
+        }
+
+        if asset_id:
+            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
+
+            data.update({
+                "businessItemIds": [asset_id],
+                "businessItemType": "ASSET",
+            })
+
+        response = self._post(url=f"{self.__base_api}/workflowInstances", data=data)
+        result = self._handle_response(response)
+
+        if return_all:
+            return result
+        return result[0].get("id") if result else None
+
+    def find_workflow_task(
+        self,
+        business_item_id: str = None,
+        business_item_name: str = None,
+        business_item_type: str = None,
+        count_limit: int = -1,
+        create_date: str = None,
+        description: str = None,
+        due_date: str = None,
+        limit: int = 0,
+        offset: int = 0,
+        sort_field: str = "DUE_DATE",
+        sort_order: str = "DESC",
+        title: str = None,
+        user_id: str = None,
+        workflow_task_user_relation: str = "ALL"
+    ):
+        """
+        Find workflow tasks matching the given search criteria.
+        :param business_item_id: ID of the business item associated with the task.
+        :param business_item_name: Name of the business item associated with the task.
+        :param business_item_type: Type of the business item (e.g., ASSET).
+        :param count_limit: Limit elements counted. -1 counts all, 0 skips count.
+        :param create_date: Creation date of the task.
+        :param description: Description of the task.
+        :param due_date: Due date of the task.
+        :param limit: Maximum results to retrieve. 0 uses default, max 1000.
+        :param offset: First result to retrieve (deprecated, use cursor instead).
+        :param sort_field: Field to sort results by. Default is DUE_DATE.
+        :param sort_order: Sort order. Options: ASC, DESC. Default is DESC.
+        :param title: Title of the task
+        :param user_id: ID of the user associated with the task.
+        :param workflow_task_user_relation: Relation of the user to the task. Options: ALL, ASSIGNED, INVOLVED.
+        :return: List of workflow tasks matching criteria.
+        """
+        # Validate business_item_id if provided
+        if business_item_id is not None:
+            if not isinstance(business_item_id, str):
+                raise ValueError("business_item_id must be a string")
+            try:
+                uuid.UUID(business_item_id)
+            except ValueError as exc:
+                raise ValueError("business_item_id must be a valid UUID") from exc
+
+        # Validate business_item_type if provided
+        if business_item_type is not None and not isinstance(business_item_type, str):
+            raise ValueError("business_item_type must be a string")
+
+        # Validate count_limit
+        if not isinstance(count_limit, int):
+            raise ValueError("count_limit must be an integer")
+
+        # Validate create_date if provided
+        if create_date is not None and not isinstance(create_date, str):
+            raise ValueError("create_date must be a string")
+
+        # Validate description if provided
+        if description is not None and not isinstance(description, str):
+            raise ValueError("description must be a string")
+
+        # Validate due_date if provided
+        if due_date is not None and not isinstance(due_date, str):
+            raise ValueError("due_date must be a string")
+
+        # Validate limit
+        if not isinstance(limit, int) or limit < 0:
+            raise ValueError("limit must be a non-negative integer")
+        if limit > 1000:
+            raise ValueError("limit cannot exceed 1000")
+
+        # Validate offset
+        if not isinstance(offset, int) or offset < 0:
+            raise ValueError("offset must be a non-negative integer")
+
+        # Validate sort_field
+        valid_sort_fields = ["DUE_DATE", "CREATE_DATE", "TITLE"]
+        if sort_field not in valid_sort_fields:
+            raise ValueError(f"sort_field must be one of: {', '.join(valid_sort_fields)}")
+
+        # Validate sort_order
+        if sort_order not in ["ASC", "DESC"]:
+            raise ValueError("sort_order must be 'ASC' or 'DESC'")
+
+        # Validate title if provided
+        if title is not None and not isinstance(title, str):
+            raise ValueError("title must be a string")
+
+        # 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 workflow_task_user_relation
+        valid_relations = ["ALL", "ASSIGNED", "INVOLVED"]
+        if workflow_task_user_relation not in valid_relations:
+            raise ValueError(f"workflow_task_user_relation must be one of: {', '.join(valid_relations)}")
+
+        # Build parameters - only include non-default values
+        params = {
+            "countLimit": count_limit,
+            "limit": limit,
+            "offset": offset,
+            "sortField": sort_field,
+            "sortOrder": sort_order,
+            "workflowTaskUserRelation": workflow_task_user_relation
+        }
+
+        if business_item_id is not None:
+            params["businessItemId"] = business_item_id
+        if business_item_name is not None:
+            params["businessItemName"] = business_item_name
+        if business_item_type is not None:
+            params["businessItemType"] = business_item_type
+        if create_date is not None:
+            params["createDate"] = create_date
+        if description is not None:
+            params["description"] = description
+        if due_date is not None:
+            params["dueDate"] = due_date
+        if title is not None:
+            params["title"] = title
+        if user_id is not None:
+            params["userId"] = user_id
+
+        response = self._get(url=f"{self.__base_api}/workflowTasks", params=params)
+        return self._handle_response(response)
+
+    def get_workflow_task_id(self, instance_id: str, workflow_definition_id: str):
+        """
+        Get the task ID for a workflow instance.
+        :param instance_id: The workflow instance ID.
+        :param workflow_definition_id: The workflow definition ID.
+        :return: The task ID.
+        """
+        if not all([instance_id, workflow_definition_id]):
+            raise ValueError("instance_id and workflow_definition_id are required")
+
+        for param_name, param_value in [
+            ("instance_id", instance_id), ("workflow_definition_id", workflow_definition_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
+
+        params = {
+            "offset": 0,
+            "limit": 0,
+            "countLimit": -1,
+            "workflowDefinitionId": workflow_definition_id,
+            "instanceId": instance_id,
+            "sortField": "START_DATE",
+            "sortOrder": "DESC",
+        }
+
+        response = self._get(url=f"{self.__base_api}/workflowInstances", params=params)
+        result = self._handle_response(response)
+
+        tasks = result.get("results", [{}])[0].get("tasks", [])
+        return tasks[0].get("id") if tasks else None
+
+    def complete_workflow_task(self, task_ids: list[str], task_form_properties: dict):
+        """
+        Complete a workflow task.
+        :param task_ids: The IDs of the tasks to complete.
+        :param task_form_properties: The form properties for the tasks.
+        :return: The response from completing the tasks.
+        """
+        if not task_ids or not isinstance(task_ids, list):
+            raise ValueError("task_ids must be a non-empty list")
+        if not all(isinstance(task_id, str) for task_id in task_ids):
+            raise ValueError("All task_ids must be strings")
+
+        response = self._post(
+            url=f"{self.__base_api}/workflowTasks/completed",
+            data={"taskIds": task_ids, "taskFormProperties": task_form_properties}
+        )
+        return self._handle_response(response)
+
+    def get_task_form_data(self, task_id: str):
+        """
+        Get form data for a workflow task.
+        :param task_id: The ID of the workflow task.
+        :return: The task form data.
+        """
+        if not task_id:
+            raise ValueError("task_id is required")
+        if not isinstance(task_id, str):
+            raise ValueError("task_id must be a string")
+
+        try:
+            uuid.UUID(task_id)
+        except ValueError as exc:
+            raise ValueError("task_id must be a valid UUID") from exc
+
+        response = self._get(url=f"{self.__base_api}/workflowTasks/{task_id}/taskFormData")
+        return self._handle_response(response)

collibra_connector/api/__init__.py

@@ -1,2 +1,16 @@
 from .Asset import Asset
 from .Base import BaseAPI
+from .Community import Community
+from .Domain import Domain
+from .User import User
+from .Responsibility import Responsibility
+from .Workflow import Workflow
+from .Metadata import Metadata
+from .Comment import Comment
+from .Exceptions import (
+    CollibraAPIError,
+    UnauthorizedError,
+    ForbiddenError,
+    NotFoundError,
+    ServerError
+)

collibra_connector/connector.py

@@ -2,7 +2,18 @@ import logging
 import requests
 from requests.auth import HTTPBasicAuth
 
-from .api import Asset
+from .api import (
+    Asset,
+    Community,
+    Domain,
+    User,
+    Responsibility,
+    Workflow,
+    Metadata,
+    Comment
+)
+from .api.Utils import CollibraUtils
+
 
 class CollibraConnector():
     """
@@ -23,7 +34,16 @@ class CollibraConnector():
         self.__base_url = api
         self.__timeout = timeout
 
+        # Initialize all API classes
         self.asset = Asset(self)
+        self.community = Community(self)
+        self.domain = Domain(self)
+        self.user = User(self)
+        self.responsibility = Responsibility(self)
+        self.workflow = Workflow(self)
+        self.metadata = Metadata(self)
+        self.comment = Comment(self)
+        self.utils = CollibraUtils(self)
 
         logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(__name__)
@@ -35,7 +55,7 @@ class CollibraConnector():
         """Test the connection to Collibra API"""
         try:
             response = requests.get(
-                f"{self.__api}/info",
+                f"{self.__api}/auth/sessions/current",
                 auth=self.__auth,
                 timeout=self.__timeout
             )
@@ -54,4 +74,4 @@ class CollibraConnector():
 
     @property
     def base_url(self):
-        return self.__base_url
+        return self.__base_url

collibra_connector-1.0.10a0.dist-info/METADATA

@@ -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