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

h_message_bus/domain/request_messages/graph_clear_request_message.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 GraphClearRequestMessage(HaiMessage):
-    """Message to clear all nodes and relationships from 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) -> 'GraphClearRequestMessage':
-        """Create a message requesting to clear the graph"""
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_CLEAR,
-            payload={}
-        )
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphClearRequestMessage':
-        return cls.create_message()

h_message_bus/domain/request_messages/graph_get_all_request_message.py

@@ -1,27 +0,0 @@
-
-from typing import TypeVar, Dict, Any, Type, List
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class GraphGetAllRequestMessage(HaiMessage):
-    """Message to get all nodes and relationships from 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) -> 'GraphGetAllRequestMessage':
-        """Create a message requesting to get all nodes and relationships"""
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_GET_ALL,
-            payload={}
-        )
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphGetAllRequestMessage':
-        return cls.create_message()

h_message_bus/domain/request_messages/graph_get_all_result_response_message.py

@@ -1,45 +0,0 @@
-from typing import TypeVar, Dict, Any, Type, List
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class GraphGetAllResultResponseMessage(HaiMessage):
-    """Message containing all nodes and relationships from 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, nodes: List[Dict], relationships: List[Dict]) -> 'GraphGetAllResultResponseMessage':
-        """Create a message with all nodes and relationships"""
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_GET_ALL_RESPONSE,
-            payload={
-                "nodes": nodes,
-                "relationships": relationships
-            },
-        )
-
-    @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", [])
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphGetAllResultResponseMessage':
-        # Extract the necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            nodes=payload.get("nodes", []),
-            relationships=payload.get("relationships", [])
-        )

h_message_bus/domain/request_messages/graph_node_add_request_message.py

@@ -1,64 +0,0 @@
-from typing import TypeVar, Dict, Any, Type, Optional
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-
-class GraphNodeAddRequestMessage(HaiMessage):
-    """Message to add a node to 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, node_id: str, label: str, properties: dict = None,
-                       description: str = None) -> 'GraphNodeAddRequestMessage':
-        """Create a message requesting to add a node to the graph"""
-        if properties is None:
-            properties = {}
-
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_NODE_ADD,
-            payload={
-                "node_id": node_id,
-                "label": label,
-                "properties": properties,
-                "description": description
-            },
-        )
-
-    @property
-    def node_id(self) -> str:
-        """Get the node ID from the payload"""
-        return self.payload.get("node_id")
-
-    @property
-    def label(self) -> str:
-        """Get the label from the payload"""
-        return self.payload.get("label")
-
-    @property
-    def properties(self) -> dict:
-        """Get the properties from the payload"""
-        return self.payload.get("properties", {})
-
-    @property
-    def description(self) -> Optional[str]:
-        """Get the description from the payload"""
-        return self.payload.get("description")
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeAddRequestMessage':
-        # Extract the necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            node_id=payload.get("node_id", ''),
-            label=payload.get("label", ''),
-            properties=payload.get("properties", {}),
-            description=payload.get("description")
-        )

h_message_bus/domain/request_messages/graph_node_added_response_message.py

@@ -1,69 +0,0 @@
-from typing import TypeVar, Dict, Any, Type, Optional
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class GraphNodeAddedResponseMessage(HaiMessage):
-    """Message indicating a node was successfully added to 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, node_id: str, label: str, properties: dict = None,
-                       description: str = None) -> 'GraphNodeAddedResponseMessage':
-        """Create a message confirming a node was added"""
-        if properties is None:
-            properties = {}
-
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_NODE_ADD_RESPONSE,
-            payload={
-                "node_id": node_id,
-                "label": label,
-                "properties": properties,
-                "description": description,
-                "success": True
-            },
-        )
-
-    @property
-    def node_id(self) -> str:
-        """Get the node ID from the payload"""
-        return self.payload.get("node_id")
-
-    @property
-    def label(self) -> str:
-        """Get the label from the payload"""
-        return self.payload.get("label")
-
-    @property
-    def properties(self) -> dict:
-        """Get the properties from the payload"""
-        return self.payload.get("properties", {})
-
-    @property
-    def description(self) -> Optional[str]:
-        """Get the description from the payload"""
-        return self.payload.get("description")
-
-    @property
-    def success(self) -> bool:
-        """Check if the operation was successful"""
-        return self.payload.get("success", False)
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeAddedResponseMessage':
-        # Extract the necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            node_id=payload.get("node_id", ''),
-            label=payload.get("label", ''),
-            properties=payload.get("properties", {}),
-            description=payload.get("description")
-        )

h_message_bus/domain/request_messages/graph_node_get_request_message.py

@@ -1,39 +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 GraphNodeGetRequestMessage(HaiMessage):
-    """Message to get a node from the graph by 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, node_id: str) -> 'GraphNodeGetRequestMessage':
-        """Create a message requesting to get a node from the graph"""
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_NODE_GET,
-            payload={
-                "node_id": node_id
-            },
-        )
-
-    @property
-    def node_id(self) -> str:
-        """Get the node ID from the payload"""
-        return self.payload.get("node_id")
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeGetRequestMessage':
-        # Extract the necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            node_id=payload.get("node_id", '')
-        )

h_message_bus/domain/request_messages/graph_node_get_result_response_message.py

