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

h_message_bus/domain/request_messages/graph_nodes_by_property_response_message.py

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

h_message_bus/domain/request_messages/graph_query_operation_request_message.py

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

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

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

h_message_bus/domain/request_messages/graph_relationship_added_request_message.py

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

h_message_bus/domain/request_messages/init_knowledgebase_request.py

@@ -1,26 +0,0 @@
-from typing import TypeVar, Dict, Any, Type
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class InitKnowledgeBaseRequestMessage(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) -> 'InitKnowledgeBaseRequestMessage':
-        """Create a message requesting to clear the graph"""
-        return cls.create(
-            topic=RequestMessageTopic.INIT_KNOWLEDGE_BASE,
-            payload={}
-        )
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'InitKnowledgeBaseRequestMessage':
-        return cls.create_message()

h_message_bus/domain/request_messages/tg_message_request_message.py

@@ -1,48 +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 TelegramMessageRequestMessage(HaiMessage):
-    """Message containing user message 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, message: str, chat_id: int) -> 'TelegramMessageRequestMessage':
-
-        payload = {
-            "message": message,
-            "chat_id": chat_id,
-        }
-
-        return cls.create(
-            topic=RequestMessageTopic.TG_CHAT_SEND,
-            payload=payload
-        )
-
-    @property
-    def message(self) -> str:
-        """Get the message content from the payload"""
-        return self.payload.get("message", "")
-
-    @property
-    def chat_id(self) -> int:
-        """Get the Telegram chat ID from the payload"""
-        return self.payload.get("chat_id", 0)
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TelegramMessageRequestMessage':
-        payload = message.payload
-
-        return cls.create_message(
-            message=payload.get("message", ""),
-            chat_id=payload.get("chat_id")
-        )
-

h_message_bus/domain/request_messages/tg_user_message_reply_request_message.py

@@ -1,56 +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 TelegramUserMessageReplyRequestMessage(HaiMessage):
-    """Message containing user message 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, message: str, chat_id: int,
-                       message_id: int) -> 'TelegramUserMessageReplyRequestMessage':
-
-        payload = {
-            "message": message,
-            "chat_id": chat_id,
-            "message_id": message_id,
-        }
-
-        return cls.create(
-            topic=RequestMessageTopic.TG_CHAT_REPLY,
-            payload=payload
-        )
-
-    @property
-    def message(self) -> str:
-        """Get the message content from the payload"""
-        return self.payload.get("message", "")
-
-    @property
-    def chat_id(self) -> int:
-        """Get the Telegram chat ID from the payload"""
-        return self.payload.get("chat_id", 0)
-
-    @property
-    def message_id(self) -> int:
-        """Get the Telegram message ID from the payload"""
-        return self.payload.get("message_id", 0)
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TelegramUserMessageReplyRequestMessage':
-        payload = message.payload
-
-        return cls.create_message(
-            message=payload.get("message", ""),
-            chat_id=payload.get("chat_id"),
-            message_id=payload.get("message_id")
-        )
-

h_message_bus/domain/request_messages/tg_user_message_request_message.py

@@ -1,93 +0,0 @@
-from typing import Type, TypeVar, Dict, Any, Optional
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-
-class TelegramUserMessageRequestMessage(HaiMessage):
-    """Message containing user message 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, message: str, user_id: str, username: str,
-                       chat_id: str,
-                       message_id: str,
-                       replied_to_text: Optional[str] = None) -> 'TelegramUserMessageRequestMessage':
-        """Create a message with user message data
-
-        Args:
-            message: The cleaned message content
-            user_id: The ID of the user
-            username: The username of the user
-            replied_to_text: The text being replied to, if any
-            chat_id: The Telegram chat ID
-            message_id: The Telegram message ID
-
-        Returns:
-            A new TelegramUserMessageRequestMessage instance
-        """
-        payload = {
-            "message": message,
-            "user_id": user_id,
-            "username": username,
-            "chat_id" : chat_id,
-            "message_id" : message_id
-        }
-
-        if replied_to_text:
-            payload["replied_to_text"] = replied_to_text
-
-        return cls.create(
-            topic=RequestMessageTopic.TG_USER_CHAT_SEND,
-            payload=payload
-        )
-
-    @property
-    def message(self) -> str:
-        """Get the message content from the payload"""
-        return self.payload.get("message", "")
-
-    @property
-    def user_id(self) -> str:
-        """Get the user ID from the payload"""
-        return self.payload.get("user_id", "")
-
-    @property
-    def username(self) -> str:
-        """Get the username from the payload"""
-        return self.payload.get("username", "")
-
-    @property
-    def replied_to_text(self) -> str:
-        """Get the replied to text from the payload"""
-        return self.payload.get("replied_to_text", "")
-
-    @property
-    def chat_id(self) -> int:
-        """Get the Telegram chat ID from the payload"""
-        return self.payload.get("chat_id", 0)
-
-    @property
-    def message_id(self) -> int:
-        """Get the Telegram message ID from the payload"""
-        return self.payload.get("message_id", 0)
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'TelegramUserMessageRequestMessage':
-        payload = message.payload
-
-        return cls.create_message(
-            message=payload.get("message", ""),
-            user_id=payload.get("user_id", ""),
-            username=payload.get("username", ""),
-            replied_to_text=payload.get("replied_to_text", ""),
-            chat_id=payload.get("chat_id"),
-            message_id=payload.get("message_id")
-        )
-

h_message_bus/domain/request_messages/twitter_follow_user_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='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", "")
-        )