h-message-bus 0.0.32__tar.gz → 0.0.34__tar.gz

{h_message_bus-0.0.32 → h_message_bus-0.0.34}/PKG-INFO

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

{h_message_bus-0.0.32 → h_message_bus-0.0.34}/pyproject.toml

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

{h_message_bus-0.0.32 → h_message_bus-0.0.34}/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"

h_message_bus-0.0.34/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.34/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.34/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.34/src/h_message_bus/domain/request_messages/twitter_home_timeline_response_message.py

@@ -0,0 +1,74 @@
+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)
+
+    @classmethod
+    def from_hai_message(cls, message: HaiMessage) -> 'TwitterHomeTimelineResponseMessage':
+        """Create a TwitterHomeTimelineResponseMessage from a HaiMessage"""
+        payload = message.payload
+
+        return cls.create_message(
+            tweets=payload.get("tweets", [])
+        )

h_message_bus-0.0.34/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.34/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.34/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.34/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.34/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.34/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.32 → h_message_bus-0.0.34}/src/h_message_bus.egg-info/PKG-INFO

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

{h_message_bus-0.0.32 → h_message_bus-0.0.34}/src/h_message_bus.egg-info/SOURCES.txt

@@ -45,10 +45,20 @@ 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