h-message-bus 0.0.26__py3-none-any.whl → 0.0.27__py3-none-any.whl

h_message_bus/domain/models/request_message_topic.py

@@ -32,6 +32,8 @@ class RequestMessageTopic(str, Enum):
     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"
@@ -44,4 +46,24 @@ class RequestMessageTopic(str, Enum):
     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"
+    WEB_FIND_RELATED_RESPONSE = "hai.tools.web.find.related.response"
+
+    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_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

@@ -0,0 +1,31 @@
+from src.h_message_bus.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/request_messages/graph_clear_request_message.py

@@ -0,0 +1,26 @@
+from typing import TypeVar, Dict, Any, Type
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphClearRequestMessage(HaiMessage):
+    """Message to clear all nodes and relationships from the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls) -> 'GraphClearRequestMessage':
+        """Create a message requesting to clear the graph"""
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_CLEAR,
+            payload={}
+        )
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphClearRequestMessage':
+        return cls.create_message()

h_message_bus/domain/request_messages/graph_get_all_request_message.py

@@ -0,0 +1,27 @@
+
+from typing import TypeVar, Dict, Any, Type, List
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphGetAllRequestMessage(HaiMessage):
+    """Message to get all nodes and relationships from the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls) -> 'GraphGetAllRequestMessage':
+        """Create a message requesting to get all nodes and relationships"""
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_GET_ALL,
+            payload={}
+        )
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphGetAllRequestMessage':
+        return cls.create_message()

h_message_bus/domain/request_messages/graph_get_all_result_response_message.py

@@ -0,0 +1,45 @@
+from typing import TypeVar, Dict, Any, Type, List
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphGetAllResultResponseMessage(HaiMessage):
+    """Message containing all nodes and relationships from the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, nodes: List[Dict], relationships: List[Dict]) -> 'GraphGetAllResultResponseMessage':
+        """Create a message with all nodes and relationships"""
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_GET_ALL_RESPONSE,
+            payload={
+                "nodes": nodes,
+                "relationships": relationships
+            },
+        )
+
+    @property
+    def nodes(self) -> List[Dict]:
+        """Get the list of nodes from the payload"""
+        return self.payload.get("nodes", [])
+
+    @property
+    def relationships(self) -> List[Dict]:
+        """Get the list of relationships from the payload"""
+        return self.payload.get("relationships", [])
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphGetAllResultResponseMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            nodes=payload.get("nodes", []),
+            relationships=payload.get("relationships", [])
+        )

h_message_bus/domain/request_messages/graph_node_add_request_message.py

@@ -0,0 +1,64 @@
+from typing import TypeVar, Dict, Any, Type, Optional
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+
+class GraphNodeAddRequestMessage(HaiMessage):
+    """Message to add a node to the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, node_id: str, label: str, properties: dict = None,
+                       description: str = None) -> 'GraphNodeAddRequestMessage':
+        """Create a message requesting to add a node to the graph"""
+        if properties is None:
+            properties = {}
+
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_NODE_ADD,
+            payload={
+                "node_id": node_id,
+                "label": label,
+                "properties": properties,
+                "description": description
+            },
+        )
+
+    @property
+    def node_id(self) -> str:
+        """Get the node ID from the payload"""
+        return self.payload.get("node_id")
+
+    @property
+    def label(self) -> str:
+        """Get the label from the payload"""
+        return self.payload.get("label")
+
+    @property
+    def properties(self) -> dict:
+        """Get the properties from the payload"""
+        return self.payload.get("properties", {})
+
+    @property
+    def description(self) -> Optional[str]:
+        """Get the description from the payload"""
+        return self.payload.get("description")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeAddRequestMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            node_id=payload.get("node_id", ''),
+            label=payload.get("label", ''),
+            properties=payload.get("properties", {}),
+            description=payload.get("description")
+        )

h_message_bus/domain/request_messages/graph_node_added_response_message.py

