vector-bridge 0.0.1__py3-none-any.whl

vector_bridge/__init__.py

@@ -0,0 +1,489 @@
+from collections.abc import Callable
+from typing import Any
+from urllib.parse import urlparse
+
+import aiohttp
+import requests
+from pydantic import BaseModel
+from vector_bridge.schema.errors.base import raise_for_base_error_detail
+from vector_bridge.schema.helpers.enums import UserType
+from vector_bridge.schema.organization import OrganizationCreate
+from vector_bridge.schema.user import UserCreate
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+class BaseVectorBridgeClient:
+    """Base class for VectorBridge clients with common functionality."""
+
+    def __init__(
+        self,
+        base_url: str = "http://vector_bridge:8000/",
+        api_key: str | None = None,
+        integration_name: str = "default",
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.access_token = None
+        self.api_key = api_key
+        self.integration_name = integration_name
+
+        self._parsed_url = urlparse(self.base_url)
+
+    @property
+    def host(self) -> str:
+        return self._parsed_url.hostname or "localhost"
+
+    @property
+    def redis_url(self) -> str:
+        return f"redis://{self.host}:6379"
+
+    def _get_auth_headers(self) -> dict[str, str]:
+        """Get headers with API key authentication and bearer token authentication."""
+        api_key_headers = {}
+        if self.api_key:
+            api_key_headers["Api-Key"] = self.api_key
+        if self.access_token:
+            api_key_headers["Authorization"] = f"Bearer {self.access_token}"
+
+        if not api_key_headers:
+            raise ValueError("Authentication or API key required. Call login() first or provide api_key.")
+        return api_key_headers
+
+    def _create_http_exception(self, status_code: int, error_data: Any, error_callable: Callable) -> Exception:
+        """Create HTTPException from error response."""
+        if isinstance(error_data, dict):
+            detail = error_data.get("detail")
+        else:
+            detail = str(error_data)
+
+        return error_callable(detail)
+
+    def _print_welcome_message(self, username: str):
+        """Print welcome message after login."""
+        print(f"Hey, {username}! You have been logged in...")
+        print(
+            """
+
+██╗   ██╗███████╗ ██████╗████████╗ ██████╗ ██████╗ ██████╗ ██████╗ ██╗██████╗  ██████╗ ███████╗    █████╗ ██╗
+██║   ██║██╔════╝██╔════╝╚══██╔══╝██╔═══██╗██╔══██╗██╔══██╗██╔══██╗██║██╔══██╗██╔════╝ ██╔════╝   ██╔══██╗██║
+██║   ██║█████╗  ██║        ██║   ██║   ██║██████╔╝██████╔╝██████╔╝██║██║  ██║██║  ███╗█████╗     ███████║██║
+╚██╗ ██╔╝██╔══╝  ██║        ██║   ██║   ██║██╔══██╗██╔══██╗██╔══██╗██║██║  ██║██║   ██║██╔══╝     ██╔══██║██║
+ ╚████╔╝ ███████╗╚██████╗   ██║   ╚██████╔╝██║  ██║██████╔╝██║  ██║██║██████╔╝╚██████╔╝███████╗██╗██║  ██║██║
+  ╚═══╝  ╚══════╝ ╚═════╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝╚═╝╚═════╝  ╚═════╝ ╚══════╝╚═╝╚═╝  ╚═╝╚═╝
+DOCS: https://docs.vectorbridge.ai/                                                           version: 0.0.1
+
+                """
+        )
+
+
+class VectorBridgeClient(BaseVectorBridgeClient):
+    """
+    Synchronous Python client for the VectorBridge.ai API.
+
+    Provides access to all functionality of the VectorBridge platform including
+    authentication, user management, AI processing, vector operations, and more.
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://vector_bridge:8000/",
+        api_key: str | None = None,
+        integration_name: str = "default",
+    ):
+        """
+        Initialize the VectorBridge client.
+
+        Args:
+            base_url: The base URL of the VectorBridge API.
+            api_key: API key for authentication.
+            integration_name: Name of the integration.
+        """
+        super().__init__(base_url, api_key, integration_name)
+
+        from vector_bridge.sync_io.admin import AdminClient
+        from vector_bridge.sync_io.client.ai_knowledge import AIKnowledge
+        from vector_bridge.sync_io.client.api_keys import APIKeysClient
+        from vector_bridge.sync_io.client.history import HistoryClient
+        from vector_bridge.sync_io.client.logs import LogsClient
+        from vector_bridge.sync_io.client.otp import OTPClient
+        from vector_bridge.sync_io.client.query import QueryClient
+        from vector_bridge.sync_io.client.usage import UsageClient
+        from vector_bridge.sync_io.client.user import UserClient
+        from vector_bridge.sync_io.client.workflows import WorkflowClient
+
+        self.session = requests.Session()
+
+        # Initialize client modules
+        self.admin = AdminClient(self)
+        self.api_keys = APIKeysClient(self)
+        self.ai_knowledge = AIKnowledge(self)
+        self.history = HistoryClient(self)
+        self.logs = LogsClient(self)
+        self.otp = OTPClient(self)
+        self.workflows = WorkflowClient(self)
+        self.queries = QueryClient(self)
+        self.users = UserClient(self)
+        self.usage = UsageClient(self)
+
+    def create_owner_with_organization(self, user: UserCreate, organization: OrganizationCreate) -> None:
+        """
+        Create a new owner user and an associated organization.
+
+        This function first creates an owner user, then creates an organization
+        associated with that owner. Intended for bootstrapping a new organization
+        in the system.
+
+        Args:
+            user (UserCreate): The user data to create (will be forced to type=OWNER).
+            organization (OrganizationCreate): The organization details to create.
+
+        Returns:
+            None
+        """
+        # Ensure user type is OWNER
+        user.user_type = UserType.OWNER
+
+        # Step 1: Create the owner user
+        user_url = f"{self.base_url}/v1/user/create-owner"
+        user_response = self.session.post(user_url, json=user.model_dump())
+        self._handle_response(response=user_response, error_callable=raise_for_base_error_detail)
+
+        self.login(username=user.email, password=user.password)
+
+        # Step 2: Create the organization
+        org_url = f"{self.base_url}/v1/admin/organization/create"
+        headers = self._get_auth_headers()
+        org_response = self.session.post(org_url, headers=headers, json=organization.model_dump())
+        self._handle_response(response=org_response, error_callable=raise_for_base_error_detail)
+
+    def login(self, username: str, password: str) -> Token:
+        """
+        Log in to obtain an access token.
+
+        Args:
+            username: User's email
+            password: User's password
+
+        Returns:
+            Token object containing access_token and token_type
+        """
+        url = f"{self.base_url}/token"
+        data = {
+            "username": username,
+            "password": password,
+        }
+        response = self.session.post(
+            url,
+            data=data,
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+        )
+        result = self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+        self.access_token = result["access_token"]
+
+        self._print_welcome_message(username)
+
+        return Token(**result)
+
+    def _handle_response(self, response: requests.Response, error_callable: Callable) -> Any:
+        """Handle API response and errors."""
+        if 200 <= response.status_code < 300:
+            if response.status_code == 204:
+                return None
+            try:
+                return response.json()
+            except ValueError:
+                return response.text
+        else:
+            try:
+                error_data = response.json()
+            except ValueError:
+                error_data = response.text
+
+            exc = self._create_http_exception(response.status_code, error_data, error_callable)
+            raise exc
+
+    def ping(self) -> str:
+        """
+        Ping the API to check if it's available.
+
+        Returns:
+            Response string
+        """
+        url = f"{self.base_url}/v1/ping"
+        response = self.session.get(url)
+        return self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+
+    def generate_crypto_key(self) -> str:
+        """
+        Generate a crypto key.
+
+        Returns:
+            Generated crypto key
+        """
+        url = f"{self.base_url}/v1/secrets/generate-crypto-key"
+        response = self.session.get(url)
+        return self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+
+    def check_db_connection(self, weaviate_url: str, weaviate_api_key: str) -> dict:
+        """
+        Check database connection.
+
+        Args:
+            weaviate_url: The VectorDB URL
+            weaviate_api_key: The VectorDB API key
+
+        Returns:
+            Connection check response
+        """
+        url = f"{self.base_url}/v1/check/db_connection"
+        data = {"url": weaviate_url, "api_key": weaviate_api_key}
+        response = self.session.post(url, json=data)
+        return self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+
+    def close(self):
+        """Close the session."""
+        self.session.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+class AsyncVectorBridgeClient(BaseVectorBridgeClient):
+    """
+    Asynchronous Python client for the VectorBridge.ai API.
+
+    Provides async access to all functionality of the VectorBridge platform including
+    authentication, user management, AI processing, vector operations, and more.
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://vector_bridge:8000/",
+        api_key: str | None = None,
+        integration_name: str = "default",
+        connector: aiohttp.BaseConnector | None = None,
+        timeout: aiohttp.ClientTimeout | None = None,
+    ):
+        """
+        Initialize the async VectorBridge client.
+
+        Args:
+            base_url: The base URL of the VectorBridge API.
+            api_key: API key for authentication.
+            integration_name: Name of the integration.
+            connector: aiohttp connector for custom connection handling.
+            timeout: Timeout configuration for requests.
+        """
+        super().__init__(base_url, api_key, integration_name)
+
+        from vector_bridge.async_io.admin import AsyncAdminClient
+        from vector_bridge.async_io.admin.api_keys import AsyncAPIKeys
+        from vector_bridge.async_io.client.ai_knowledge import AsyncAIKnowledge
+        from vector_bridge.async_io.client.history import AsyncHistoryClient
+        from vector_bridge.async_io.client.logs import AsyncLogsClient
+        from vector_bridge.async_io.client.otp import AsyncOTPClient
+        from vector_bridge.async_io.client.query import AsyncQueryClient
+        from vector_bridge.async_io.client.usage import AsyncUsageClient
+        from vector_bridge.async_io.client.user import AsyncUserClient
+        from vector_bridge.async_io.client.workflows import AsyncWorkflowClient
+
+        self.session = None
+        self._connector = connector
+        self._timeout = timeout or aiohttp.ClientTimeout(total=30)
+
+        # Initialize async client modules
+        if AsyncAdminClient:
+            self.admin = AsyncAdminClient(self)
+            self.api_keys = AsyncAPIKeys(self)
+            self.ai_knowledge = AsyncAIKnowledge(self)
+            self.history = AsyncHistoryClient(self)
+            self.logs = AsyncLogsClient(self)
+            self.otp = AsyncOTPClient(self)
+            self.workflows = AsyncWorkflowClient(self)
+            self.queries = AsyncQueryClient(self)
+            self.users = AsyncUserClient(self)
+            self.usage = AsyncUsageClient(self)
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self._ensure_session()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+
+    async def _ensure_session(self):
+        """Ensure aiohttp session is created."""
+        if self.session is None:
+            self.session = aiohttp.ClientSession(connector=self._connector, timeout=self._timeout)
+
+    async def create_owner_with_organization(self, user: UserCreate, organization: OrganizationCreate) -> None:
+        """
+        Create a new owner user and an associated organization (async).
+
+        This function first creates an owner user, then creates an organization
+        associated with that owner. Intended for bootstrapping a new organization
+        in the system.
+
+        Args:
+            user (UserCreate): The user data to create (will be forced to type=OWNER).
+            organization (OrganizationCreate): The organization details to create.
+
+        Returns:
+            None
+        """
+        await self._ensure_session()
+
+        # Ensure user type is OWNER
+        user.user_type = UserType.OWNER
+
+        # Step 1: Create the owner user
+        user_url = f"{self.base_url}/v1/user/create-owner"
+        async with self.session.post(user_url, json=user.model_dump()) as response:
+            await self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+
+        await self.login(username=user.email, password=user.password)
+
+        # Step 2: Create the organization
+        org_url = f"{self.base_url}/v1/admin/organization/create"
+        headers = self._get_auth_headers()
+        async with self.session.post(org_url, headers=headers, json=organization.model_dump()) as response:
+            await self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+
+    async def login(self, username: str, password: str) -> Token:
+        """
+        Log in to obtain an access token.
+
+        Args:
+            username: User's email
+            password: User's password
+
+        Returns:
+            Token object containing access_token and token_type
+        """
+        await self._ensure_session()
+
+        url = f"{self.base_url}/token"
+        data = aiohttp.FormData()
+        data.add_field("username", username)
+        data.add_field("password", password)
+
+        async with self.session.post(url, data=data) as response:
+            result = await self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+            self.access_token = result["access_token"]
+
+            # Print welcome message in sync context (or make it optional)
+            self._print_welcome_message(username)
+
+            return Token(**result)
+
+    async def _handle_response(self, response: aiohttp.ClientResponse, error_callable: Callable) -> Any:
+        """Handle async API response and errors."""
+        if 200 <= response.status < 300:
+            if response.status == 204:
+                return None
+            try:
+                return await response.json()
+            except (ValueError, aiohttp.ContentTypeError):
+                return await response.text()
+        else:
+            try:
+                error_data = await response.json()
+            except (ValueError, aiohttp.ContentTypeError):
+                error_data = await response.text()
+
+            exc = self._create_http_exception(response.status, error_data, error_callable)
+            raise exc
+
+    async def ping(self) -> str:
+        """
+        Ping the API to check if it's available.
+
+        Returns:
+            Response string
+        """
+        await self._ensure_session()
+
+        url = f"{self.base_url}/v1/ping"
+        async with self.session.get(url) as response:
+            return await self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+
+    async def generate_crypto_key(self) -> str:
+        """
+        Generate a crypto key.
+
+        Returns:
+            Generated crypto key
+        """
+        await self._ensure_session()
+
+        url = f"{self.base_url}/v1/secrets/generate-crypto-key"
+        async with self.session.get(url) as response:
+            return await self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+
+    async def check_db_connection(self, weaviate_url: str, weaviate_api_key: str) -> dict:
+        """
+        Check database connection.
+
+        Args:
+            weaviate_url: The VectorDB URL
+            weaviate_api_key: The VectorDB API key
+
+        Returns:
+            Connection check response
+        """
+        await self._ensure_session()
+
+        url = f"{self.base_url}/v1/check/db_connection"
+        data = {"url": weaviate_url, "api_key": weaviate_api_key}
+        async with self.session.post(url, json=data) as response:
+            return await self._handle_response(response=response, error_callable=raise_for_base_error_detail)
+
+    async def close(self):
+        """Close the async session."""
+        if self.session and not self.session.closed:
+            await self.session.close()
+            self.session = None
+
+
+# Factory function for easier client creation
+def create_client(
+    base_url: str = "http://vector_bridge:8000/",
+    api_key: str | None = None,
+    integration_name: str = "default",
+    async_client: bool = False,
+    **kwargs,
+) -> VectorBridgeClient | AsyncVectorBridgeClient:
+    """
+    Factory function to create either sync or async VectorBridge client.
+
+    Args:
+        base_url: The base URL of the VectorBridge API.
+        api_key: API key for authentication.
+        integration_name: Name of the integration.
+        async_client: If True, returns AsyncVectorBridgeClient, otherwise VectorBridgeClient.
+        **kwargs: Additional arguments passed to the client constructor.
+
+    Returns:
+        VectorBridgeClient or AsyncVectorBridgeClient instance.
+    """
+    if async_client:
+        return AsyncVectorBridgeClient(
+            base_url=base_url,
+            api_key=api_key,
+            integration_name=integration_name,
+            **kwargs,
+        )
+    else:
+        return VectorBridgeClient(
+            base_url=base_url,
+            api_key=api_key,
+            integration_name=integration_name,
+        )

