letschatty 0.4.349__py3-none-any.whl → 0.4.351__py3-none-any.whl

letschatty/services/chatty_assets/base_container_with_collection.py

@@ -64,7 +64,8 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         self.update_previews_thread()
         self.load_from_db_thread(company_id=None)
 
-    def insert(self, item: T, execution_context: ExecutionContext) -> T:
+    # All methods are now async-only for better performance
+    async def insert(self, item: T, execution_context: ExecutionContext) -> T:
         """
         Add an item to the container and insert it into the database collection.
 
@@ -77,12 +78,12 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         """
         logger.debug(f"{self.__class__.__name__} inserting item {item}")
         inserted_item = super().insert(item)
-        self.collection.insert(inserted_item)
+        await self.collection.insert(inserted_item)
         execution_context.set_event_time(inserted_item.created_at)
         self.update_previews_thread()
         return inserted_item
 
-    def update(self, id: str, new_item: T, execution_context: ExecutionContext) -> T:
+    async def update(self, id: str, new_item: T, execution_context: ExecutionContext) -> T:
         """
         Update an item in the container and in the database collection.
 
@@ -105,18 +106,18 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             if id != updated_item.id:
                 logger.error(f"Item id {id} does not match updated item id {updated_item.id}")
                 raise ValueError(f"Item id {id} does not match updated item id {updated_item.id}")
-            self.collection.update(updated_item)
+            await self.collection.update(updated_item)
             execution_context.set_event_time(updated_item.updated_at)
             self.update_preview(updated_item)
             self.update_previews_thread()
             return updated_item
 
         except NotFoundError as e:
-            outdated_item = self.collection.get_by_id(id)
+            outdated_item = await self.collection.get_by_id(id)
             if outdated_item:
                 updated_item = outdated_item.update(new_item)
                 self.items[id] = updated_item
-                self.collection.update(updated_item)
+                await self.collection.update(updated_item)
                 execution_context.set_event_time(updated_item.updated_at)
                 self.update_previews_thread()
                 return updated_item
@@ -125,7 +126,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
                 f"Item with id {id} not found in {self.__class__.__name__} nor in collection DB"
             )
 
-    def delete(self, id: str, execution_context: ExecutionContext,deletion_type : DeletionType = DeletionType.LOGICAL) -> T:
+    async def delete(self, id: str, execution_context: ExecutionContext,deletion_type : DeletionType = DeletionType.LOGICAL) -> T:
         """
         Delete an item from the container and the collection.
 
@@ -142,16 +143,16 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             deleted_item = super().delete(id)
             self.delete_preview(id)
             execution_context.set_event_time(datetime.now(ZoneInfo("UTC")))
-            self.collection.delete(id, deletion_type)
+            await self.collection.delete(id, deletion_type)
             return deleted_item
         except NotFoundError as e:
-            self.collection.delete(id, deletion_type)
+            await self.collection.delete(id, deletion_type)
             self.delete_preview(id)
             self.update_previews_thread()
             execution_context.set_event_time(datetime.now(ZoneInfo("UTC")))
-            return self.collection.get_by_id(id)
+            return await self.collection.get_by_id(id)
 
