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

h_message_bus/domain/request_messages/twitter_get_tweet_response_message.py

@@ -1,54 +0,0 @@
-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='TwitterGetTweetResponseMessage')
-
-
-@dataclass
-class TwitterGetTweetResponseMessage(HaiMessage):
-    """Message to respond to a request to get a tweet by its 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,
-                       tweet_id: str,
-                       success: bool,
-                       tweet: Optional[Dict[str, Any]] = None,
-                       error_message: str = "") -> 'TwitterGetTweetResponseMessage':
-        """Create a response message for a request to get a tweet"""
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_GET_TWEET_RESPONSE,  # You'll need to add this to ResponseMessageTopic
-            payload={
-                "tweet_id": tweet_id,
-                "success": success,
-                "tweet": tweet,
-                "error_message": error_message
-            },
-        )
-
-    @property
-    def tweet_id(self) -> str:
-        """Get the tweet ID that was requested"""
-        return self.payload.get("tweet_id", "")
-
-    @property
-    def success(self) -> bool:
-        """Get whether the get tweet operation was successful"""
-        return self.payload.get("success", False)
-
-    @property
-    def tweet(self) -> Optional[Dict[str, Any]]:
-        """Get the 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 get tweet operation failed"""
-        return self.payload.get("error_message", "")

h_message_bus/domain/request_messages/twitter_get_user_request_message.py

@@ -1,35 +0,0 @@
-from typing import Type, TypeVar, Dict, Any
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class TwitterGetUserRequestMessage(HaiMessage):
-    """Message to request Twitter user information"""
-
-    @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, username: str) -> 'TwitterGetUserRequestMessage':
-        """Create a message requesting Twitter user data"""
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_GET_USER,
-            payload={"username": username},
-        )
-
-    @property
-    def username(self) -> str:
-        """Get the username from the payload"""
-        return self.payload.get("username", "")
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TwitterGetUserRequestMessage':
-        payload = message.payload
-
-        return cls.create_message(
-        username=payload.get("username", "")
-        )

h_message_bus/domain/request_messages/twitter_get_user_response_message.py

@@ -1,96 +0,0 @@
-from typing import Type, TypeVar, Dict, Any, List
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class TwitterGetUserResponseMessage(HaiMessage):
-    """Response of Twitter user information request"""
-
-    @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, screen_name: str, description: str, followers_count: str, like_count: str, is_verified: str, url: str, bio_urls: [str]) -> 'TwitterGetUserResponseMessage':
-        """Create a response message from Twitter user information"""
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_GET_USER_RESPONSE,
-            payload={
-                'id': user_id,
-                'screen_name': screen_name,
-                'description': description,
-                'followers_count': followers_count,
-                'like_count': like_count,
-                'is_verified': is_verified,
-                'url': url,
-                'bio_urls': bio_urls
-            })
-
-    @property
-    def user_id(self) -> str:
-        """Get user ID"""
-        return self.payload.get('id', '')
-
-    @property
-    def screen_name(self) -> str:
-        """Get screen name"""
-        return self.payload.get('screen_name', '')
-
-    @property
-    def description(self) -> str:
-        """Get user description"""
-        return self.payload.get('description', '')
-
-    @property
-    def followers_count(self) -> str:
-        """Get followers count"""
-        return self.payload.get('followers_count', '')
-
-    @property
-    def like_count(self) -> str:
-        """Get like count"""
-        return self.payload.get('like_count', '')
-
-    @property
-    def is_verified(self) -> str:
-        """Get verification status"""
-        return self.payload.get('is_verified', '')
-
-    @property
-    def url(self) -> str:
-        """Get user URL"""
-        return self.payload.get('url', '')
-
-    @property
-    def bio_urls(self) -> List[str]:
-        """Get URLs from user bio"""
-        return self.payload.get('bio_urls', [])
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TwitterGetUserResponseMessage':
-        """
-        Convert a HaiMessage to TwitterGetUserResponseMessage
-
-        Args:
-            message: The source HaiMessage object
-
-        Returns:
-            A new TwitterGetUserResponseMessage with data from the source message
-        """
-        # Extract necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            user_id=payload.get('id', ''),
-            screen_name=payload.get('screen_name', ''),
-            description=payload.get('description', ''),
-            followers_count=payload.get('followers_count', ''),
-            like_count=payload.get('like_count', ''),
-            is_verified=payload.get('is_verified', ''),
-            url=payload.get('url', ''),
-            bio_urls=payload.get('bio_urls', [])
-        )
-

h_message_bus/domain/request_messages/twitter_get_users_request_message.py

@@ -1,42 +0,0 @@
-import json
-from typing import Type, TypeVar, Dict, Any, List
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class TwitterGetUsersRequestMessage(HaiMessage):
-    """Message to request Twitter user information"""
-
-    @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, usernames: List[str]) -> 'TwitterGetUsersRequestMessage':
-        """Create a message requesting Twitter user data"""
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_GET_USERS,
-            payload={"usernames": json.dumps(usernames)},
-        )
-
-    @property
-    def usernames(self) -> List[str]:
-        """Get the username from the payload"""
-        usernames_payload = self.payload.get("usernames", "")
-        usernames = json.loads(usernames_payload)
-        response_list = []
-        for username in usernames:
-            response_list.append(username)
-        return response_list
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TwitterGetUsersRequestMessage':
-        payload = message.payload
-        usernames = payload.get("usernames", "")
-        usernames_list = json.loads(usernames)
-        return cls.create_message(
-        usernames=usernames_list
-        )

h_message_bus/domain/request_messages/twitter_get_users_response_message.py

@@ -1,44 +0,0 @@
-import json
-from typing import Type, TypeVar, Dict, Any, List
-
-from ..models.request_message_topic import RequestMessageTopic
-from ..models.twitter_user_metadata import TwitterUserMetadata
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class TwitterGetUsersResponseMessage(HaiMessage):
-
-    @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, users: List[dict[str, str]]) -> 'TwitterGetUsersResponseMessage':
-        user_result = json.dumps(users)
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_GET_USERS_RESPONSE,
-            payload={
-                "users": user_result,
-            },
-        )
-
-    @property
-    def users(self) -> List[TwitterUserMetadata]:
-        """Get the collection name from the message payload"""
-        users = self.payload.get("users", "")
-        users_dict = json.loads(users)
-        response_list = []
-        for user in users_dict:
-            response_list.append(TwitterUserMetadata.from_dict(user))
-        return response_list
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TwitterGetUsersResponseMessage':
-        payload = message.payload
-        metadata = payload.get("users", "")
-        meta_list = json.loads(metadata)
-        return cls.create_message(
-            users=meta_list
-        )

h_message_bus/domain/request_messages/twitter_home_timeline_request_message.py

@@ -1,56 +0,0 @@
-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/domain/request_messages/twitter_home_timeline_response_message.py

@@ -1,74 +0,0 @@
-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/domain/request_messages/twitter_post_tweet_request_message.py

@@ -1,40 +0,0 @@
-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/domain/request_messages/twitter_post_tweet_response_message.py

@@ -1,47 +0,0 @@
-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/domain/request_messages/twitter_quote_retweet_request_message.py

@@ -1,48 +0,0 @@
-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='TwitterQuoteRetweetRequestMessage')
-
-
-@dataclass
-class TwitterQuoteRetweetRequestMessage(HaiMessage):
-    """Message to request creating a quote retweet"""
-
-    @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) -> 'TwitterQuoteRetweetRequestMessage':
-        """Create a message requesting to quote retweet a tweet"""
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_QUOTE_RETWEET,  # 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 quote retweet from the payload"""
-        return self.payload.get("tweet_id", "")
-
-    @property
-    def text(self) -> str:
-        """Get the text content to add to the quote retweet from the payload"""
-        return self.payload.get("text", "")
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TwitterQuoteRetweetRequestMessage':
-        """Create a TwitterQuoteRetweetRequestMessage from a HaiMessage"""
-        payload = message.payload
-
-        return cls.create_message(
-            tweet_id=payload.get("tweet_id", ""),
-            text=payload.get("text", "")
-        )

