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

h_message_bus/domain/models/twitter_user_metadata.py

@@ -1,76 +0,0 @@
-class TwitterUserMetadata:
-    def __init__(self,
-                 id: str,
-                 screen_name: str,
-                 user_name: str = None,
-                 description: str = None,
-                 followers_count: int = 0,
-                 like_count: int = 0,
-                 is_verified: bool = False,
-                 url: str = None,
-                 bio_urls: list = None):
-        """
-        Initialize a TwitterUserMetadata instance.
-
-        Args:
-            id (str): The user's Twitter ID
-            screen_name (str): The user's screen name
-            user_name (str, optional): The user's name
-            description (str, optional): The user's bio description
-            followers_count (int, optional): Number of followers
-            like_count (int, optional): Number of likes
-            is_verified (bool, optional): Whether the user is verified
-            url (str, optional): The user's profile URL
-            bio_urls (list, optional): URLs mentioned in the user's bio
-        """
-        self.id = id
-        self.screen_name = screen_name
-        self.user_name = user_name
-        self.description = description
-        self.followers_count = followers_count
-        self.like_count = like_count
-        self.is_verified = is_verified
-        self.url = url
-        self.bio_urls = bio_urls or []
-
-    def to_dict(self) -> dict:
-        """
-        Convert TwitterUserMetadata instance to a dictionary.
-
-        Returns:
-            dict: A dictionary representation of the TwitterUserMetadata instance.
-        """
-        return {
-            'id': self.id,
-            'screen_name': self.screen_name,
-            'user_name': self.user_name,
-            'description': self.description,
-            'followers_count': self.followers_count,
-            'like_count': self.like_count,
-            'is_verified': self.is_verified,
-            'url': self.url,
-            'bio_urls': self.bio_urls
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'TwitterUserMetadata':
-        """
-        Create a TwitterUserMetadata instance from a dictionary.
-
-        Args:
-            data (dict): A dictionary containing TwitterUserMetadata attributes
-
-        Returns:
-            TwitterUserMetadata: A new TwitterUserMetadata instance
-        """
-        return cls(
-            id=data.get('id'),
-            screen_name=data.get('screen_name'),
-            user_name=data.get('user_name'),
-            description=data.get('description'),
-            followers_count=data.get('followers_count', 0),
-            like_count=data.get('like_count', 0),
-            is_verified=data.get('is_verified', False),
-            url=data.get('url'),
-            bio_urls=data.get('bio_urls', [])
-        )

h_message_bus/domain/models/vector_collection_metadata.py

@@ -1,30 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class VectorCollectionMetadata:
-    collection_name: str
-    last_updated: str
-    last_queried: str
-    query_count: int = 0
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'VectorCollectionMetadata':
-        """Create an instance from a dictionary."""
-        return cls(
-            collection_name=data.get('collection_name', ''),
-            last_updated=data.get('last_updated', ''),
-            last_queried=data.get('last_queried', ''),
-            query_count=data.get('query_count', 0)
-        )
-
-    def to_dict(self) -> dict:
-        """Convert instance to a dictionary."""
-        return {
-            'collection_name': self.collection_name,
-            'last_updated': self.last_updated,
-            'last_queried': self.last_queried,
-            'query_count': self.query_count
-        }
-
-

h_message_bus/domain/models/vector_query_answer.py

@@ -1,22 +0,0 @@
-from dataclasses import dataclass
-
-
-@dataclass
-class VectorQueryAnswer:
-    text: str
-    dimension: str
-
-    @classmethod
-    def from_dict(cls, data: dict) -> 'VectorQueryAnswer':
-        """Create an instance from a dictionary."""
-        return cls(
-            text=data.get('text', ''),
-            dimension=data.get('dimension', ''),
-        )
-
-    def to_dict(self) -> dict:
-        """Convert instance to a dictionary."""
-        return {
-            'text': self.text,
-            'dimension': self.dimension,
-        }

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