-    def get_by_id(self, id: str) -> T:
+    async def get_by_id(self, id: str) -> T:
         """
         Get an item from the container.
 
@@ -174,7 +175,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             #     #if they are supposed to be in memory, we raise an error since it shouldn't be in the collection DB
             #     raise NotFoundError(f"Item with id {id} not found in {self.__class__.__name__} nor in collection DB")
             logger.debug(f"{self.__class__.__name__} getting item {id} not found in container, trying to get from collection")
-            item = self.collection.get_by_id(id)
+            item = await self.collection.get_by_id(id)
             if item:
                 if item.deleted_at is not None:
                     return item
@@ -239,7 +240,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
             logger.debug(f"Clearing previews cache of {self.__class__.__name__}")
             self.set_preview_items([])
 
-    def get_all(self, company_id: Optional[StrObjectId]) -> List[T]:
+    async def get_all(self, company_id: Optional[StrObjectId]) -> List[T]:
         # Get items from memory
         logger.debug(f"{self.__class__.__name__} getting all items from memory and collection")
         memory_items = super().get_all(company_id=company_id)
@@ -247,7 +248,7 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         memory_ids = [ObjectId(item.id) for item in memory_items]
         # Build the query for collection items
         query = {"deleted_at": None, "_id": {"$nin": memory_ids}}
-        collection_items = self.collection.get_docs(query=query, company_id=company_id)
+        collection_items = await self.collection.get_docs(query=query, company_id=company_id)
         all_items = memory_items + collection_items
         return sorted(all_items, key=lambda x: x.created_at, reverse=True)
 
@@ -261,6 +262,8 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
     def update_previews_thread(self):
         """We start a thread to update the previews cache so it doesn't block the main thread"""
         # self.update_previews_cache()
+        if not self.cache_config.keep_previews_always_in_memory:
+            return
         thread = threading.Thread(target=self.update_previews_cache)
         thread.start()
 
@@ -275,13 +278,13 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         self.set_preview_items(collection_items)
         return collection_items
 
-    def get_by_query(self, query: dict, company_id: Optional[StrObjectId]) -> List[T]:
+    async def get_by_query(self, query: dict, company_id: Optional[StrObjectId]) -> List[T]:
         logger.debug(f"{self.__class__.__name__} getting items by query {query} from collection")
-        return self.collection.get_docs(query=query, company_id=company_id)
+        return await self.collection.get_docs(query=query, company_id=company_id)
 
-    def get_deleted(self, company_id: Optional[StrObjectId]) -> List[T]:
+    async def get_deleted(self, company_id: Optional[StrObjectId]) -> List[T]:
         logger.debug(f"{self.__class__.__name__} getting deleted items from collection")
-        return self.collection.get_docs(query={"deleted_at": {"$ne": None}}, company_id=company_id)
+        return await self.collection.get_docs(query={"deleted_at": {"$ne": None}}, company_id=company_id)
 
     def load_from_db_thread(self, company_id: Optional[StrObjectId]):
         """We start a thread to load the items from the database so it doesn't block the main thread"""
@@ -292,21 +295,27 @@ class ChattyAssetContainerWithCollection(ChattyAssetBaseContainer[T, P], ABC):
         thread.start()
 
     def load_from_db(self, company_id: Optional[StrObjectId]):
-        """Pass company_id=None to load all items from the database."""
+        """Pass company_id=None to load all items from the database. Uses sync client for background loading."""
         logger.debug(f"{self.__class__.__name__} loading items from collection")
-        # self.items = {item.id: item for item in self.collection.get_docs(query={}, company_id=company_id)}
-        self.items = {item.id: item for item in self.collection.get_docs(query={"deleted_at": None}, company_id=company_id)}
-
-    def restore(self, id: str, execution_context: ExecutionContext) -> T:
+        # Background loading uses sync client (less critical, runs in thread)
+        query: Dict[str, Any] = {"deleted_at": None}
+        if company_id:
+            query["company_id"] = company_id
+        docs = list(self.collection.collection.find(filter=query))
+        # Create instances once and reuse
+        loaded_items = [self.collection.create_instance(doc) for doc in docs]
+        self.items = {item.id: item for item in loaded_items}
+
+    async def restore(self, id: str, execution_context: ExecutionContext) -> T:
         logger.debug(f"{self.__class__.__name__} restoring item {id} with execution context {execution_context}")
         if id in self.items:
             raise ValueError(f"Item with id {id} already exists in {self.__class__.__name__}")
-        restored_item = self.collection.get_by_id(id)
+        restored_item = await self.collection.get_by_id(id)
         if restored_item is None:
             raise NotFoundError(f"Item with id {id} not found in collection DB")
         restored_item.deleted_at = None
         restored_item.update_now()
         execution_context.set_event_time(restored_item.updated_at)
         self.items[id] = restored_item
