h-message-bus 0.0.31__tar.gz → 0.0.33__tar.gz

{h_message_bus-0.0.31 → h_message_bus-0.0.33}/PKG-INFO

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

{h_message_bus-0.0.31 → h_message_bus-0.0.33}/pyproject.toml

@@ -4,7 +4,7 @@
 
    [project]
    name = "h_message_bus"
-   version = "0.0.31"
+   version = "0.0.33"
    authors = [
        {name = "shoebill", email = "shoebill.hai@gmail.com"},
    ]

{h_message_bus-0.0.31 → h_message_bus-0.0.33}/src/h_message_bus/domain/models/request_message_topic.py

@@ -38,6 +38,21 @@ class RequestMessageTopic(str, Enum):
     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"
+
     # tools
     WEB_SEARCH = "hai.tools.web.search"
     WEB_SEARCH_RESPONSE = "hai.tools.web.search.response"
@@ -63,6 +78,9 @@ class RequestMessageTopic(str, Enum):
     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"

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/graph_query_operation_request_message.py

@@ -0,0 +1,114 @@
+import json
+from typing import Dict, Any, Type, TypeVar
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='HaiMessage')
+
+
+class GraphQueryOperationRequestMessage(HaiMessage):
+    """Message to request graph query operations"""
+
+    @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,
+                       operation_type: str,
+                       anchor_node: str,
+                       relationship_direction: str = None,
+                       relationship_type: str = None,
+                       limit: int = None,
+                       traversal_depth: int = None) -> 'GraphQueryOperationRequestMessage':
+        """
+        Create a message requesting a graph query operation
+
+        Args:
+            operation_type: One of 'FIND_RELATED_NODES', 'GET_NODE_INFO', 'COUNT_RELATIONSHIPS'
+            anchor_node: The central node in the query (e.g., 'hyperliquid')
+            relationship_direction: One of 'INCOMING', 'OUTGOING', or 'BOTH'
+            relationship_type: The relationship type to traverse (e.g., 'BUILDS_ON')
+            limit: Numerical limit of results to return
+            traversal_depth: How many relationship hops to traverse
+
+        Returns:
+            A new GraphQueryOperationRequestMessage
+        """
+        # Build the query operation dictionary
+        query_operation = {
+            "operation_type": operation_type,
+            "anchor_node": anchor_node,
+        }
+
+        # Add optional parameters if provided
+        if relationship_direction is not None:
+            query_operation["relationship_direction"] = relationship_direction
+
+        if relationship_type is not None:
+            query_operation["relationship_type"] = relationship_type
+
+        if limit is not None:
+            query_operation["limit"] = f"{limit}"
+
+        if traversal_depth is not None:
+            query_operation["traversal_depth"] = f"{traversal_depth}"
+
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_QUERY_OPERATION,
+            payload={"query_operation": json.dumps(query_operation)},
+        )
+
+    @property
+    def query_operation(self) -> Dict[str, Any]:
+        """Get the query operation from the payload"""
+        query_operation_payload = self.payload.get("query_operation", "{}")
+        return json.loads(query_operation_payload)
+
+    @property
+    def operation_type(self) -> str:
+        """Get the operation type from the query operation"""
+        return self.query_operation.get("operation_type", "")
+
+    @property
+    def anchor_node(self) -> str:
+        """Get the anchor node from the query operation"""
+        return self.query_operation.get("anchor_node", "")
+
+    @property
+    def relationship_direction(self) -> str:
+        """Get the relationship direction from the query operation"""
+        return self.query_operation.get("relationship_direction", "BOTH")
+
+    @property
+    def relationship_type(self) -> str:
+        """Get the relationship type from the query operation"""
+        return self.query_operation.get("relationship_type", "")
+
+    @property
+    def limit(self) -> int:
+        """Get the limit from the query operation"""
+        return int(self.query_operation.get("limit", 10))
+
+    @property
+    def traversal_depth(self) -> int:
+        """Get the traversal depth from the query operation"""
+        return int(self.query_operation.get("traversal_depth", 1))
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphQueryOperationRequestMessage':
+        """Create a GraphQueryOperationRequestMessage from a HaiMessage"""
+        payload = message.payload
+        query_operation_str = payload.get("query_operation", "{}")
+        query_operation = json.loads(query_operation_str)
+
+        return cls.create_message(
+            operation_type=query_operation.get("operation_type", ""),
+            anchor_node=query_operation.get("anchor_node", ""),
+            relationship_direction=query_operation.get("relationship_direction"),
+            relationship_type=query_operation.get("relationship_type"),
+            limit=query_operation.get("limit"),
+            traversal_depth=query_operation.get("traversal_depth")
+        )

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/graph_query_operation_response_message.py