h_message_bus/domain/request_messages/twitter_quote_retweet_response_message.py

@@ -1,55 +0,0 @@
-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='TwitterQuoteRetweetResponseMessage')
-
-
-@dataclass
-class TwitterQuoteRetweetResponseMessage(HaiMessage):
-    """Message to respond to a request to quote 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,
-                       original_tweet_id: str,
-                       success: bool,
-                       quote_tweet: Optional[Dict[str, Any]] = None,
-                       error_message: str = "") -> 'TwitterQuoteRetweetResponseMessage':
-        """Create a response message for a request to quote retweet a tweet"""
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_QUOTE_RETWEET_RESPONSE,
-            # You'll need to add this to ResponseMessageTopic
-            payload={
-                "original_tweet_id": original_tweet_id,
-                "success": success,
-                "quote_tweet": quote_tweet,
-                "error_message": error_message
-            },
-        )
-
-    @property
-    def original_tweet_id(self) -> str:
-        """Get the original tweet ID that was quote retweeted"""
-        return self.payload.get("original_tweet_id", "")
-
-    @property
-    def success(self) -> bool:
-        """Get whether the quote retweet operation was successful"""
-        return self.payload.get("success", False)
-
-    @property
-    def quote_tweet(self) -> Optional[Dict[str, Any]]:
-        """Get the quote tweet data if the operation was successful"""
-        return self.payload.get("quote_tweet", None)
-
-    @property
-    def error_message(self) -> str:
-        """Get the error message if the quote retweet operation failed"""
-        return self.payload.get("error_message", "")

h_message_bus/domain/request_messages/twitter_reply_request_message.py

@@ -1,48 +0,0 @@
-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", "")
-        )