-        self.collection.update(restored_item)
-        return restored_item
+        await self.collection.update(restored_item)
+        return restored_item

letschatty/services/chatty_assets/collections/__init__.py

@@ -0,0 +1,38 @@
+"""
+Asset Collection Subclasses
+
+This module provides pre-configured AssetCollection subclasses for each asset type.
+These ensure consistency between the API and microservices by defining the collection
+configuration (collection name, asset type, preview type, create_instance_method) once.
+"""
+
+from .product_collection import ProductCollection
+from .tag_collection import TagCollection
+from .user_collection import UserCollection
+from .chat_collection import ChatCollection
+from .source_collection import SourceCollection
+from .flow_collection import FlowCollection
+from .sale_collection import SaleCollection
+from .contact_point_collection import ContactPointCollection
+from .ai_agent_collection import AiAgentCollection
+from .fast_answer_collection import FastAnswerCollection
+from .topic_collection import TopicCollection
+from .filter_criteria_collection import FilterCriteriaCollection
+from .ai_component_collection import AiComponentCollection
+
+__all__ = [
+    'ProductCollection',
+    'TagCollection',
+    'UserCollection',
+    'ChatCollection',
+    'SourceCollection',
+    'FlowCollection',
+    'SaleCollection',
+    'ContactPointCollection',
+    'AiAgentCollection',
+    'FastAnswerCollection',
+    'TopicCollection',
+    'FilterCriteriaCollection',
+    'AiComponentCollection',
+]
+

letschatty/services/chatty_assets/collections/ai_agent_collection.py

@@ -0,0 +1,19 @@
+"""AI Agent Collection - Pre-configured AssetCollection for AI Agents"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.ai_agents_v2.chatty_ai_agent import ChattyAIAgent, ChattyAIAgentPreview
+from ....models.data_base.mongo_connection import MongoConnection
+
+
+class AiAgentCollection(AssetCollection[ChattyAIAgent, ChattyAIAgentPreview]):
+    """Pre-configured collection for AI Agent assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="ai_agents",
+            asset_type=ChattyAIAgent,
+            connection=connection,
+            create_instance_method=ChattyAIAgent.default_create_instance_method,
+            preview_type=ChattyAIAgentPreview
+        )
+

letschatty/services/chatty_assets/collections/ai_agent_in_chat_collection.py

@@ -0,0 +1,32 @@
+"""AI Agent In Chat Collection - Pre-configured AssetCollection for AI Agent state in chats"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.ai_agents_v2.chatty_ai_agent_in_chat import ChattyAIAgentInChat
+from ....models.data_base.mongo_connection import MongoConnection
+from typing import Optional
+
+
+class AIAgentInChatCollection(AssetCollection[ChattyAIAgentInChat, ChattyAIAgentInChat]):
+    """
+    Pre-configured collection for AI Agent In Chat state.
+
+    This is a standalone collection (not embedded in Chat) that allows Lambda to
+    manage AI agent state independently without loading entire chat documents.
+    """
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="chatty_ai_agents_in_chat",
+            asset_type=ChattyAIAgentInChat,
+            connection=connection,
+            create_instance_method=lambda doc: ChattyAIAgentInChat(**doc),
+            preview_type=ChattyAIAgentInChat  # No separate preview type needed
+        )
+
+    async def get_by_chat_id(self, chat_id: str) -> Optional[ChattyAIAgentInChat]:
+        """Get AI agent state by chat ID, or None if not found"""
+        doc = await self.async_collection.find_one({"chat_id": chat_id, "deleted_at": None})
+        if not doc:
+            return None
+        return self.create_instance(doc)
+

letschatty/services/chatty_assets/collections/ai_component_collection.py

@@ -0,0 +1,21 @@
+"""AI Component Collection - Pre-configured AssetCollection for AI Components"""
+
+from typing import Any
+from ..asset_service import AssetCollection
+from ....models.base_models.ai_agent_component import AiAgentComponent, AiAgentComponentPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ....services.ai_components_service import AiComponentsService
+
+
+class AiComponentCollection(AssetCollection[AiAgentComponent, AiAgentComponentPreview]):
+    """Pre-configured collection for AI Component assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="ai_components",
+            asset_type=AiAgentComponent,
+            connection=connection,
+            create_instance_method=AiComponentsService.instantiate_component,
+            preview_type=AiAgentComponentPreview
+        )
+