@@ -0,0 +1,69 @@
+from typing import TypeVar, Dict, Any, Type, Optional
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphNodeAddedResponseMessage(HaiMessage):
+    """Message indicating a node was successfully added to the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, node_id: str, label: str, properties: dict = None,
+                       description: str = None) -> 'GraphNodeAddedResponseMessage':
+        """Create a message confirming a node was added"""
+        if properties is None:
+            properties = {}
+
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_NODE_ADD_RESPONSE,
+            payload={
+                "node_id": node_id,
+                "label": label,
+                "properties": properties,
+                "description": description,
+                "success": True
+            },
+        )
+
+    @property
+    def node_id(self) -> str:
+        """Get the node ID from the payload"""
+        return self.payload.get("node_id")
+
+    @property
+    def label(self) -> str:
+        """Get the label from the payload"""
+        return self.payload.get("label")
+
+    @property
+    def properties(self) -> dict:
+        """Get the properties from the payload"""
+        return self.payload.get("properties", {})
+
+    @property
+    def description(self) -> Optional[str]:
+        """Get the description from the payload"""
+        return self.payload.get("description")
+
+    @property
+    def success(self) -> bool:
+        """Check if the operation was successful"""
+        return self.payload.get("success", False)
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeAddedResponseMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            node_id=payload.get("node_id", ''),
+            label=payload.get("label", ''),
+            properties=payload.get("properties", {}),
+            description=payload.get("description")
+        )

h_message_bus/domain/request_messages/graph_node_get_request_message.py

@@ -0,0 +1,39 @@
+
+from typing import TypeVar, Dict, Any, Type
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphNodeGetRequestMessage(HaiMessage):
+    """Message to get a node from the graph by ID"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, node_id: str) -> 'GraphNodeGetRequestMessage':
+        """Create a message requesting to get a node from the graph"""
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_NODE_GET,
+            payload={
+                "node_id": node_id
+            },
+        )
+
+    @property
+    def node_id(self) -> str:
+        """Get the node ID from the payload"""
+        return self.payload.get("node_id")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeGetRequestMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            node_id=payload.get("node_id", '')
+        )

h_message_bus/domain/request_messages/graph_node_get_result_response_message.py

@@ -0,0 +1,70 @@
+from typing import TypeVar, Dict, Any, Type, Optional
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphNodeGetResultResponseMessage(HaiMessage):
+    """Message containing a requested node from the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, node_id: str, label: str, properties: dict = None,
+                       description: str = None, found: bool = True) -> 'GraphNodeGetResultResponseMessage':
+        """Create a message with the requested node information"""
+        if properties is None:
+            properties = {}
+
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_NODE_GET_RESPONSE,
+            payload={
+                "node_id": node_id,
+                "label": label,
+                "properties": properties,
+                "description": description,
+                "found": found
+            },
+        )
+
+    @property
+    def node_id(self) -> str:
+        """Get the node ID from the payload"""
+        return self.payload.get("node_id")
+
+    @property
+    def label(self) -> str:
+        """Get the label from the payload"""
+        return self.payload.get("label")
+
+    @property
+    def properties(self) -> dict:
+        """Get the properties from the payload"""
+        return self.payload.get("properties", {})
+
+    @property
+    def description(self) -> Optional[str]:
+        """Get the description from the payload"""
+        return self.payload.get("description")
+
+    @property
+    def found(self) -> bool:
+        """Check if the node was found"""
+        return self.payload.get("found", False)
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeGetResultResponseMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            node_id=payload.get("node_id", ''),
+            label=payload.get("label", ''),
+            properties=payload.get("properties", {}),
+            description=payload.get("description"),
+            found=payload.get("found", False)
+        )

h_message_bus/domain/request_messages/graph_node_update_request_message.py

@@ -0,0 +1,56 @@
+from typing import TypeVar, Dict, Any, Type, Optional
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphNodeUpdateRequestMessage(HaiMessage):
+    """Message to update an existing node in the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, node_id: str, properties: dict = None,
+                       description: str = None) -> 'GraphNodeUpdateRequestMessage':
+        """Create a message requesting to update a node in the graph"""
+        if properties is None:
+            properties = {}
+
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_NODE_UPDATE,
+            payload={
+                "node_id": node_id,
+                "properties": properties,
+                "description": description
+            },
+        )
+
+    @property
+    def node_id(self) -> str:
+        """Get the node ID from the payload"""
+        return self.payload.get("node_id")
+
+    @property
+    def properties(self) -> dict:
+        """Get the properties from the payload"""
+        return self.payload.get("properties", {})
+
+    @property
+    def description(self) -> Optional[str]:
+        """Get the description from the payload"""
+        return self.payload.get("description")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeUpdateRequestMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            node_id=payload.get("node_id", ''),
+            properties=payload.get("properties", {}),
+            description=payload.get("description")
+        )

