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

h_message_bus/domain/request_messages/twitter_reply_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='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/domain/request_messages/twitter_retweet_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='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/domain/request_messages/twitter_retweet_response_message.py

@@ -1,43 +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='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/domain/request_messages/twitter_search_request_message.py

@@ -1,73 +0,0 @@
-from typing import Dict, Any, Type, TypeVar, Optional, Literal, cast
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-
-class TwitterSearchRequestMessage(HaiMessage):
-    """Message to request Twitter search"""
-
-    @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,
-            max_results: int = 10,
-            min_view_count: int = 50,
-            sort_order: Literal["relevancy", "recency"] = "relevancy"
-    ) -> 'TwitterSearchRequestMessage':
-        """Create a message requesting Twitter search"""
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_SEARCH,
-            payload={
-                "query": query,
-                "max_results": max_results,
-                "min_view_count": min_view_count,
-                "sort_order": sort_order
-            },
-        )
-
-    @property
-    def query(self) -> str:
-        """Get the search query from the payload"""
-        return self.payload.get("query", "")
-
-    @property
-    def max_results(self) -> int:
-        """Get the maximum number of results from the payload"""
-        return self.payload.get("max_results", 10)
-
-    @property
-    def min_view_count(self) -> int:
-        """Get the minimum view count from the payload"""
-        return self.payload.get("min_view_count", 50)
-
-    @property
-    def sort_order(self) -> Literal["relevancy", "recency"]:
-        """Get the sort order from the payload"""
-        sort_order_str = self.payload.get("sort_order", "relevancy")
-        if sort_order_str not in ("relevancy", "recency"):
-            sort_order_str = "relevancy"
-        return cast(Literal["relevancy", "recency"], sort_order_str)
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TwitterSearchRequestMessage':
-        """Create a TwitterSearchRequestMessage from a HaiMessage"""
-        payload = message.payload
-        query = payload.get("query", "")
-        max_results = payload.get("max_results", 10)
-        min_view_count = payload.get("min_view_count", 50)
-        sort_order = payload.get("sort_order", "relevancy")
-
-        return cls.create_message(
-            query=query,
-            max_results=max_results,
-            min_view_count=min_view_count,
-            sort_order=sort_order
-        )

h_message_bus/domain/request_messages/twitter_search_response_message.py

@@ -1,73 +0,0 @@
-from typing import Dict, Any, Type, TypeVar, List, Optional
-import json
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-
-class TwitterSearchResponseMessage(HaiMessage):
-    """Message containing Twitter search results"""
-
-    @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,
-            results: List[Dict[str, Any]],
-            result_count: int,
-            request_id: str
-    ) -> 'TwitterSearchResponseMessage':
-        """Create a message containing Twitter search results"""
-        return cls.create(
-            topic=RequestMessageTopic.TWITTER_SEARCH_RESPONSE,
-            payload={
-                "query": query,
-                "results": json.dumps(results),
-                "result_count": result_count,
-                "request_id": request_id
-            },
-        )
-
-    @property
-    def query(self) -> str:
-        """Get the search query from the payload"""
-        return self.payload.get("query", "")
-
-    @property
-    def result_count(self) -> int:
-        """Get the number of results from the payload"""
-        return self.payload.get("result_count", 0)
-
-    @property
-    def request_id(self) -> str:
-        """Get the original request ID from the payload"""
-        return self.payload.get("request_id", "")
-
-    @property
-    def results(self) -> List[Dict[str, Any]]:
-        """Get the search results from the payload"""
-        results_json = self.payload.get("results", "[]")
-        return json.loads(results_json)
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TwitterSearchResponseMessage':
-        """Create a TwitterSearchResponseMessage from a HaiMessage"""
-        payload = message.payload
-        query = payload.get("query", "")
-        results_json = payload.get("results", "[]")
-        results = json.loads(results_json)
-        result_count = payload.get("result_count", 0)
-        request_id = payload.get("request_id", "")
-
-        return cls.create_message(
-            query=query,
-            results=results,
-            result_count=result_count,
-            request_id=request_id
-        )

h_message_bus/domain/request_messages/twitter_user_tweets_request_message.py

@@ -1,63 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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,
-                "view_count": message.view_count,
-                "retweet_count": message.retweet_count,
-                "reply_count": message.reply_count,
-                "user": message.user,
-            }
-
-            tweets.append(tweet_data)
-
-        return cls.create_message(
-            user_id=user_id,
-            tweets=tweets,
-            success=True
-        )

h_message_bus/domain/request_messages/vector_query_collection_request_message.py