letschatty/services/chatty_assets/collections/chain_of_thought_collection.py

@@ -0,0 +1,30 @@
+"""Chain of Thought Collection - Pre-configured AssetCollection for Chain of Thoughts"""
+
+from typing import Any, List, Dict
+
+from letschatty.models.utils.types.serializer_type import SerializerType
+from ..asset_service import AssetCollection, StrObjectId
+from ....models.company.assets.ai_agents_v2.chain_of_thought_in_chat import (
+    ChainOfThoughtInChat,
+    ChainOfThoughtInChatPreview
+)
+from ....models.data_base.mongo_connection import MongoConnection
+
+
+class ChainOfThoughtCollection(AssetCollection[ChainOfThoughtInChat, ChainOfThoughtInChatPreview]):
+    """Pre-configured collection for Chain of Thought"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="chain_of_thoughts",
+            asset_type=ChainOfThoughtInChat,
+            connection=connection,
+            create_instance_method=lambda doc: ChainOfThoughtInChat(**doc),
+            preview_type=ChainOfThoughtInChatPreview
+        )
+
+    async def get_by_chat_id(self, chat_id: StrObjectId, skip: int = 0, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get chain of thoughts by chat ID, sorted by created_at (newest first)"""
+        cursor = self.async_collection.find({"chat_id": chat_id, "deleted_at": None}).sort("created_at", -1).skip(skip).limit(limit)
+        cot_docs = await cursor.to_list(length=None)
+        return [self.create_instance(cot_doc).model_dump_json(serializer=SerializerType.FRONTEND) for cot_doc in cot_docs]

letschatty/services/chatty_assets/collections/chat_collection.py