vector_bridge/async_io/admin/__init__.py

@@ -0,0 +1,20 @@
+from vector_bridge import AsyncVectorBridgeClient
+from vector_bridge.async_io.admin.integrations import AsyncIntegrationsAdmin
+from vector_bridge.async_io.admin.organization import AsyncOrganizationAdmin
+from vector_bridge.async_io.admin.security_groups import AsyncSecurityGroupsAdmin
+from vector_bridge.async_io.admin.settings import AsyncSettingsAdmin
+from vector_bridge.async_io.admin.vector_db import AsyncVectorDBAdmin
+
+
+class AsyncAdminClient:
+    """Async admin client providing access to all admin endpoints that require authentication."""
+
+    def __init__(self, client: AsyncVectorBridgeClient):
+        self.client = client
+
+        # Initialize async admin subclients
+        self.settings = AsyncSettingsAdmin(client)
+        self.organization = AsyncOrganizationAdmin(client)
+        self.security_groups = AsyncSecurityGroupsAdmin(client)
+        self.integrations = AsyncIntegrationsAdmin(client)
+        self.vector_db = AsyncVectorDBAdmin(client)

vector_bridge/async_io/admin/api_keys.py

@@ -0,0 +1,87 @@
+from vector_bridge import AsyncVectorBridgeClient
+from vector_bridge.schema.api_keys import APIKey, APIKeyCreate
+from vector_bridge.schema.errors.api_keys import raise_for_api_key_detail
+
+
+class AsyncAPIKeys:
+    """Async client for API keys management endpoints."""
+
+    def __init__(self, client: AsyncVectorBridgeClient):
+        self.client = client
+
+    async def create_api_key(self, api_key_data: APIKeyCreate) -> APIKey:
+        """
+        Create a new API key for integrations.
+
+        Args:
+            api_key_data: Details for the API key to create
+
+        Returns:
+            Created API key
+        """
+        await self.client._ensure_session()
+
+        url = f"{self.client.base_url}/v1/api_key/create"
+        headers = self.client._get_auth_headers()
+
+        async with self.client.session.post(url, headers=headers, json=api_key_data.model_dump()) as response:
+            result = await self.client._handle_response(response=response, error_callable=raise_for_api_key_detail)
+            return APIKey.model_validate(result)
+
+    async def get_api_key(self, api_key: str) -> APIKey:
+        """
+        Retrieve details about a specific API key.
+
+        Args:
+            api_key: The API key
+
+        Returns:
+            API key details
+        """
+        await self.client._ensure_session()
+
+        url = f"{self.client.base_url}/v1/api_key/{api_key}"
+        headers = self.client._get_auth_headers()
+
+        async with self.client.session.get(url, headers=headers) as response:
+            result = await self.client._handle_response(response=response, error_callable=raise_for_api_key_detail)
+            return APIKey.model_validate(result)
+
+    async def delete_api_key(self, api_key: str) -> None:
+        """
+        Delete an API key.
+
+        Args:
+            api_key: The API key to delete
+        """
+        await self.client._ensure_session()
+
+        url = f"{self.client.base_url}/v1/api_key/{api_key}"
+        headers = self.client._get_auth_headers()
+
+        async with self.client.session.delete(url, headers=headers) as response:
+            if response.status != 204:
+                await self.client._handle_response(response=response, error_callable=raise_for_api_key_detail)
+
+    async def list_api_keys(self, integration_name: str | None = None) -> list[APIKey]:
+        """
+        List all API keys.
+
+        Args:
+            integration_name: Specifies the name of the integration module being queried
+
+        Returns:
+            List of API keys
+        """
+        await self.client._ensure_session()
+
+        url = f"{self.client.base_url}/v1/api_keys"
+        params = {}
+        if integration_name:
+            params["integration_name"] = integration_name
+
+        headers = self.client._get_auth_headers()
+
+        async with self.client.session.get(url, headers=headers, params=params) as response:
+            results = await self.client._handle_response(response=response, error_callable=raise_for_api_key_detail)
+            return [APIKey.model_validate(result) for result in results]