h_message_bus/domain/request_messages/graph_nodes_by_property_request_message.py

@@ -0,0 +1,45 @@
+from typing import TypeVar, Dict, Any, Type
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphNodesByPropertyRequestMessage(HaiMessage):
+    """Message to get nodes with a specific property value and their relationships"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, property_name: str, property_value: any) -> 'GraphNodesByPropertyRequestMessage':
+        """Create a message requesting nodes with a specific property value"""
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_NODES_BY_PROPERTY,
+            payload={
+                "property_name": property_name,
+                "property_value": property_value
+            },
+        )
+
+    @property
+    def property_name(self) -> str:
+        """Get the property name from the payload"""
+        return self.payload.get("property_name")
+
+    @property
+    def property_value(self) -> any:
+        """Get the property value from the payload"""
+        return self.payload.get("property_value")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodesByPropertyRequestMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            property_name=payload.get("property_name", ''),
+            property_value=payload.get("property_value")
+        )

h_message_bus/domain/request_messages/graph_nodes_by_property_response_message.py

@@ -0,0 +1,80 @@
+from typing import TypeVar, Dict, Any, Type, List
+
+from ...domain.models.hai_message import HaiMessage
+from ..models.request_message_topic import RequestMessageTopic
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphNodesByPropertyResponseMessage(HaiMessage):
+    """Response message containing nodes with a specific property value and their relationships"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, property_name: str, property_value: any,
+                       nodes: List[Dict], relationships: List[Dict],
+                       success: bool = True) -> 'GraphNodesByPropertyResponseMessage':
+        """
+        Create a response message with nodes having a specific property value and their relationships
+
+        Args:
+            property_name: The property name that was queried
+            property_value: The property value that was queried
+            nodes: List of node dictionaries
+            relationships: List of relationship dictionaries
+            success: Whether the operation was successful
+
+        Returns:
+            A response message with the query results
+        """
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_NODES_BY_PROPERTY_RESPONSE,
+            payload={
+                "property_name": property_name,
+                "property_value": property_value,
+                "nodes": nodes,
+                "relationships": relationships,
+                "success": success
+            },
+        )
+
+    @property
+    def property_name(self) -> str:
+        """Get the property name from the payload"""
+        return self.payload.get("property_name")
+
+    @property
+    def property_value(self) -> any:
+        """Get the property value from the payload"""
+        return self.payload.get("property_value")
+
+    @property
+    def nodes(self) -> List[Dict]:
+        """Get the list of nodes from the payload"""
+        return self.payload.get("nodes", [])
+
+    @property
+    def relationships(self) -> List[Dict]:
+        """Get the list of relationships from the payload"""
+        return self.payload.get("relationships", [])
+
+    @property
+    def success(self) -> bool:
+        """Check if the query was successful"""
+        return self.payload.get("success", False)
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodesByPropertyResponseMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            property_name=payload.get("property_name", ''),
+            property_value=payload.get("property_value"),
+            nodes=payload.get("nodes", []),
+            relationships=payload.get("relationships", []),
+            success=payload.get("success", False)
+        )

h_message_bus/domain/request_messages/graph_query_request_message.py