@@ -0,0 +1,21 @@
+"""Chat Collection - Pre-configured AssetCollection for Chats"""
+
+from ..asset_service import AssetCollection
+from ....models.chat.chat import Chat
+from ....models.base_models import ChattyAssetPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ....services.factories.chats.chat_factory import ChatFactory
+
+
+class ChatCollection(AssetCollection[Chat, ChattyAssetPreview]):
+    """Pre-configured collection for Chat assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="chats",
+            asset_type=Chat,
+            connection=connection,
+            create_instance_method=ChatFactory.from_json,
+            preview_type=None
+        )
+

letschatty/services/chatty_assets/collections/contact_point_collection.py

@@ -0,0 +1,21 @@
+"""Contact Point Collection - Pre-configured AssetCollection for Contact Points"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.contact_point import ContactPoint
+from ....models.base_models import ChattyAssetPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ....services.factories.analytics.contact_point_factory import ContactPointFactory
+
+
+class ContactPointCollection(AssetCollection[ContactPoint, ChattyAssetPreview]):
+    """Pre-configured collection for ContactPoint assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="contact_points",
+            asset_type=ContactPoint,
+            connection=connection,
+            create_instance_method=ContactPointFactory.instantiate_contact_point,
+            preview_type=None
+        )
+

letschatty/services/chatty_assets/collections/fast_answer_collection.py

@@ -0,0 +1,21 @@
+"""FastAnswer Collection - Pre-configured AssetCollection for Fast Answers"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets import ChattyFastAnswer
+from ....models.base_models import ChattyAssetPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ...factories.chatty_fast_answers.chatty_fast_answers_factory import ChattyFastAnswersFactory
+
+
+class FastAnswerCollection(AssetCollection[ChattyFastAnswer, ChattyAssetPreview]):
+    """Pre-configured collection for Fast Answer assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="fast_answers",
+            asset_type=ChattyFastAnswer,
+            connection=connection,
+            create_instance_method=ChattyFastAnswersFactory.create,
+            preview_type=ChattyAssetPreview
+        )
+

letschatty/services/chatty_assets/collections/filter_criteria_collection.py

@@ -0,0 +1,18 @@
+"""Filter Criteria Collection - Pre-configured AssetCollection for Filter Criterias"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.filter_criteria import FilterCriteria, FilterCriteriaPreview
+from ....models.data_base.mongo_connection import MongoConnection
+
+
+class FilterCriteriaCollection(AssetCollection[FilterCriteria, FilterCriteriaPreview]):
+    """Pre-configured collection for Filter Criteria assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="filter_criterias",
+            asset_type=FilterCriteria,
+            connection=connection,
+            create_instance_method=FilterCriteria.default_create_instance_method,
+            preview_type=FilterCriteriaPreview
+        )

letschatty/services/chatty_assets/collections/flow_collection.py

@@ -0,0 +1,20 @@
+"""Flow Collection - Pre-configured AssetCollection for Flows"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.flow import FlowPreview
+from ....models.base_models import ChattyAssetPreview
+from ....models.data_base.mongo_connection import MongoConnection
+
+
+class FlowCollection(AssetCollection[FlowPreview, ChattyAssetPreview]):
+    """Pre-configured collection for Flow assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="flows",
+            asset_type=FlowPreview,
+            connection=connection,
+            create_instance_method=FlowPreview.default_create_instance_method,
+            preview_type=None
+        )
+

letschatty/services/chatty_assets/collections/product_collection.py

@@ -0,0 +1,20 @@
+"""Product Collection - Pre-configured AssetCollection for Products"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.product import Product, ProductPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ....services.factories.product_factory import ProductFactory
+
+
+class ProductCollection(AssetCollection[Product, ProductPreview]):
+    """Pre-configured collection for Product assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="products",
+            asset_type=Product,
+            connection=connection,
+            create_instance_method=ProductFactory.create_product,
+            preview_type=ProductPreview
+        )
+

letschatty/services/chatty_assets/collections/sale_collection.py

@@ -0,0 +1,20 @@
+"""Sale Collection - Pre-configured AssetCollection for Sales"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.sale import Sale
+from ....models.base_models import ChattyAssetPreview
+from ....models.data_base.mongo_connection import MongoConnection
+
+
+class SaleCollection(AssetCollection[Sale, ChattyAssetPreview]):
+    """Pre-configured collection for Sale assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="sales",
+            asset_type=Sale,
+            connection=connection,
+            create_instance_method=Sale.default_create_instance_method,
+            preview_type=None
+        )
+

letschatty/services/chatty_assets/collections/source_collection.py

@@ -0,0 +1,21 @@
+"""Source Collection - Pre-configured AssetCollection for Sources"""
+
+from ..asset_service import AssetCollection
+from ....models.analytics.sources import SourceBase
+from ....models.base_models import ChattyAssetPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ....services.factories.analytics.sources.source_factory import SourceFactory
+
+
+class SourceCollection(AssetCollection[SourceBase, ChattyAssetPreview]):
+    """Pre-configured collection for Source assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="sources",
+            asset_type=SourceBase,
+            connection=connection,
+            create_instance_method=SourceFactory.instantiate_source,
+            preview_type=None
+        )
+

letschatty/services/chatty_assets/collections/tag_collection.py

@@ -0,0 +1,19 @@
+"""Tag Collection - Pre-configured AssetCollection for Tags"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.tag import Tag, TagPreview
+from ....models.data_base.mongo_connection import MongoConnection
+
+
+class TagCollection(AssetCollection[Tag, TagPreview]):
+    """Pre-configured collection for Tag assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="tags",
+            asset_type=Tag,
+            connection=connection,
+            create_instance_method=Tag.default_create_instance_method,
+            preview_type=TagPreview
+        )
+

letschatty/services/chatty_assets/collections/topic_collection.py

