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

h_message_bus/infrastructure/nats_client_repository.py

@@ -1,4 +1,5 @@
 import logging
+import asyncio
 from typing import Optional, Callable, Any
 
 import nats
@@ -6,37 +7,34 @@ from nats.aio.client import Client as NatsClient
 
 from ..infrastructure.nats_config import NatsConfig
 
-
 class NatsClientRepository:
     """
     Repository for managing connection and interaction with a NATS server.
-
-    This class provides methods to establish a connection with a NATS server,
-    publish and subscribe to subjects, send requests and handle responses, and
-    cleanly disconnect from the server. It abstracts the connection and ensures
-    seamless communication with the NATS server.
-
-    :ivar config: Configuration details for the NATS client, including server
-        connection parameters, timeouts, and limits.
-    :type config: NatsConfig
-    :ivar client: Instance of the NATS client used for communication. Initialized
-        as None and assigned upon connecting to a NATS server.
-    :type client: Optional[NatsClient]
-    :ivar subscriptions: List of active subscriptions for NATS subjects.
-    :type subscriptions: list
     """
 
     def __init__(self, config: NatsConfig):
         self.config = config
-        self.client: NatsClient | None = None
-
+        self.client: Optional[NatsClient] = None
         self.subscriptions = []
         self.logger = logging.getLogger(__name__)
 
     async def connect(self) -> None:
-        """Connect to NATS server."""
+        """Connect to NATS server with event handlers and logging."""
         if self.client and self.client.is_connected:
             return
+
+        async def error_cb(e):
+            self.logger.error(f"NATS client error: {e}")
+
+        async def disconnect_cb():
+            self.logger.warning("NATS client disconnected.")
+
+        async def reconnect_cb():
+            self.logger.info("NATS client reconnected.")
+
+        async def closed_cb():
+            self.logger.warning("NATS client connection closed.")
+
         self.logger.info(f"Connecting to NATS server at {self.config.server}")
 
         self.client = await nats.connect(
@@ -45,49 +43,67 @@ class NatsClientRepository:
             reconnect_time_wait=self.config.reconnect_time_wait,
             connect_timeout=self.config.connection_timeout,
             ping_interval=self.config.ping_interval,
-            max_outstanding_pings=self.config.max_outstanding_pings
-        ) #ignore client type warning
-
-    async def publish(self, subject: str, payload: bytes) -> None:
-        """Publish raw message to NATS."""
-        if not self.client or not self.client.is_connected:
-            await self.connect()
-
-        try:
-            await self.client.publish(subject, payload)
-        except Exception as e:
-            print(f"Failed to publish message: {e}")
-            return
+            max_outstanding_pings=self.config.max_outstanding_pings,
+            error_cb=error_cb,
+            disconnected_cb=disconnect_cb,
+            reconnected_cb=reconnect_cb,
+            closed_cb=closed_cb,
+        )  # type: ignore
+
+    async def _ensure_connected(self, retries: int = 5):
+        """Wait and retry until the client is connected."""
+        for attempt in range(retries):
+            if self.client and self.client.is_connected:
+                return
+            self.logger.info(f"Waiting for NATS connection (attempt {attempt+1})...")
+            await asyncio.sleep(2 ** attempt)
+        raise ConnectionError("Could not establish connection to NATS server.")
+
+    async def publish(self, subject: str, payload: bytes, retries: int = 3) -> None:
+        """Publish a raw message to NATS with retries and backoff."""
+        for attempt in range(retries):
+            try:
+                await self._ensure_connected()
+                await self.client.publish(subject, payload)
+                return
+            except Exception as e:
+                self.logger.error(f"Failed to publish message (attempt {attempt+1}): {e}")
+                await asyncio.sleep(2 ** attempt)
+        self.logger.error("Giving up publishing after retries.")
 
     async def subscribe(self, subject: str, callback: Callable) -> Any:
         """Subscribe to a subject with a callback."""
-        if not self.client or not self.client.is_connected:
-            await self.connect()
-
-        subscription = await self.client.subscribe(subject, cb=callback)
-        self.subscriptions.append(subscription)
-        return subscription
-
-    async def request(self, subject: str, payload: bytes, timeout: float = 2.0) -> Optional[bytes]:
-        """Send a request and get raw response."""
-        if not self.client or not self.client.is_connected:
-            await self.connect()
-
+        await self._ensure_connected()
         try:
-            response = await self.client.request(subject, payload, timeout=timeout)
-            return response.data
+            subscription = await self.client.subscribe(subject, cb=callback)
+            self.subscriptions.append(subscription)
+            return subscription
         except Exception as e:
-            print(f"NATS request failed: {e}")
+            self.logger.error(f"Failed to subscribe to {subject}: {e}")
             return None
 
+    async def request(self, subject: str, payload: bytes, timeout: float = 2.0, retries: int = 3) -> Optional[bytes]:
+        """Send a request and get a raw response with retries and backoff."""
+        for attempt in range(retries):
+            try:
+                await self._ensure_connected()
+                response = await self.client.request(subject, payload, timeout=timeout)
+                return response.data
+            except Exception as e:
+                self.logger.error(f"NATS request failed (attempt {attempt+1}): {e}")
+                await asyncio.sleep(2 ** attempt)
+        self.logger.error("Giving up request after retries.")
+        return None
+
     async def close(self) -> None:
         """Close all subscriptions and NATS connection."""
         if self.client and self.client.is_connected:
-            # Unsubscribe from all subscriptions
-            for sub in self.subscriptions:
-                await sub.unsubscribe()
-
-            # Drain and close connection
-            await self.client.drain()
-            self.client = None
-            self.subscriptions = []
+            try:
+                for sub in self.subscriptions:
+                    await sub.unsubscribe()
+                await self.client.drain()
+            except Exception as e:
+                self.logger.error(f"Error during NATS cleanup: {e}")
+            finally:
+                self.client = None
+                self.subscriptions = []

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.39.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.39
+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.39.dist-info → h_message_bus-0.0.41.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+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()
-        }