@@ -0,0 +1,48 @@
+from typing import TypeVar, Dict, Any, Type
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphQueryRequestMessage(HaiMessage):
+    """Message to perform a custom query on the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, query: str, parameters: dict = None) -> 'GraphQueryRequestMessage':
+        """Create a message requesting to perform a custom query on the graph"""
+        if parameters is None:
+            parameters = {}
+
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_QUERY,
+            payload={
+                "query": query,
+                "parameters": parameters
+            },
+        )
+
+    @property
+    def query(self) -> str:
+        """Get the query from the payload"""
+        return self.payload.get("query")
+
+    @property
+    def parameters(self) -> dict:
+        """Get the query parameters from the payload"""
+        return self.payload.get("parameters", {})
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphQueryRequestMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            query=payload.get("query", ''),
+            parameters=payload.get("parameters", {})
+        )

h_message_bus/domain/request_messages/graph_relationship_added_request_message.py

@@ -0,0 +1,63 @@
+from typing import TypeVar, Dict, Any, Type
+
+from ...domain.models.hai_message import HaiMessage
+from ..models.request_message_topic import RequestMessageTopic
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphRelationshipAddRequestMessage(HaiMessage):
+    """Message to add a relationship between nodes in the graph"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, source_node_id: str, target_node_id: str,
+                       relationship_type: str, properties: dict = None) -> 'GraphRelationshipAddRequestMessage':
+        """Create a message requesting to add a relationship to the graph"""
+        if properties is None:
+            properties = {}
+
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_RELATIONSHIP_ADD,
+            payload={
+                "source_node_id": source_node_id,
+                "target_node_id": target_node_id,
+                "relationship_type": relationship_type,
+                "properties": properties
+            },
+        )
+
+    @property
+    def source_node_id(self) -> str:
+        """Get the source node ID from the payload"""
+        return self.payload.get("source_node_id")
+
+    @property
+    def target_node_id(self) -> str:
+        """Get the target node ID from the payload"""
+        return self.payload.get("target_node_id")
+
+    @property
+    def relationship_type(self) -> str:
+        """Get the relationship type from the payload"""
+        return self.payload.get("relationship_type")
+
+    @property
+    def properties(self) -> dict:
+        """Get the properties from the payload"""
+        return self.payload.get("properties", {})
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphRelationshipAddRequestMessage':
+        # Extract the necessary fields from the message payload
+        payload = message.payload
+
+        return cls.create_message(
+            source_node_id=payload.get("source_node_id", ''),
+            target_node_id=payload.get("target_node_id", ''),
+            relationship_type=payload.get("relationship_type", ''),
+            properties=payload.get("properties", {})
+        )

h_message_bus/domain/request_messages/tg_message_request_message.py

@@ -1,4 +1,4 @@
-from typing import Type, TypeVar, Dict, Any, Optional
+from typing import Type, TypeVar, Dict, Any
 
 from ..models.request_message_topic import RequestMessageTopic
 from ...domain.models.hai_message import HaiMessage

h_message_bus/domain/request_messages/tg_user_message_reply_request_message.py

@@ -1,4 +1,4 @@
-from typing import Type, TypeVar, Dict, Any, Optional
+from typing import Type, TypeVar, Dict, Any
 
 from ..models.request_message_topic import RequestMessageTopic
 from ...domain.models.hai_message import HaiMessage

h_message_bus/domain/request_messages/twitter_user_tweets_request_message.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import TypeVar, Dict, Any, Type
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+@dataclass
+class TwitterUserTweetsRequestMessage(HaiMessage):
+    """Message to request tweets from a Twitter user"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, user_id: str, max_results: int = 100,
+                       include_replies: bool = False,
+                       include_retweets: bool = False) -> 'TwitterUserTweetsRequestMessage':
+        """Create a message requesting tweets from a Twitter user"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_GET_USER_TWEETS,
+            payload={
+                "user_id": user_id,
+                "max_results": max_results,
+                "include_replies": include_replies,
+                "include_retweets": include_retweets
+            },
+        )
+
+    @property
+    def user_id(self) -> str:
+        """Get the user ID from the payload"""
+        return self.payload.get("user_id")
+
+    @property
+    def max_results(self) -> int:
+        """Get the maximum number of results from the payload"""
+        return self.payload.get("max_results", 100)
+
+    @property
+    def include_replies(self) -> bool:
+        """Get whether to include replies from the payload"""
+        return self.payload.get("include_replies", False)
+
+    @property
+    def include_retweets(self) -> bool:
+        """Get whether to include retweets from the payload"""
+        return self.payload.get("include_retweets", False)
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'TwitterUserTweetsRequestMessage':
+        """Create a TwitterUserTweetsRequestMessage from a HaiMessage"""
+        payload = message.payload
+
+        return cls.create_message(
+            user_id=payload.get("user_id", ""),
+            max_results=payload.get("max_results", 100),
+            include_replies=payload.get("include_replies", False),
+            include_retweets=payload.get("include_retweets", False)
+        )