@@ -1,51 +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 VectorQueryCollectionRequestMessage(HaiMessage):
-    """Message to read data from vector store"""
-
-    @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, collection_name: str, query: str, top_n: str) -> 'VectorQueryCollectionRequestMessage':
-        """Create a message requesting Twitter user data"""
-        return cls.create(
-            topic=RequestMessageTopic.VECTORS_QUERY,
-            payload={
-                "collection_name": collection_name,
-                "query": query,
-                "top_n": top_n
-            },
-        )
-
-    @property
-    def collection_name(self) -> str:
-        """Get the collection name from the message payload"""
-        return self.payload.get("collection_name", "")
-
-    @property
-    def query(self) -> str:
-        """Get the query from the message payload"""
-        return self.payload.get("query", "")
-
-    @property
-    def top_n(self) -> str:
-        """Get the top_n value from the message payload"""
-        return self.payload.get("top_n", "")
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'VectorQueryCollectionRequestMessage':
-        payload = message.payload
-
-        return cls.create_message(
-            collection_name=payload.get("collection_name", ""),
-            query=payload.get("query", ""),
-            top_n=payload.get("top_n", "")
-        )

h_message_bus/domain/request_messages/vector_query_collection_response_message.py

@@ -1,47 +0,0 @@
-import json
-from typing import Type, TypeVar, Dict, Any
-
-from ..models.request_message_topic import RequestMessageTopic
-from ..models.vector_query_answer import VectorQueryAnswer
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class VectorQueryCollectionResponseMessage(HaiMessage):
-    """Response Message from reading vector data"""
-
-    @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, result: dict[int, dict[str, str]]) -> 'VectorQueryCollectionResponseMessage':
-        """Create a message requesting Twitter user data"""
-        result_list = json.dumps(result)
-        return cls.create(
-            topic=RequestMessageTopic.VECTORS_QUERY_RESPONSE,
-            payload={
-                "result": result_list,
-            },
-        )
-
-    @property
-    def results(self) -> list[VectorQueryAnswer]:
-        """Returns the results from the message payload"""
-        results = self.payload.get("result", "")
-        meta_dict = json.loads(results)
-        response_list = []
-        for meta in meta_dict:
-            response_list.append(VectorQueryAnswer.from_dict(meta))
-        return response_list
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'VectorQueryCollectionResponseMessage':
-        # Extract necessary fields from the message payload
-        payload = message.payload
-        result = payload.get("result", "")
-        result_list = json.loads(result)
-        return cls.create_message(
-           result=result_list
-        )

h_message_bus/domain/request_messages/vector_read_metadata_request_message.py

@@ -1,25 +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 VectorReadMetaDataRequestMessage(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) -> 'VectorReadMetaDataRequestMessage':
-        """Create a message requesting Twitter user data"""
-        return cls.create(
-            topic=RequestMessageTopic.VECTORS_METADATA_READ,
-            payload={},
-        )
-
-    @classmethod
-    def from_hai_message(cls) -> 'VectorReadMetaDataRequestMessage':
-        return cls.create_message()

h_message_bus/domain/request_messages/vector_read_metadata_response_message.py

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

h_message_bus/domain/request_messages/vector_save_request_message.py

@@ -1,66 +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 VectorSaveRequestMessage(HaiMessage):
-    """Message to data in vector store"""
-
-    @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, collection_name: str, collection_metadata: dict[str,str], document_id: str, content: str, metadata: dict[str,str]) -> 'VectorSaveRequestMessage':
-        """Create a message requesting Twitter user data"""
-        return cls.create(
-            topic=RequestMessageTopic.VECTORS_SAVE,
-            payload={
-                "collection_name": collection_name,
-                "collection_metadata": collection_metadata,
-                "document_id": document_id,
-                "content": content,
-                "metadata": metadata
-            },
-        )
-
-    @property
-    def collection_name(self) -> str:
-        """Get the collection name from the payload"""
-        return self.payload.get("collection_name")
-
-    @property
-    def collection_metadata(self) -> dict[str, str]:
-        """Get the collection name from the payload"""
-        return self.payload.get("collection_metadata")
-
-    @property
-    def document_id(self) -> str:
-        """Get the document ID from the payload"""
-        return self.payload.get("document_id")
-
-    @property
-    def content(self) -> str:
-        """Get the content from the payload"""
-        return self.payload.get("content")
-
-    @property
-    def metadata(self) -> dict[str, str]:
-        """Get the metadata from the payload"""
-        return self.payload.get("metadata")
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'VectorSaveRequestMessage':
-        # Extract the necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            collection_name=payload.get("collection_name", ''),
-            collection_metadata=payload.get("collection_metadata", {}),
-            document_id=payload.get("document_id", ''),
-            content=payload.get("content", ''),
-            metadata=payload.get("metadata", {})
-        )