@@ -0,0 +1,85 @@
+import json
+from typing import Dict, Any, TypeVar, Type
+
+from ...domain.models.hai_message import HaiMessage
+from ..models.request_message_topic import RequestMessageTopic
+
+T = TypeVar('T', bound='HaiMessage')
+
+class GraphQueryOperationResponseMessage(HaiMessage):
+    """Message with results from graph query operations"""
+
+    @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,
+                       operation_type: str,
+                       result: Dict[str, Any],
+                       success: bool = True,
+                       error_message: str = None) -> 'GraphQueryOperationResponseMessage':
+        """
+        Create a response message with graph query operation results
+
+        Args:
+            operation_type: The type of operation that was performed
+            result: Dictionary containing the operation results
+            success: Whether the operation was successful
+            error_message: Error message if the operation failed
+
+        Returns:
+            A new GraphQueryOperationResponseMessage
+        """
+        payload = {
+            "operation_type": operation_type,
+            "result": json.dumps(result),
+            "success": success
+        }
+
+        if error_message:
+            payload["error_message"] = error_message
+
+        return cls.create(
+            topic=RequestMessageTopic.GRAPH_QUERY_OPERATION_RESPONSE,
+            payload=payload,
+        )
+
+    @property
+    def operation_type(self) -> str:
+        """Get the operation type from the payload"""
+        return self.payload.get("operation_type", "")
+
+    @property
+    def result(self) -> Dict[str, Any]:
+        """Get the result from the payload"""
+        result_str = self.payload.get("result", "{}")
+        return json.loads(result_str)
+
+    @property
+    def success(self) -> bool:
+        """Get the success status from the payload"""
+        return self.payload.get("success", False)
+
+    @property
+    def error_message(self) -> str:
+        """Get the error message from the payload"""
+        return self.payload.get("error_message", "")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'GraphQueryOperationResponseMessage':
+        """Create a GraphQueryOperationResponseMessage from a HaiMessage"""
+        payload = message.payload
+        operation_type = payload.get("operation_type", "")
+        result_str = payload.get("result", "{}")
+        result = json.loads(result_str)
+        success = payload.get("success", False)
+        error_message = payload.get("error_message")
+
+        return cls.create_message(
+            operation_type=operation_type,
+            result=result,
+            success=success,
+            error_message=error_message
+        )

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_follow_user_request_message.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterFollowUserRequestMessage')
+
+@dataclass
+class TwitterFollowUserRequestMessage(HaiMessage):
+    """Message to request following 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) -> 'TwitterFollowUserRequestMessage':
+        """Create a message requesting to follow a Twitter user"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_FOLLOW_USER,  # You'll need to add this to RequestMessageTopic
+            payload={
+                "user_id": user_id
+            },
+        )
+
+    @property
+    def user_id(self) -> str:
+        """Get the user ID from the payload"""
+        return self.payload.get("user_id", "")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'TwitterFollowUserRequestMessage':
+        """Create a TwitterFollowUserRequestMessage from a HaiMessage"""
+        payload = message.payload
+
+        return cls.create_message(
+            user_id=payload.get("user_id", "")
+        )

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_follow_user_response_message.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterFollowUserResponseMessage')
+
+@dataclass
+class TwitterFollowUserResponseMessage(HaiMessage):
+    """Message to respond to a request to follow 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, success: bool, error_message: str = "") -> 'TwitterFollowUserResponseMessage':
+        """Create a response message for a request to follow a Twitter user"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_FOLLOW_USER_RESPONSE,  # You'll need to add this to ResponseMessageTopic
+            payload={
+                "user_id": user_id,
+                "success": success,
+                "error_message": error_message
+            },
+        )
+
+    @property
+    def user_id(self) -> str:
+        """Get the user ID from the payload"""
+        return self.payload.get("user_id", "")
+
+    @property
+    def success(self) -> bool:
+        """Get whether the follow operation was successful"""
+        return self.payload.get("success", False)
+
+    @property
+    def error_message(self) -> str:
+        """Get the error message if the follow operation failed"""
+        return self.payload.get("error_message", "")

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_home_timeline_request_message.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterHomeTimelineRequestMessage')
+
+@dataclass
+class TwitterHomeTimelineRequestMessage(HaiMessage):
+    """Message to request the home timeline for the authenticated 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, max_results: int = 100,
+                      include_replies: bool = True,
+                      include_retweets: bool = True) -> 'TwitterHomeTimelineRequestMessage':
+        """Create a message requesting the Twitter home timeline"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_GET_HOME_TIMELINE,  # You'll need to add this to RequestMessageTopic
+            payload={
+                "max_results": max_results,
+                "include_replies": include_replies,
+                "include_retweets": include_retweets
+            },
+        )
+
+    @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", True)
+
+    @property
+    def include_retweets(self) -> bool:
+        """Get whether to include retweets from the payload"""
+        return self.payload.get("include_retweets", True)
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'TwitterHomeTimelineRequestMessage':
+        """Create a TwitterHomeTimelineRequestMessage from a HaiMessage"""
+        payload = message.payload
+
+        return cls.create_message(
+            max_results=payload.get("max_results", 100),
+            include_replies=payload.get("include_replies", True),
+            include_retweets=payload.get("include_retweets", True)
+        )

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_home_timeline_response_message.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar, List
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterHomeTimelineResponseMessage')
+
+
+@dataclass
+class TwitterMessageMetaData:
+    """Metadata about a Twitter message"""
+    tweet_id: str
+    user: Dict[str, Any]
+    message: str
+    created_at: str
+    view_count: int
+    retweet_count: int
+    reply_count: int
+
+
+@dataclass
+class TwitterHomeTimelineResponseMessage(HaiMessage):
+    """Message containing the home timeline for the authenticated 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, tweets: List[Dict[str, Any]]) -> 'TwitterHomeTimelineResponseMessage':
+        """Create a response message with the user's home timeline tweets"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_GET_HOME_TIMELINE_RESPONSE,
+            # You'll need to add this to ResponseMessageTopic
+            payload={
+                "tweets": tweets
+            },
+        )
+
+    @property
+    def tweets(self) -> List[Dict[str, Any]]:
+        """Get the tweets from the payload"""
+        return self.payload.get("tweets", [])
+
+    @classmethod
+    def from_twitter_messages(cls,
+                              twitter_messages: List[TwitterMessageMetaData]) -> 'TwitterHomeTimelineResponseMessage':
+        """Create a TwitterHomeTimelineResponseMessage from a list of TwitterMessageMetaData"""
+        tweet_list = []
+
+        for message in twitter_messages:
+            tweet_data = {
+                "tweet_id": message.tweet_id,
+                "message": message.message,
+                "created_at": message.created_at,
+                "view_count": message.view_count,
+                "retweet_count": message.retweet_count,
+                "reply_count": message.reply_count,
+                "user": message.user
+            }
+            tweet_list.append(tweet_data)
+
+        return cls.create_message(tweets=tweet_list)

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_post_tweet_request_message.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterPostTweetRequestMessage')
+
+@dataclass
+class TwitterPostTweetRequestMessage(HaiMessage):
+    """Message to request posting a new tweet"""
+
+    @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, text: str) -> 'TwitterPostTweetRequestMessage':
+        """Create a message requesting to post a new tweet"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_POST_TWEET,  # You'll need to add this to RequestMessageTopic
+            payload={
+                "text": text
+            },
+        )
+
+    @property
+    def text(self) -> str:
+        """Get the text content of the tweet from the payload"""
+        return self.payload.get("text", "")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'TwitterPostTweetRequestMessage':
+        """Create a TwitterPostTweetRequestMessage from a HaiMessage"""
+        payload = message.payload
+
+        return cls.create_message(
+            text=payload.get("text", "")
+        )

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_post_tweet_response_message.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar, Optional
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterPostTweetResponseMessage')
+
+
+@dataclass
+class TwitterPostTweetResponseMessage(HaiMessage):
+    """Message to respond to a request to post a new tweet"""
+
+    @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,
+                       success: bool,
+                       tweet: Optional[Dict[str, Any]] = None,
+                       error_message: str = "") -> 'TwitterPostTweetResponseMessage':
+        """Create a response message for a request to post a new tweet"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_POST_TWEET_RESPONSE,  # You'll need to add this to ResponseMessageTopic
+            payload={
+                "success": success,
+                "tweet": tweet,
+                "error_message": error_message
+            },
+        )
+
+    @property
+    def success(self) -> bool:
+        """Get whether the post tweet operation was successful"""
+        return self.payload.get("success", False)
+
+    @property
+    def tweet(self) -> Optional[Dict[str, Any]]:
+        """Get the posted tweet data if the operation was successful"""
+        return self.payload.get("tweet", None)
+
+    @property
+    def error_message(self) -> str:
+        """Get the error message if the post tweet operation failed"""
+        return self.payload.get("error_message", "")

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_reply_request_message.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterReplyRequestMessage')
+
+
+@dataclass
+class TwitterReplyRequestMessage(HaiMessage):
+    """Message to request replying to a tweet"""
+
+    @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, tweet_id: str, text: str) -> 'TwitterReplyRequestMessage':
+        """Create a message requesting to reply to a tweet"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_REPLY,  # You'll need to add this to RequestMessageTopic
+            payload={
+                "tweet_id": tweet_id,
+                "text": text
+            },
+        )
+
+    @property
+    def tweet_id(self) -> str:
+        """Get the tweet ID to reply to from the payload"""
+        return self.payload.get("tweet_id", "")
+
+    @property
+    def text(self) -> str:
+        """Get the text content of the reply from the payload"""
+        return self.payload.get("text", "")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'TwitterReplyRequestMessage':
+        """Create a TwitterReplyRequestMessage from a HaiMessage"""
+        payload = message.payload
+
+        return cls.create_message(
+            tweet_id=payload.get("tweet_id", ""),
+            text=payload.get("text", "")
+        )

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_reply_response_message.py

@@ -0,0 +1,54 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar, Optional
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterReplyResponseMessage')
+
+
+@dataclass
+class TwitterReplyResponseMessage(HaiMessage):
+    """Message to respond to a request to reply to a tweet"""
+
+    @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,
+                       original_tweet_id: str,
+                       success: bool,
+                       reply_tweet: Optional[Dict[str, Any]] = None,
+                       error_message: str = "") -> 'TwitterReplyResponseMessage':
+        """Create a response message for a request to reply to a tweet"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_REPLY_RESPONSE,  # You'll need to add this to ResponseMessageTopic
+            payload={
+                "original_tweet_id": original_tweet_id,
+                "success": success,
+                "reply_tweet": reply_tweet,
+                "error_message": error_message
+            },
+        )
+
+    @property
+    def original_tweet_id(self) -> str:
+        """Get the original tweet ID that was replied to"""
+        return self.payload.get("original_tweet_id", "")
+
+    @property
+    def success(self) -> bool:
+        """Get whether the reply operation was successful"""
+        return self.payload.get("success", False)
+
+    @property
+    def reply_tweet(self) -> Optional[Dict[str, Any]]:
+        """Get the reply tweet data if the operation was successful"""
+        return self.payload.get("reply_tweet", None)
+
+    @property
+    def error_message(self) -> str:
+        """Get the error message if the reply operation failed"""
+        return self.payload.get("error_message", "")

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_retweet_request_message.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterRetweetRequestMessage')
+
+@dataclass
+class TwitterRetweetRequestMessage(HaiMessage):
+    """Message to request retweeting a tweet"""
+
+    @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, tweet_id: str) -> 'TwitterRetweetRequestMessage':
+        """Create a message requesting to retweet a tweet"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_RETWEET,  # You'll need to add this to RequestMessageTopic
+            payload={
+                "tweet_id": tweet_id
+            },
+        )
+
+    @property
+    def tweet_id(self) -> str:
+        """Get the tweet ID from the payload"""
+        return self.payload.get("tweet_id", "")
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'TwitterRetweetRequestMessage':
+        """Create a TwitterRetweetRequestMessage from a HaiMessage"""
+        payload = message.payload
+
+        return cls.create_message(
+            tweet_id=payload.get("tweet_id", "")
+        )

h_message_bus-0.0.33/src/h_message_bus/domain/request_messages/twitter_retweet_response_message.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+from typing import Type, Dict, Any, TypeVar
+
+from ..models.request_message_topic import RequestMessageTopic
+from ...domain.models.hai_message import HaiMessage
+
+T = TypeVar('T', bound='TwitterRetweetResponseMessage')
+
+@dataclass
+class TwitterRetweetResponseMessage(HaiMessage):
+    """Message to respond to a request to retweet a tweet"""
+
+    @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, tweet_id: str, success: bool, error_message: str = "") -> 'TwitterRetweetResponseMessage':
+        """Create a response message for a request to retweet a tweet"""
+        return cls.create(
+            topic=RequestMessageTopic.TWITTER_RETWEET_RESPONSE,  # You'll need to add this to ResponseMessageTopic
+            payload={
+                "tweet_id": tweet_id,
+                "success": success,
+                "error_message": error_message
+            },
+        )
+
+    @property
+    def tweet_id(self) -> str:
+        """Get the tweet ID from the payload"""
+        return self.payload.get("tweet_id", "")
+
+    @property
+    def success(self) -> bool:
+        """Get whether the retweet operation was successful"""
+        return self.payload.get("success", False)
+
+    @property
+    def error_message(self) -> str:
+        """Get the error message if the retweet operation failed"""
+        return self.payload.get("error_message", "")

{h_message_bus-0.0.31 → h_message_bus-0.0.33}/src/h_message_bus.egg-info/PKG-INFO

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

{h_message_bus-0.0.31 → h_message_bus-0.0.33}/src/h_message_bus.egg-info/SOURCES.txt

@@ -37,16 +37,28 @@ src/h_message_bus/domain/request_messages/graph_node_update_request_message.py
 src/h_message_bus/domain/request_messages/graph_node_update_response_message.py
 src/h_message_bus/domain/request_messages/graph_nodes_by_property_request_message.py
 src/h_message_bus/domain/request_messages/graph_nodes_by_property_response_message.py
+src/h_message_bus/domain/request_messages/graph_query_operation_request_message.py
+src/h_message_bus/domain/request_messages/graph_query_operation_response_message.py
 src/h_message_bus/domain/request_messages/graph_query_request_message.py
 src/h_message_bus/domain/request_messages/graph_relationship_added_request_message.py
 src/h_message_bus/domain/request_messages/init_knowledgebase_request.py
 src/h_message_bus/domain/request_messages/tg_message_request_message.py
 src/h_message_bus/domain/request_messages/tg_user_message_reply_request_message.py
 src/h_message_bus/domain/request_messages/tg_user_message_request_message.py
+src/h_message_bus/domain/request_messages/twitter_follow_user_request_message.py
+src/h_message_bus/domain/request_messages/twitter_follow_user_response_message.py
 src/h_message_bus/domain/request_messages/twitter_get_user_request_message.py
 src/h_message_bus/domain/request_messages/twitter_get_user_response_message.py
 src/h_message_bus/domain/request_messages/twitter_get_users_request_message.py
 src/h_message_bus/domain/request_messages/twitter_get_users_response_message.py
+src/h_message_bus/domain/request_messages/twitter_home_timeline_request_message.py
+src/h_message_bus/domain/request_messages/twitter_home_timeline_response_message.py
+src/h_message_bus/domain/request_messages/twitter_post_tweet_request_message.py
+src/h_message_bus/domain/request_messages/twitter_post_tweet_response_message.py
+src/h_message_bus/domain/request_messages/twitter_reply_request_message.py
+src/h_message_bus/domain/request_messages/twitter_reply_response_message.py
+src/h_message_bus/domain/request_messages/twitter_retweet_request_message.py
+src/h_message_bus/domain/request_messages/twitter_retweet_response_message.py
 src/h_message_bus/domain/request_messages/twitter_user_tweets_request_message.py
 src/h_message_bus/domain/request_messages/twitter_user_tweets_response_message.py
 src/h_message_bus/domain/request_messages/vector_query_collection_request_message.py