h-message-bus 0.0.40__py3-none-any.whl → 0.0.41__py3-none-any.whl

h_message_bus/infrastructure/nats_client_repository.py

@@ -60,7 +60,7 @@ class NatsClientRepository:
         raise ConnectionError("Could not establish connection to NATS server.")
 
     async def publish(self, subject: str, payload: bytes, retries: int = 3) -> None:
-        """Publish raw message to NATS with retries and backoff."""
+        """Publish a raw message to NATS with retries and backoff."""
         for attempt in range(retries):
             try:
                 await self._ensure_connected()
@@ -83,7 +83,7 @@ class NatsClientRepository:
             return None
 
     async def request(self, subject: str, payload: bytes, timeout: float = 2.0, retries: int = 3) -> Optional[bytes]:
-        """Send a request and get raw response with retries and backoff."""
+        """Send a request and get a raw response with retries and backoff."""
         for attempt in range(retries):
             try:
                 await self._ensure_connected()

h_message_bus/infrastructure/nats_config.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 @dataclass
 class NatsConfig:
     """
-    Configuration class for NATS client.
+    Configuration class for the NATS client.
 
     This class encapsulates the configuration options required for connecting and
     interacting with a NATS (NATS.io) server. It includes options for setting

{h_message_bus-0.0.40.dist-info → h_message_bus-0.0.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h_message_bus
-Version: 0.0.40
+Version: 0.0.41
 Summary: Message bus integration for HAI
 Author-email: shoebill <shoebill.hai@gmail.com>
 Classifier: Programming Language :: Python :: 3
@@ -40,18 +40,18 @@ pip install h_message_bus
 
 ## Topics
 
-H Message Bus includes predefined topics following the convention: `hai.[source].[destination].[action]`
+H Message Bus uses topic strings for message routing. It's recommended to follow the convention: `hai.[source].[destination].[action]`
 
-Available topics:
+Example topics:
 
-| Topic Constant                  | Topic String           | Description                         |
-|---------------------------------|------------------------|-------------------------------------|
-| `Topic.AI_SEND_TG_CHAT_MESSAGE` | `hai.ai.tg.chat.send`  | AI sending message to Telegram chat |
-| `Topic.AI_VECTORS_SAVE`         | `hai.ai.vectors.save`  | AI saving data to vector database   |
-| `Topic.AI_VECTORS_QUERY`        | `hai.ai.vectors.query` | AI querying vector database         |
-| `Topic.TG_SEND_AI_CHAT_MESSAGE` | `hai.tg.ai.chat.send`  | Telegram sending message to AI      |
+| Topic String           | Description                         |
+|------------------------|-------------------------------------|
+| `hai.ai.tg.chat.send`  | AI sending message to Telegram chat |
+| `hai.ai.vectors.save`  | AI saving data to vector database   |
+| `hai.ai.vectors.query` | AI querying vector database         |
+| `hai.tg.ai.chat.send`  | Telegram sending message to AI      |
 
-You can use these predefined topics or create your own topic strings.
+You can use these example topics or create your own topic strings based on your application's needs.
 
 ## Quick Start
 
@@ -68,29 +68,31 @@ docker-compose up -d
 ```python
 import asyncio
 import uuid
-from h_message_bus import NatsConfig, NatsPublisherAdapter, HaiMessage, Topic
+from h_message_bus import NatsConfig, NatsPublisherAdapter, HaiMessage, NatsClientRepository
 
 async def main():
     # Configure NATS connection
     config = NatsConfig(server="nats://localhost:4222")
-    
+
+    # Create NATS client repository
+    client_repository = NatsClientRepository(config)
+
     # Create publisher adapter
-    publisher = NatsPublisherAdapter(config)
-    
+    publisher = NatsPublisherAdapter(client_repository)
+
     # Connect to NATS
-    await publisher.connect()
-    
-    # Create and publish a message using a predefined topic
+    await client_repository.connect()
+
+    # Create and publish a message
     message = HaiMessage(
-        message_id=str(uuid.uuid4()),
-        sender="service-a",
-        topic=Topic.TG_SEND_AI_CHAT_MESSAGE,
+        id=str(uuid.uuid4()),
+        topic="hai.tg.ai.chat.send",
         payload={"text": "Hello AI, this is a message from Telegram", "chat_id": 12345}
     )
-    
+
     # Publish message
     await publisher.publish(message)
-    
+
     # Clean up
     await publisher.close()
 
@@ -102,27 +104,34 @@ if __name__ == "__main__":
 
 ```python
 import asyncio
-from h_message_bus import NatsConfig, NatsSubscriberAdapter, HaiMessage, Topic
+from h_message_bus import NatsConfig, NatsSubscriberAdapter, HaiMessage, NatsClientRepository, MessageProcessor
 
-async def message_handler(message: HaiMessage):
-    print(f"Received message: {message.message_id}")
-    print(f"From: {message.sender}")
-    print(f"Topic: {message.topic}")
-    print(f"Payload: {message.payload}")
+class MyMessageProcessor(MessageProcessor):
+    async def process(self, message: HaiMessage):
+        print(f"Received message: {message.id}")
+        print(f"Topic: {message.topic}")
+        print(f"Payload: {message.payload}")
+        print(f"Timestamp: {message.timestamp}")
 
 async def main():
     # Configure NATS connection
     config = NatsConfig(server="nats://localhost:4222")
-    
+
+    # Create NATS client repository
+    client_repository = NatsClientRepository(config)
+
     # Create subscriber
-    subscriber = NatsSubscriberAdapter(config)
-    
+    subscriber = NatsSubscriberAdapter(client_repository)
+
     # Connect to NATS
-    await subscriber.connect()
-    
+    await client_repository.connect()
+
+    # Create message processor
+    processor = MyMessageProcessor()
+
     # Subscribe to a topic
-    await subscriber.subscribe(Topic.TG_SEND_AI_CHAT_MESSAGE, message_handler)
-    
+    await subscriber.subscribe("hai.tg.ai.chat.send", processor)
+
     # Keep the application running
     try:
         print("Subscriber running. Press Ctrl+C to exit.")
@@ -130,7 +139,7 @@ async def main():
             await asyncio.sleep(1)
     except KeyboardInterrupt:
         # Clean up
-        await subscriber.close()
+        await client_repository.close()
 
 if __name__ == "__main__":
     asyncio.run(main())
@@ -143,74 +152,91 @@ if __name__ == "__main__":
 ```python
 import asyncio
 import uuid
-from h_message_bus import NatsConfig, NatsPublisherAdapter, HaiMessage, Topic
+from h_message_bus import NatsConfig, NatsPublisherAdapter, HaiMessage, NatsClientRepository
 
 async def main():
+    # Configure NATS connection
     config = NatsConfig(server="nats://localhost:4222")
-    publisher = NatsPublisherAdapter(config)
-    
+
+    # Create NATS client repository
+    client_repository = NatsClientRepository(config)
+
+    # Create publisher adapter
+    publisher = NatsPublisherAdapter(client_repository)
+
     # Connect to NATS
-    await publisher.connect()
-    
+    await client_repository.connect()
+
     request_message = HaiMessage(
-        message_id=str(uuid.uuid4()),
-        sender="client-service",
-        topic=Topic.AI_VECTORS_QUERY,
+        id=str(uuid.uuid4()),
+        topic="hai.ai.vectors.query",
         payload={"query": "find similar documents", "limit": 10}
     )
-    
+
     # Send request and wait for response (with timeout)
     response = await publisher.request(request_message, timeout=5.0)
-    
+
     if response:
         print(f"Received response: {response.payload}")
     else:
         print("Request timed out")
-    
-    await publisher.close()
+
+    # Clean up
+    await client_repository.close()
 
 if __name__ == "__main__":
     asyncio.run(main())
 ```
 
-### Creating a Service with Request Handler
+### Creating a Service for Request-Response
 
 ```python
 import asyncio
 import uuid
-from h_message_bus import NatsConfig, NatsSubscriberAdapter, NatsPublisherAdapter, HaiMessage, Topic
-
-async def request_handler(request: HaiMessage):
-    print(f"Received request: {request.message_id}")
-    print(f"Payload: {request.payload}")
-    
-    # Process the request
-    result = {"status": "success", "data": {"result": 42}}
-    
-    # Create a response message
-    return HaiMessage(
-        message_id=str(uuid.uuid4()),
-        sender="service-b",
-        topic=f"{request.topic}.response",
-        payload=result,
-        correlation_id=request.message_id
-    )
+import json
+from h_message_bus import NatsConfig, NatsSubscriberAdapter, NatsPublisherAdapter, HaiMessage, NatsClientRepository, MessageProcessor
+
+class RequestResponseProcessor(MessageProcessor):
+    def __init__(self, publisher):
+        self.publisher = publisher
+
+    async def process(self, request: HaiMessage):
+        print(f"Received request: {request.id}")
+        print(f"Payload: {request.payload}")
+
+        # Process the request
+        result = {"status": "success", "data": {"result": 42}}
+
+        # Create a response message
+        response = HaiMessage(
+            id=str(uuid.uuid4()),
+            topic=f"{request.topic}.response",
+            payload=result
+        )
+
+        # Publish the response
+        await self.publisher.publish(response)
 
 async def main():
     # Configure NATS connection
     config = NatsConfig(server="nats://localhost:4222")
-    
-    # Create subscriber for handling requests
-    subscriber = NatsSubscriberAdapter(config)
-    publisher = NatsPublisherAdapter(config)
-    
+
+    # Create NATS client repository
+    client_repository = NatsClientRepository(config)
+
     # Connect to NATS
-    await subscriber.connect()
-    await publisher.connect()
-    
-    # Register request handler for vector database queries
-    await subscriber.subscribe_with_response(Topic.AI_VECTORS_QUERY, request_handler, publisher)
-    
+    await client_repository.connect()
+
+    # Create publisher and subscriber
+    publisher = NatsPublisherAdapter(client_repository)
+    subscriber = NatsSubscriberAdapter(client_repository)
+
+    # Create request processor that uses the publisher
+    processor = RequestResponseProcessor(publisher)
+
+    # Subscribe to the request topic
+    await subscriber.subscribe("hai.ai.vectors.query", processor)
+
     # Keep the application running
     try:
         print("Service running. Press Ctrl+C to exit.")
@@ -218,8 +244,7 @@ async def main():
             await asyncio.sleep(1)
     except KeyboardInterrupt:
         # Clean up
-        await subscriber.close()
-        await publisher.close()
+        await client_repository.close()
 
 if __name__ == "__main__":
     asyncio.run(main())
@@ -237,7 +262,6 @@ The `NatsConfig` class allows you to customize your NATS connection:
 | `connection_timeout`     | Connection timeout (seconds)                 | 2             |
 | `ping_interval`          | Interval for ping frames (seconds)           | 20            |
 | `max_outstanding_pings`  | Maximum unanswered pings before disconnect   | 5             |
-| `max_payload`            | Maximum size of the payload in bytes         | 1048576 (1MB) |
 
 ## API Reference
 
@@ -251,7 +275,6 @@ The following classes are exported directly from the package:
 - `NatsSubscriberAdapter` - Adapter for subscribing to messages
 - `MessageProcessor` - Processing incoming messages
 - `NatsClientRepository` - Low-level NATS client operations
-- `Topic` - Enumeration of predefined topic strings
 
 ### HaiMessage Structure
 
@@ -259,12 +282,10 @@ The `HaiMessage` class is the core data structure used for all messaging:
 
 ```python
 class HaiMessage:
-    message_id: str       # Unique identifier for the message
-    sender: str           # Identifier of the sender
+    id: str               # Unique identifier for the message
     topic: str            # The topic or channel for the message
     payload: dict         # Actual message data
-    correlation_id: str = None  # Optional reference to a related message
-    timestamp: float = None     # Optional message creation timestamp
+    timestamp: str = None # Optional message creation timestamp (ISO format)
 ```
 
 ## Contributing

h_message_bus-0.0.41.dist-info/RECORD

@@ -0,0 +1,20 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_message_bus/__init__.py,sha256=T_07sHtXLlRuLwK-BRVfFIIOGc48TKbtVLvKtIw2K5U,516
+h_message_bus/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_message_bus/adapters/nats_message_adapter.py,sha256=-hzx0UJmKJT4VWfRA_zVT68hddl9dejvUiSdLU1rY-w,1378
+h_message_bus/adapters/nats_publisher_adapter.py,sha256=EgrGioGuZfLpJsb5wiialMGMe8E4oUktS8zMdGri3Lc,1982
+h_message_bus/adapters/nats_subscriber_adapter.py,sha256=UJN2Es7hokbO5YsSUAf0KQ2B15QcGzGtQx-G1S3iQWQ,2105
+h_message_bus/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_message_bus/application/message_processor.py,sha256=1vdVfPn1BUDmswJ-Y5aS-YDbLSizrjX6_CMIBa5SGjc,734
+h_message_bus/application/message_publisher.py,sha256=pYX4JzJLe7L_59gKVYBLqT6iTwFB73zhbzxd7yv2TqI,834
+h_message_bus/application/message_subcriber.py,sha256=2yqUUHVHtZlA6-zzyHzghdWQ7ZmdcFic5c0xi_rgG-M,741
+h_message_bus/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_message_bus/domain/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_message_bus/domain/models/hai_message.py,sha256=b5CfX7hi5uNq77IVnZzEi9iotc4b_U2MNYwV6JY7JcU,2146
+h_message_bus/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_message_bus/infrastructure/nats_client_repository.py,sha256=aAwtUhDZAWOF8fF4IPfcUH5Gc6UscO41ST7rh-HsN2A,4505
+h_message_bus/infrastructure/nats_config.py,sha256=xg-Ak6H92T32DZKCsbWYQMO9J8nUBI0JZcUY3aA5w1c,1308
+h_message_bus-0.0.41.dist-info/METADATA,sha256=gVKKEx7HpSIfCGt9omofxOpUqJx077emtCAG0HT2FO0,9171
+h_message_bus-0.0.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+h_message_bus-0.0.41.dist-info/top_level.txt,sha256=BArjhm_lwFR9yJJEIf-LT_X64psuLkXFdbpQRJUreFE,23
+h_message_bus-0.0.41.dist-info/RECORD,,

{h_message_bus-0.0.40.dist-info → h_message_bus-0.0.41.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

h_message_bus/domain/models/event_message_topic.py

@@ -1,20 +0,0 @@
-from enum import Enum
-
-
-class EventMessageTopic(str, Enum):
-    """
-    Represents a collection of predefined topics as an enumeration.
-
-    This class is an enumeration that defines constant string values for use
-    as topic identifiers. These topics represent specific actions or messages
-    within a messaging or vector database management context. It ensures
-    consistent usage of these predefined topics across the application.
-
-    syntax: [hai].[source].[destination].[action]
-
-    """
-    # Events
-    STARTUP = "hai.startup"
-    SHUTDOWN = "hai.shutdown"
-    ENTITY_OFFICIAL_UPDATE = "hai.entity.official.update"
-    VECTOR_STALE_INFORMATION = "hai.vector.collection.stale.information"

h_message_bus/domain/models/request_message_topic.py

@@ -1,100 +0,0 @@
-from enum import Enum
-
-
-class RequestMessageTopic(str, Enum):
-    """
-    Represents a collection of predefined topics as an enumeration.
-
-    This class is an enumeration that defines constant string values for use
-    as topic identifiers. These topics represent specific actions or messages
-    within a messaging or vector database management context. It ensures
-    consistent usage of these predefined topics across the application.
-
-    syntax: [hai].[source].[destination].[action]
-
-    """
-    # Telegram
-    TG_CHAT_SEND = "hai.tg.chat.send"
-    TG_USER_CHAT_SEND = "hai.tg.user.chat.send"
-    TG_CHAT_REPLY = "hai.tg.chat.reply"
-
-    # vector database
-    VECTORS_SAVE = "hai.vectors.save"
-
-    VECTORS_QUERY = "hai.vectors.query"
-    VECTORS_QUERY_RESPONSE = "hai.vectors.query.response"
-
-    VECTORS_METADATA_READ = "hai.vectors.metadata.read"
-    VECTORS_METADATA_READ_RESPONSE = "hai.vectors.metadata.read.response"
-
-    # Twitter
-    TWITTER_GET_USER = "hai.twitter.get.user"
-    TWITTER_GET_USER_RESPONSE = "hai.twitter.get.user.response"
-    TWITTER_GET_USERS = "hai.twitter.get.users"
-    TWITTER_GET_USERS_RESPONSE = "hai.twitter.get.users.response"
-    TWITTER_GET_USER_TWEETS = "hai.twitter.get.user.tweets"
-    TWITTER_GET_USER_TWEETS_RESPONSE = "hai.twitter.get.user.tweets.response"
-
-    TWITTER_USER_SEND_AI_CHAT_SEND = "hai.twitter.user.chat.send"
-    TWITTER_USER_SEND_AI_CHAT_SEND_RESPONSE = "hai.twitter.user.chat.send.response"
-
-    TWITTER_FOLLOW_USER= "hai.twitter.follow.user"
-    TWITTER_FOLLOW_USER_RESPONSE = "hai.twitter.follow.user.response"
-
-    TWITTER_GET_HOME_TIMELINE= "hai.twitter.get.home.timeline"
-    TWITTER_GET_HOME_TIMELINE_RESPONSE = "hai.twitter.get.home.timeline.response"
-
-    TWITTER_RETWEET= "hai.twitter.retweet"
-    TWITTER_RETWEET_RESPONSE = "hai.twitter.retweet.response"
-
-    TWITTER_REPLY= "hai.twitter.reply"
-    TWITTER_REPLY_RESPONSE = "hai.twitter.reply.response"
-
-    TWITTER_POST_TWEET= "hai.twitter.post.tweet"
-    TWITTER_POST_TWEET_RESPONSE = "hai.twitter.post.tweet.response"
-
-    TWITTER_QUOTE_RETWEET= "hai.twitter.quote.retweet"
-    TWITTER_QUOTE_RETWEET_RESPONSE = "hai.twitter.quote.retweet.response"
-
-    TWITTER_GET_TWEET= "hai.twitter.get.tweet"
-    TWITTER_GET_TWEET_RESPONSE = "hai.twitter.get.tweet.response"
-
-    TWITTER_SEARCH= "hai.twitter.search"
-    TWITTER_SEARCH_RESPONSE = "hai.twitter.search.response"
-
-    # tools
-    WEB_SEARCH = "hai.tools.web.search"
-    WEB_SEARCH_RESPONSE = "hai.tools.web.search.response"
-
-    WEB_GET_DOCS = "hai.tools.web.get.docs"
-    WEB_GET_DOCS_RESPONSE = "hai.tools.web.get.docs.response"
-
-    WEB_FIND_RELATED = "hai.tools.web.find.related"
-    WEB_FIND_RELATED_RESPONSE = "hai.tools.web.find.related.response"
-
-    INIT_KNOWLEDGE_BASE = "hai.tools.init.knowledge.base"
-    INIT_KNOWLEDGE_BASE_RESPONSE = "hai.tools.init.knowledge.base.response"
-
-    # graph database
-    GRAPH_NODE_ADD = "hai.graph.node.add"
-    GRAPH_NODE_UPDATE = "hai.graph.node.update"
-    GRAPH_NODE_GET = "hai.graph.node.get"
-    GRAPH_NODE_DELETE = "hai.graph.node.delete"
-    GRAPH_RELATIONSHIP_ADD = "hai.graph.relationship.add"
-    GRAPH_RELATIONSHIP_DELETE = "hai.graph.relationship.delete"
-    GRAPH_QUERY = "hai.graph.query"
-    GRAPH_CLEAR = "hai.graph.clear"
-    GRAPH_GET_ALL = "hai.graph.get.all"
-    GRAPH_NODES_BY_PROPERTY = "hai.graph.nodes.by.property"
-
-    GRAPH_QUERY_OPERATION = "hai.graph.query.operation"
-    GRAPH_QUERY_OPERATION_RESPONSE = "hai.graph.query.operation.response"
-
-    GRAPH_NODE_ADD_RESPONSE = "hai.graph.node.add.response"
-    GRAPH_NODE_UPDATE_RESPONSE = "hai.graph.node.update.response"
-    GRAPH_NODE_GET_RESPONSE = "hai.graph.node.get.response"
-    GRAPH_RELATIONSHIP_ADD_RESPONSE = "hai.graph.relationship.add.response"
-    GRAPH_QUERY_RESPONSE = "hai.graph.query.response"
-    GRAPH_CLEAR_RESPONSE = "hai.graph.clear.response"
-    GRAPH_GET_ALL_RESPONSE = "hai.graph.get.all.response"
-    GRAPH_NODES_BY_PROPERTY_RESPONSE = "hai.graph.nodes.by.property.response"

h_message_bus/domain/models/twitter_message_metadata.py

@@ -1,31 +0,0 @@
-from ...domain.models.twitter_user_metadata import TwitterUserMetadata
-
-
-class TwitterMessageMetaData:
-    def __init__(self, tweet_id: str, user: TwitterUserMetadata, message:  str, created_at: str, view_count: int, retweet_count: int, reply_count: int):
-        self.tweet_id = tweet_id
-        self.message = message
-        self.user = user
-        self.created_at = created_at,
-        self.view_count = view_count
-        self.retweet_count = retweet_count
-        self.reply_count = reply_count
-
-    def to_dict(self) -> dict:
-        """
-        Convert TwitterMessage instance to a dictionary.
-
-        Returns:
-            dict: A dictionary representation of the TwitterMessage instance.
-            If the user attribute is a TwitterUser instance, it will be converted
-            to a dictionary using its __dict__ attribute.
-        """
-        return {
-            'tweet_id': self.tweet_id,
-            'message': self.message,
-            'created_at': self.created_at,
-            'view_count': self.view_count,
-            'retweet_count': self.retweet_count,
-            'reply_count': self.reply_count,
-            'user': self.user.to_dict()
-        }

h_message_bus/domain/models/twitter_user_metadata.py

@@ -1,76 +0,0 @@
-class TwitterUserMetadata:
-    def __init__(self,
-                 id: str,
-                 screen_name: str,
-                 user_name: str = None,
-                 description: str = None,
-                 followers_count: int = 0,
-                 like_count: int = 0,
-                 is_verified: bool = False,
-                 url: str = None,
-                 bio_urls: list = None):
-        """
-        Initialize a TwitterUserMetadata instance.
-
-        Args:
-            id (str): The user's Twitter ID
-            screen_name (str): The user's screen name
-            user_name (str, optional): The user's name
-            description (str, optional): The user's bio description
-            followers_count (int, optional): Number of followers
-            like_count (int, optional): Number of likes
-            is_verified (bool, optional): Whether the user is verified
-            url (str, optional): The user's profile URL
-            bio_urls (list, optional): URLs mentioned in the user's bio
-        """
-        self.id = id
-        self.screen_name = screen_name
-        self.user_name = user_name
-        self.description = description
-        self.followers_count = followers_count
-        self.like_count = like_count
-        self.is_verified = is_verified
-        self.url = url
-        self.bio_urls = bio_urls or []
-
-    def to_dict(self) -> dict:
-        """
-        Convert TwitterUserMetadata instance to a dictionary.
-
-        Returns:
-            dict: A dictionary representation of the TwitterUserMetadata instance.
-        """
-        return {
-            'id': self.id,
-            'screen_name': self.screen_name,
-            'user_name': self.user_name,
-            'description': self.description,
-            'followers_count': self.followers_count,
-            'like_count': self.like_count,
-            'is_verified': self.is_verified,
-            'url': self.url,
-            'bio_urls': self.bio_urls
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'TwitterUserMetadata':
-        """
-        Create a TwitterUserMetadata instance from a dictionary.
-
-        Args:
-            data (dict): A dictionary containing TwitterUserMetadata attributes
-
-        Returns:
-            TwitterUserMetadata: A new TwitterUserMetadata instance
-        """
-        return cls(
-            id=data.get('id'),
-            screen_name=data.get('screen_name'),
-            user_name=data.get('user_name'),
-            description=data.get('description'),
-            followers_count=data.get('followers_count', 0),
-            like_count=data.get('like_count', 0),
-            is_verified=data.get('is_verified', False),
-            url=data.get('url'),
-            bio_urls=data.get('bio_urls', [])
-        )

h_message_bus/domain/models/vector_collection_metadata.py

@@ -1,30 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class VectorCollectionMetadata:
-    collection_name: str
-    last_updated: str
-    last_queried: str
-    query_count: int = 0
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'VectorCollectionMetadata':
-        """Create an instance from a dictionary."""
-        return cls(
-            collection_name=data.get('collection_name', ''),
-            last_updated=data.get('last_updated', ''),
-            last_queried=data.get('last_queried', ''),
-            query_count=data.get('query_count', 0)
-        )
-
-    def to_dict(self) -> dict:
-        """Convert instance to a dictionary."""
-        return {
-            'collection_name': self.collection_name,
-            'last_updated': self.last_updated,
-            'last_queried': self.last_queried,
-            'query_count': self.query_count
-        }
-
-

h_message_bus/domain/models/vector_query_answer.py

@@ -1,22 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class VectorQueryAnswer:
-    text: str
-    dimension: str
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'VectorQueryAnswer':
-        """Create an instance from a dictionary."""
-        return cls(
-            text=data.get('text', ''),
-            dimension=data.get('dimension', ''),
-        )
-
-    def to_dict(self) -> dict:
-        """Convert instance to a dictionary."""
-        return {
-            'text': self.text,
-            'dimension': self.dimension,
-        }