@@ -0,0 +1,21 @@
+"""Topic Collection - Pre-configured AssetCollection for Topics"""
+
+from ..asset_service import AssetCollection
+from ....models.analytics.smart_messages.topic import Topic
+from ....models.base_models import ChattyAssetPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ...factories.analytics.smart_messages.topics_factory import TopicFactory
+
+
+class TopicCollection(AssetCollection[Topic, ChattyAssetPreview]):
+    """Pre-configured collection for Topic assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="topics",
+            asset_type=Topic,
+            connection=connection,
+            create_instance_method=TopicFactory.instantiate_topic,
+            preview_type=ChattyAssetPreview
+        )
+

letschatty/services/chatty_assets/collections/user_collection.py

@@ -0,0 +1,20 @@
+"""User Collection - Pre-configured AssetCollection for Users"""
+
+from ..asset_service import AssetCollection
+from ....models.company.assets.users.user import User, UserPreview
+from ....models.data_base.mongo_connection import MongoConnection
+from ....services.users.user_factory import UserFactory
+
+
+class UserCollection(AssetCollection[User, UserPreview]):
+    """Pre-configured collection for User assets"""
+
+    def __init__(self, connection: MongoConnection):
+        super().__init__(
+            collection="users",
+            asset_type=User,
+            connection=connection,
+            create_instance_method=UserFactory.instantiate_user,
+            preview_type=UserPreview
+        )
+

letschatty/services/chatty_assets/example_usage.py

@@ -0,0 +1,44 @@
+"""
+Example usage of the AssetsCollections class
+
+This file demonstrates how to use the read-only AssetsCollections container
+in a microservice.
+"""
+from .assets_collections import AssetsCollections
+from ...models.data_base.mongo_connection import MongoConnection
+
+# Example: How to use AssetsCollections in a microservice
+
+def example_usage():
+    """
+    Example of how to use AssetsCollections in your microservice.
+    """
+    # Initialize the connection (typically this would be a singleton in your microservice)
+    connection = MongoConnection()
+
+    # Get the singleton instance
+    assets = AssetsCollections(connection)
+
+    # Read assets by ID
+    # product = assets.get_product_by_id("some_product_id")
+    # tag = assets.get_tag_by_id("some_tag_id")
+    # user = assets.get_user_by_id("some_user_id")
+    # chat = assets.get_chat_by_id("some_chat_id")
+    # source = assets.get_source_by_id("some_source_id")
+    # flow = assets.get_flow_by_id("some_flow_id")
+    # sale = assets.get_sale_by_id("some_sale_id")
+    # contact_point = assets.get_contact_point_by_id("some_contact_point_id")
+    # ai_agent = assets.get_ai_agent_by_id("some_ai_agent_id")
+
+    # Or access the collections directly for more advanced queries
+    # all_products = assets.products.get_docs(query={"active": True}, company_id="some_company_id")
+
+    print("AssetsCollections initialized and ready to use!")
+
+    # Note: This is read-only. No insert, update, or delete operations are available.
+    # For write operations, use the full AssetService classes in the API.
+
+
+if __name__ == "__main__":
+    example_usage()
+

letschatty/services/chatty_assets/services/__init__.py

@@ -0,0 +1,37 @@
+"""
+Pre-configured Asset Services
+
+This module provides ready-to-use AssetService subclasses for each asset type.
+These services include the collection configuration and default cache settings.
+
+API implementations can extend these to add business logic (events, validation, etc.)
+"""
+
+from .product_service import ProductService
+from .tag_service import TagService
+from .user_service import UserService
+from .chat_service import ChatService
+from .source_service import SourceService
+from .flow_service import FlowService
+from .sale_service import SaleService
+from .contact_point_service import ContactPointService
+from .ai_agent_service import AiAgentService
+from .fast_answer_service import FastAnswerService
+from .topic_service import TopicService
+from .filter_criteria_service import FilterCriteriaService
+
+__all__ = [
+    'ProductService',
+    'TagService',
+    'UserService',
+    'ChatService',
+    'SourceService',
+    'FlowService',
+    'SaleService',
+    'ContactPointService',
+    'AiAgentService',
+    'FastAnswerService',
+    'TopicService',
+    'FilterCriteriaService',
+]
+