h_message_bus/domain/request_messages/twitter_user_tweets_response_message.py

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+from typing import TypeVar, Dict, Any, Type, List
+
+from ..models.request_message_topic import RequestMessageTopic
+from ..models.twitter_message_metadata import TwitterMessageMetaData
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+@dataclass
+class TwitterUserTweetsResponseMessage(HaiMessage):
+    """Message containing tweets from a Twitter user"""
+
+    @classmethod
+    def create(cls: Type[T], topic: str, payload: Dict[Any, Any]) -> T:
+        """Create a message - inherited from HaiMessage"""
+        return super().create(topic=topic, payload=payload)
+
+    @classmethod
+    def create_message(cls, user_id: str, tweets: List[Dict[str, Any]],
+                       success: bool = True, error: str = None) -> 'TwitterUserTweetsResponseMessage':
+        """Create a message with tweets from a Twitter user"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_GET_USER_TWEETS_RESPONSE,
+            payload={
+                "user_id": user_id,
+                "tweets": tweets,
+                "success": success,
+                "error": error
+            },
+        )
+
+    @property
+    def user_id(self) -> str:
+        """Get the user ID from the payload"""
+        return self.payload.get("user_id")
+
+    @property
+    def tweets(self) -> List[Dict[str, Any]]:
+        """Get the tweets from the payload"""
+        return self.payload.get("tweets", [])
+
+    @property
+    def success(self) -> bool:
+        """Get whether the request was successful"""
+        return self.payload.get("success", False)
+
+    @property
+    def error(self) -> str:
+        """Get any error message"""
+        return self.payload.get("error")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'TwitterUserTweetsResponseMessage':
+        """Create a TwitterUserTweetsResponseMessage from a HaiMessage"""
+        payload = message.payload
+
+        return cls.create_message(
+            user_id=payload.get("user_id", ""),
+            tweets=payload.get("tweets", []),
+            success=payload.get("success", False),
+            error=payload.get("error")
+        )
+
+    @classmethod
+    def from_twitter_messages(cls, user_id: str,
+                              twitter_messages: List[TwitterMessageMetaData]) -> 'TwitterUserTweetsResponseMessage':
+        """Create a response message from a list of TwitterMessage objects"""
+        tweets = []
+
+        for message in twitter_messages:
+            user = message.user
+
+            tweet_data = {
+                "tweet_id": str(message.tweet_id),
+                "message": message.message,
+                "created_at": message.created_at.isoformat() if message.created_at else None,
+                "view_count": message.view_count,
+                "retweet_count": message.retweet_count,
+                "reply_count": message.reply_count,
+                "user": message.user.to_dict() if user else None,
+            }
+
+            tweets.append(tweet_data)
+
+        return cls.create_message(
+            user_id=user_id,
+            tweets=tweets,
+            success=True
+        )

{h_message_bus-0.0.26.dist-info → h_message_bus-0.0.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h_message_bus
-Version: 0.0.26
+Version: 0.0.27
 Summary: Message bus integration for HAI
 Author-email: shoebill <shoebill.hai@gmail.com>
 Classifier: Programming Language :: Python :: 3

{h_message_bus-0.0.26.dist-info → h_message_bus-0.0.27.dist-info}/RECORD

@@ -13,18 +13,33 @@ h_message_bus/domain/event_messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQ
 h_message_bus/domain/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 h_message_bus/domain/models/event_message_topic.py,sha256=fSjRMBwMD2RE9GBUud38XMrgLZcngURERrbuoAhQ0Hk,717
 h_message_bus/domain/models/hai_message.py,sha256=b5CfX7hi5uNq77IVnZzEi9iotc4b_U2MNYwV6JY7JcU,2146
-h_message_bus/domain/models/request_message_topic.py,sha256=xcbqdL24vgQR04CXvv8pqLIjIYSNpE5OxDcs7LsvmQg,1707
+h_message_bus/domain/models/request_message_topic.py,sha256=JA8BXe4-cjyrfhLyu_y22AUx2QPLUNi3k-8QYGff_Jo,2851
+h_message_bus/domain/models/twitter_message_metadata.py,sha256=f3Ui-Zz5AnU5nQx9BOAVPCV6cg9UUZnBB1-oJtZPRSc,1218
 h_message_bus/domain/models/twitter_user_metadata.py,sha256=N7GVyn2txmlMQ19aatNh7lvzO6FNSj4dKVujestha9o,2827
 h_message_bus/domain/models/vector_collection_metadata.py,sha256=fSy3ZQ-zkYISTpc-_M6XWf1JkufVAlzlS2ZT60TzA2s,891
 h_message_bus/domain/models/vector_query_answer.py,sha256=V1JR5Di7kIVbRF_eq2uPOhDnkZpQvo9pxD41V7MNV7Q,551
 h_message_bus/domain/request_messages/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-h_message_bus/domain/request_messages/tg_message_request_message.py,sha256=0J_PUA9wr0wZEjVBwgAA5YN-RiNEE54bnzyCvheLkmc,1457
-h_message_bus/domain/request_messages/tg_user_message_reply_request_message.py,sha256=XQ4IfaPVaKoagCASxuDHvsqH4nIWE0mAKan_Z6_kba8,1777
+h_message_bus/domain/request_messages/graph_clear_request_message.py,sha256=mhYpSlsN_gweNY3r80_fXRkIUVk8NwHgqADLn0EMGb4,933
+h_message_bus/domain/request_messages/graph_get_all_request_message.py,sha256=n0EhFQTszxJ1PW5zXL8TJPgJcYMaprGV16X-oBdYXVQ,960
+h_message_bus/domain/request_messages/graph_get_all_result_response_message.py,sha256=_ixF85i6LxiIBp1SLdUCL9a6ksyGELrsw2OBsQZEMiw,1668
+h_message_bus/domain/request_messages/graph_node_add_request_message.py,sha256=T7k-ACl5JwSdy_H8wCVPM_UUKGA27ny9e7wBwR2pGFQ,2175
+h_message_bus/domain/request_messages/graph_node_added_response_message.py,sha256=0oN0hJJU2Da8uoK9JvlHosssWCPsY4hqUPJhgd6Pd5Q,2395
+h_message_bus/domain/request_messages/graph_node_get_request_message.py,sha256=G_JlCnwU6a9HEU0gFt8ilOwx1KF-FJC0EqpWw1C4km8,1302
+h_message_bus/domain/request_messages/graph_node_get_result_response_message.py,sha256=kzde_K65UezKm2NLSFehiLrDAVTHXZM9Gd-GDYUZ1dg,2457
+h_message_bus/domain/request_messages/graph_node_update_request_message.py,sha256=gNXcQmpPF6Ut6M8wtRx7Xi7XdpCT9ZJvqPzNoSdwUZQ,1977
+h_message_bus/domain/request_messages/graph_nodes_by_property_request_message.py,sha256=L-oZfZqsI9DG-CFL0G7r-2A-6wTqFuMNkDww2JUR73s,1712
+h_message_bus/domain/request_messages/graph_nodes_by_property_response_message.py,sha256=UDCA769I14BNP2Qmfwg5c6m98nBNVSZ10Kpi8Z8AGAQ,3051
+h_message_bus/domain/request_messages/graph_query_request_message.py,sha256=UXs_m6pgPkYRSRHrhI-c3WAQ31Yj1idZBgavufm32s0,1635
+h_message_bus/domain/request_messages/graph_relationship_added_request_message.py,sha256=a2hJyF78ITCjkvdR_v_NbnUvxFkolnCyN1-71rF-J2I,2388
+h_message_bus/domain/request_messages/tg_message_request_message.py,sha256=bta24fXwwxTMCwdDHlbB20T-0SNkNWdPwNsQbo_OGN0,1447
+h_message_bus/domain/request_messages/tg_user_message_reply_request_message.py,sha256=desDxVddPTp7iOYq7126zDEyaJF1bu9LWEamj-e87IA,1767
 h_message_bus/domain/request_messages/tg_user_message_request_message.py,sha256=pHmmGJpMEnwzbTVVvoD6UOMflQOuQKgErZA9MyRwWt8,3121
 h_message_bus/domain/request_messages/twitter_get_user_request_message.py,sha256=OfC93X1M0vgMU26BBrpA7AdlY32IFdVG_vRT8BdhQOc,1209
 h_message_bus/domain/request_messages/twitter_get_user_response_message.py,sha256=dXhK_JN3Sz6hN8EpDcj7gq6htJ8Yu5G-Cal73XXcEng,3299
 h_message_bus/domain/request_messages/twitter_get_users_request_message.py,sha256=y2Bh77py9RPtKfdPrPi0mv3LVIujne107y8vkPydirs,1545
 h_message_bus/domain/request_messages/twitter_get_users_response_message.py,sha256=UaSFqX_GgBFKWXtxSohdTstsr2HFzZvbcGwCaDyicic,1580
+h_message_bus/domain/request_messages/twitter_user_tweets_request_message.py,sha256=9vAhRxbCCDTqQNNKgp5cDIkiGIsnHwRSOwc6PK6TmcA,2397
+h_message_bus/domain/request_messages/twitter_user_tweets_response_message.py,sha256=DAQauYnUEnKX6AGKF6-zFd0X-j4BNfAMwBMLr5JLEwI,3243
 h_message_bus/domain/request_messages/vector_query_collection_request_message.py,sha256=x1J8SLVBlNS4TFzVJY9UG7mo94l9i4azndwzAlyktZw,1800
 h_message_bus/domain/request_messages/vector_query_collection_response_message.py,sha256=Q589JT_QE-oVsTh1GEmK__3Hct7ijfM1UTcPi0YTGn8,1767
 h_message_bus/domain/request_messages/vector_read_metadata_request_message.py,sha256=P9t6pcynS112F9_Jmbvw8wlfXhs5NOnV48SUVq92xt8,873
@@ -35,7 +50,7 @@ h_message_bus/domain/request_messages/web_search_request_message.py,sha256=ZoB4i
 h_message_bus/infrastructure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 h_message_bus/infrastructure/nats_client_repository.py,sha256=bhaWRK94h2EmFIef2DALnoBJKnuTnx6-iU7IXO2S_EU,3642
 h_message_bus/infrastructure/nats_config.py,sha256=Yzqqd1bCfmUv_4FOnA1dvqIpakzV0BUL2_nXQcndWvo,1304
-h_message_bus-0.0.26.dist-info/METADATA,sha256=cml2BaoERKhEs5LPN8Ln3d2DfDLAjDxAAcSdrWm-_rU,8834
-h_message_bus-0.0.26.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-h_message_bus-0.0.26.dist-info/top_level.txt,sha256=BArjhm_lwFR9yJJEIf-LT_X64psuLkXFdbpQRJUreFE,23
-h_message_bus-0.0.26.dist-info/RECORD,,
+h_message_bus-0.0.27.dist-info/METADATA,sha256=DF655DI4JK6ZVPQXGYRbO0lr-d9-n7ebHVx1q1MstzI,8834
+h_message_bus-0.0.27.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+h_message_bus-0.0.27.dist-info/top_level.txt,sha256=BArjhm_lwFR9yJJEIf-LT_X64psuLkXFdbpQRJUreFE,23
+h_message_bus-0.0.27.dist-info/RECORD,,