@@ -1,70 +0,0 @@
-from typing import TypeVar, Dict, Any, Type, Optional
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class GraphNodeGetResultResponseMessage(HaiMessage):
-    """Message containing a requested node from 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, node_id: str, label: str, properties: dict = None,
-                       description: str = None, found: bool = True) -> 'GraphNodeGetResultResponseMessage':
-        """Create a message with the requested node information"""
-        if properties is None:
-            properties = {}
-
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_NODE_GET_RESPONSE,
-            payload={
-                "node_id": node_id,
-                "label": label,
-                "properties": properties,
-                "description": description,
-                "found": found
-            },
-        )
-
-    @property
-    def node_id(self) -> str:
-        """Get the node ID from the payload"""
-        return self.payload.get("node_id")
-
-    @property
-    def label(self) -> str:
-        """Get the label from the payload"""
-        return self.payload.get("label")
-
-    @property
-    def properties(self) -> dict:
-        """Get the properties from the payload"""
-        return self.payload.get("properties", {})
-
-    @property
-    def description(self) -> Optional[str]:
-        """Get the description from the payload"""
-        return self.payload.get("description")
-
-    @property
-    def found(self) -> bool:
-        """Check if the node was found"""
-        return self.payload.get("found", False)
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeGetResultResponseMessage':
-        # Extract the necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            node_id=payload.get("node_id", ''),
-            label=payload.get("label", ''),
-            properties=payload.get("properties", {}),
-            description=payload.get("description"),
-            found=payload.get("found", False)
-        )

h_message_bus/domain/request_messages/graph_node_update_request_message.py

@@ -1,56 +0,0 @@
-from typing import TypeVar, Dict, Any, Type, Optional
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class GraphNodeUpdateRequestMessage(HaiMessage):
-    """Message to update an existing node 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, node_id: str, properties: dict = None,
-                       description: str = None) -> 'GraphNodeUpdateRequestMessage':
-        """Create a message requesting to update a node in the graph"""
-        if properties is None:
-            properties = {}
-
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_NODE_UPDATE,
-            payload={
-                "node_id": node_id,
-                "properties": properties,
-                "description": description
-            },
-        )
-
-    @property
-    def node_id(self) -> str:
-        """Get the node ID from the payload"""
-        return self.payload.get("node_id")
-
-    @property
-    def properties(self) -> dict:
-        """Get the properties from the payload"""
-        return self.payload.get("properties", {})
-
-    @property
-    def description(self) -> Optional[str]:
-        """Get the description from the payload"""
-        return self.payload.get("description")
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeUpdateRequestMessage':
-        # Extract the necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            node_id=payload.get("node_id", ''),
-            properties=payload.get("properties", {}),
-            description=payload.get("description")
-        )

h_message_bus/domain/request_messages/graph_node_update_response_message.py

@@ -1,69 +0,0 @@
-from typing import TypeVar, Dict, Any, Type, Optional
-
-from ..models.request_message_topic import RequestMessageTopic
-from ...domain.models.hai_message import HaiMessage
-
-T = TypeVar('T', bound='HaiMessage')
-
-class GraphNodeUpdateResponseMessage(HaiMessage):
-    """Message indicating a node was successfully added to 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, node_id: str, label: str, properties: dict = None,
-                       description: str = None, success: bool = True) -> 'GraphNodeUpdateResponseMessage':
-        """Create a message confirming a node was added"""
-        if properties is None:
-            properties = {}
-
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_NODE_UPDATE_RESPONSE,
-            payload={
-                "node_id": node_id,
-                "label": label,
-                "properties": properties,
-                "description": description,
-                "success": success
-            },
-        )
-
-    @property
-    def node_id(self) -> str:
-        """Get the node ID from the payload"""
-        return self.payload.get("node_id")
-
-    @property
-    def label(self) -> str:
-        """Get the label from the payload"""
-        return self.payload.get("label")
-
-    @property
-    def properties(self) -> dict:
-        """Get the properties from the payload"""
-        return self.payload.get("properties", {})
-
-    @property
-    def description(self) -> Optional[str]:
-        """Get the description from the payload"""
-        return self.payload.get("description")
-
-    @property
-    def success(self) -> bool:
-        """Check if the operation was successful"""
-        return self.payload.get("success", False)
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodeUpdateResponseMessage':
-        # Extract the necessary fields from the message payload
-        payload = message.payload
-
-        return cls.create_message(
-            node_id=payload.get("node_id", ''),
-            label=payload.get("label", ''),
-            properties=payload.get("properties", {}),
-            description=payload.get("description")
-        )

h_message_bus/domain/request_messages/graph_nodes_by_property_request_message.py

@@ -1,45 +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 GraphNodesByPropertyRequestMessage(HaiMessage):
-    """Message to get 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) -> 'GraphNodesByPropertyRequestMessage':
-        """Create a message requesting nodes with a specific property value"""
-        return cls.create(
-            topic=RequestMessageTopic.GRAPH_NODES_BY_PROPERTY,
-            payload={
-                "property_name": property_name,
-                "property_value": property_value
-            },
-        )
-
-    @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")
-
-    @classmethod
-    def from_hai_message(cls, message: HaiMessage) -> 'GraphNodesByPropertyRequestMessage':
-        # 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")
-        )

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)
-        )