vector-bridge 1.0.0__py3-none-any.whl

vector_bridge/schema/ai_knowledge/__init__.py

@@ -0,0 +1,34 @@
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PresignedUploadUrl(BaseModel):
+    url: str
+    body: dict
+
+
+class BaseAIKnowledgeChunk(BaseModel):
+    item_id: str
+    index: int
+    content: str
+
+
+class BaseAIKnowledge(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    schema_name: str = Field(default="")
+    unique_identifier: str = Field(default="")
+    content: Optional[str] = None
+    timestamp: str
+
+    _chunk_size: int = 384
+    _chunk_overlap: int = 76
+
+
+class AIKnowledgeList(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    items: List[Dict]
+    limit: Union[int, None] = Field(default=None)
+    offset: Union[int, None] = Field(default=None)
+    has_more: bool = Field(default=False)

vector_bridge/schema/ai_knowledge/filesystem.py

@@ -0,0 +1,140 @@
+from typing import Dict, List, Optional, Union
+from uuid import uuid4
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from vector_bridge.schema.ai_knowledge import BaseAIKnowledge
+from vector_bridge.schema.helpers.enums import FileSystemType, SortOrder
+
+# CREATES ---
+
+
+class AIKnowledgeFileSystemItemCreate(BaseAIKnowledge):
+    model_config = ConfigDict(from_attributes=True)
+
+    name: str = Field(default=None)
+    parent_id: Optional[str] = Field(default=None)
+    source_documents_ids: Optional[List[str]] = Field(default_factory=list)
+    type: FileSystemType = Field(default=FileSystemType.FILE)
+    file_size_bytes: int = Field(default=0)
+    starred: bool = Field(default=False)
+    tags: List[str] = Field(default_factory=list)
+    private: bool = Field(default=False)
+    users_with_read_access: List[str] = Field(default_factory=list)
+    users_with_write_access: List[str] = Field(default_factory=list)
+    groups_with_read_access: List[str] = Field(default_factory=list)
+    groups_with_write_access: List[str] = Field(default_factory=list)
+    created_by: str
+    cloud_stored: bool = Field(default=False)
+    vectorized: bool = Field(default=True)
+
+
+# OUTPUTS ---
+
+
+class AIKnowledgeFileSystemItemChunk(BaseModel):
+    item_id: str = Field(default_factory=lambda: str(uuid4()))
+    index: int
+    content: str
+
+
+class AIKnowledgeFileSystemItem(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    item_id: str
+    name: str
+    chunks: List[AIKnowledgeFileSystemItemChunk] = Field(default_factory=list)
+    parent: Optional["AIKnowledgeFileSystemItem"] = Field(default=None)
+    source_documents: List["AIKnowledgeFileSystemItem"] = Field(default_factory=list)
+    derived_documents: List["AIKnowledgeFileSystemItem"] = Field(default_factory=list)
+    parent_id: Optional[str]
+    parent_ids_hierarchy: List[str]
+    type: FileSystemType
+    file_size_bytes: int
+    starred: bool
+    tags: List[str]
+    private: bool
+    users_with_read_access: List[str]
+    users_with_write_access: List[str]
+    groups_with_read_access: List[str]
+    groups_with_write_access: List[str]
+    unique_identifier: str
+    timestamp: str
+    created_by: str
+    cloud_stored: bool
+    vectorized: bool = Field(default=True)
+    archived: bool = Field(default=False)
+
+
+AIKnowledgeFileSystemItem.model_rebuild()
+
+
+class AIKnowledgeFileSystemItemsList(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    items: List[AIKnowledgeFileSystemItem]
+    limit: Union[int, None] = Field(default=None)
+    offset: Union[int, None] = Field(default=None)
+    has_more: bool = Field(default=False)
+
+
+class AIKnowledgeFileSystemFilters(BaseModel):
+    file_name_like: str = Field(default=None)
+    file_name_equal: str = Field(default=None)
+    item_id: str = Field(default=None)
+    parent_id: str = Field(default=None)
+    parent_id_is_null: bool = Field(default=None)
+    parent_ids_hierarchy_contains_any: List[str] = Field(default=None)
+    source_documents_ids_contains_any: List[str] = Field(default=None)
+    source_documents_ids_contains_all: List[str] = Field(default=None)
+    type: FileSystemType = Field(default=None)
+    is_starred: bool = Field(default=None)
+    tags_contains_any: List[str] = Field(default=None)
+    tags_contains_all: List[str] = Field(default=None)
+    is_private: bool = Field(default=None)
+    users_with_read_access_contains_any: List[str] = Field(default=None)
+    users_with_read_access_contains_all: List[str] = Field(default=None)
+    users_with_write_access_contains_any: List[str] = Field(default=None)
+    users_with_write_access_contains_all: List[str] = Field(default=None)
+    groups_with_read_access_contains_any: List[str] = Field(default=None)
+    groups_with_read_access_contains_all: List[str] = Field(default=None)
+    groups_with_write_access_contains_any: List[str] = Field(default=None)
+    groups_with_write_access_contains_all: List[str] = Field(default=None)
+    unique_identifier: str = Field(default="")
+    file_size_bytes_min: int = Field(default=None)
+    file_size_bytes_max: int = Field(default=None)
+    timestamp_after: str = Field(default="")
+    timestamp_before: str = Field(default="")
+    is_cloud_stored: bool = Field(default=None)
+    is_vectorized: bool = Field(default=None)
+    is_archived: bool = Field(default=None)
+    limit: int = Field(default=100)
+    offset: int = Field(default=None)
+    sort_by: str = Field(default="timestamp")
+    sort_order: SortOrder = Field(default=SortOrder.DESCENDING)
+
+    def to_non_empty_dict(self):
+        _dict = self.model_dump()
+        return {k: v for k, v in _dict.items() if v is not None and v != ""}
+
+    def to_serializible_non_empty_dict(self):
+        _dict = self.model_dump()
+        if self.sort_order:
+            _dict["sort_order"] = self.sort_order.value
+        if self.type:
+            _dict["type"] = self.type.value
+        return {k: v for k, v in _dict.items() if v is not None and v != ""}
+
+
+class FileSystemItemArchivedCount(BaseModel):
+    files: int
+    archived_files: int
+
+
+class FileSystemItemCount(BaseModel):
+    files: int
+    folders: int
+
+
+class FileSystemItemAggregatedCount(BaseModel):
+    items: Dict[str, FileSystemItemCount]

vector_bridge/schema/ai_knowledge/schemaless.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, List
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from vector_bridge.schema.ai_knowledge import (BaseAIKnowledge,
+                                               BaseAIKnowledgeChunk)
+from vector_bridge.schema.helpers.enums import SortOrder
+
+
+class AIKnowledgeCreate(BaseModel):
+    content: str
+    other: Dict[str, Any]
+
+
+class AIKnowledgeChunk(BaseAIKnowledgeChunk):
+    pass
+
+
+class AIKnowledge(BaseAIKnowledge):
+    model_config = ConfigDict(from_attributes=True)
+
+    item_id: str
+    chunks: List[AIKnowledgeChunk | BaseAIKnowledgeChunk] = Field(default_factory=list)
+    other: Dict[str, Any]
+
+
+class AIKnowledgeContentFilters(BaseModel):
+    item_id: str = Field(default=None)
+    limit: int = Field(default=100)
+    offset: int = Field(default=0)
+    sort_by: str = Field(default="timestamp")
+    sort_order: SortOrder = Field(default=SortOrder.DESCENDING)
+
+    class Config:
+        extra = "allow"
+
+    def to_non_empty_dict(self):
+        _dict = self.model_dump()
+        return {k: v for k, v in _dict.items() if v is not None and v != ""}
+
+    def to_serializible_non_empty_dict(self):
+        _dict = self.model_dump()
+        if self.sort_order:
+            _dict["sort_order"] = self.sort_order.value
+        return {k: v for k, v in _dict.items() if v is not None and v != ""}

vector_bridge/schema/api_keys.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+from typing import Optional
+
+from dateutil.parser import isoparse
+from pydantic import BaseModel, Field
+
+
+class APIKey(BaseModel):
+    hash_key: Optional[str] = Field(default=None)
+    organization_id: str
+    api_key: str
+    key_name: str
+    integration_name: str
+    user_id: str = Field(default="")
+    expire_timestamp: str
+    monthly_request_limit: int
+    created_by: str
+    created_at: str
+
+    def is_expired(self) -> bool:
+        """Check if the API key is expired based on the expire_timestamp."""
+        current_time = datetime.utcnow()
+        expiration_time = isoparse(self.expire_timestamp)
+        return current_time >= expiration_time
+
+
+class APIKeyCreate(BaseModel):
+    key_name: str
+    integration_name: str
+    user_id: str = Field(default="")
+    expire_days: int
+    monthly_request_limit: int

vector_bridge/schema/chat.py

@@ -0,0 +1,74 @@
+import json
+from datetime import datetime
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from vector_bridge.schema.helpers.enums import MessageStorageMode
+from vector_bridge.schema.instruction import DEFAULT_AGENT
+
+
+class ChatBase(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    title: Optional[str] = Field(default="")
+    storage: MessageStorageMode
+    agent: str = Field(default=DEFAULT_AGENT)
+    core_knowledge: dict = Field(default_factory=dict)
+
+
+class ChatCreate(ChatBase):
+    model_config = ConfigDict(from_attributes=True)
+
+    integration_id: str
+
+
+class ChatInDB(ChatBase):
+    model_config = ConfigDict(from_attributes=True)
+
+    chat_id: str
+    integration_id: str
+    chat_created_by: str
+    timestamp: datetime
+    latest_message_timestamp: datetime
+    deleted: bool = False
+
+    @model_validator(mode="before")
+    def check_vector_schema(cls, values):
+        values["chat_id"] = str(values["chat_id"])
+        values["integration_id"] = str(values["integration_id"])
+        if "core_knowledge" in values and isinstance(values["core_knowledge"], str):
+            values["core_knowledge"] = json.loads(values["core_knowledge"])
+        return values
+
+
+class Chat(ChatBase):
+    model_config = ConfigDict(from_attributes=True)
+
+    integration_id: str
+    timestamp: datetime
+    chat_created_by: str
+    latest_message_timestamp: datetime
+
+    @model_validator(mode="before")
+    def check_vector_schema(cls, values):
+        if isinstance(values, (Chat, ChatInDB)):
+            return values
+
+        values["integration_id"] = str(values["integration_id"])
+        if "core_knowledge" in values and isinstance(values["core_knowledge"], str):
+            values["core_knowledge"] = json.loads(values["core_knowledge"])
+        return values
+
+
+class ChatsList(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    chats: List[Chat]
+    limit: int
+    offset: int = Field(default=0)
+    has_more: bool = Field(default=False)
+
+
+class ChatFilter(BaseModel):
+    model_config = ConfigDict(from_attributes=True)

vector_bridge/schema/error.py

@@ -0,0 +1,13 @@
+class HTTPException(Exception):
+    """
+    Custom exception for handling HTTP errors.
+
+    Attributes:
+        status_code (int): HTTP status code of the error.
+        detail (str): Detailed error message.
+    """
+
+    def __init__(self, status_code: int, detail: str):
+        super().__init__(f"HTTP {status_code}: {detail}")
+        self.status_code = status_code
+        self.detail = detail

vector_bridge/schema/functions.py

@@ -0,0 +1,87 @@
+from enum import Enum
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from vector_bridge.schema.helpers.enums import AIProviders, GPTActions
+
+
+class FunctionsSorting(str, Enum):
+    created_at = "created_at"
+    updated_at = "updated_at"
+
+
+class FunctionPropertyStorageStructure(BaseModel):
+    name: str
+    description: str
+    type: str = Field(default="string")
+    items: Dict[str, str] = Field(default_factory=dict)
+    enum: List[str] = []
+    required: bool = Field(default=False)
+
+
+class FunctionParametersStorageStructure(BaseModel):
+    properties: List[FunctionPropertyStorageStructure]
+
+    def to_dynamodb_raw(self):
+        return {
+            "properties": {"L": [{"M": _property.to_dynamodb_raw()} for _property in self.properties]},
+        }
+
+
+class Overrides(BaseModel):
+    ai_provider: Optional[AIProviders] = Field(default=None)
+    model: str = Field(default="")
+    system_prompt: str = Field(default="")
+    message_prompt: str = Field(default="")
+    knowledge_prompt: str = Field(default="")
+    max_tokens: str = Field(default="")
+    frequency_penalty: str = Field(default="")
+    presence_penalty: str = Field(default="")
+    temperature: str = Field(default="")
+
+
+class Function(BaseModel):
+    function_id: str
+    function_name: str
+    integration_id: str
+    description: str
+    function_action: GPTActions
+    code: str = Field(default="")
+    vector_schema: str = Field(default="")
+    accessible_by_ai: bool = Field(default=True)
+    function_parameters: FunctionParametersStorageStructure
+    overrides: Overrides = Field(default=Overrides())
+    system_required: bool = Field(default=False)
+    created_at: str = Field(default="")
+    created_by: str = Field(default="")
+    updated_at: str = Field(default="")
+    updated_by: str = Field(default="")
+
+
+class FunctionCreate(BaseModel):
+    function_name: str
+    description: str
+    function_action: GPTActions
+    code: str = Field(default="")
+    vector_schema: str = Field(default="")
+    accessible_by_ai: bool = Field(default=True)
+    function_parameters: FunctionParametersStorageStructure
+    overrides: Overrides = Field(default=Overrides())
+
+
+class FunctionUpdate(BaseModel):
+    description: str
+    function_action: GPTActions
+    code: str = Field(default="")
+    vector_schema: str = Field(default="")
+    accessible_by_ai: bool = Field(default=True)
+    function_parameters: FunctionParametersStorageStructure
+    overrides: Overrides = Field(default=Overrides())
+
+
+class PaginatedFunctions(BaseModel):
+    functions: List[Function] = Field(default_factory=list)
+    limit: int
+    last_evaluated_key: Optional[str] = None
+    has_more: bool = False