h-ai-brain 0.0.6__py3-none-any.whl → 0.0.8__py3-none-any.whl

h_ai/application/hai_service.py

@@ -1,17 +1,22 @@
-import datetime
-
 from h_message_bus import NatsPublisherAdapter
-from h_message_bus.domain.twitter_get_user_request_message import TwitterGetUserRequestMessage
-from h_message_bus.domain.twitter_get_user_response_message import TwitterGetUserResponseMessage
-from h_message_bus.domain.vector_save_request_message import VectorSaveRequestMessage
-
+from h_message_bus.domain.request_messages.twitter_get_user_request_message import TwitterGetUserRequestMessage
+from h_message_bus.domain.request_messages.twitter_get_user_response_message import TwitterGetUserResponseMessage
+from h_message_bus.domain.request_messages.vector_read_metadata_request_message import VectorReadMetaDataRequestMessage
+from h_message_bus.domain.request_messages.vector_read_metadata_response_message import \
+    VectorReadMetaDataResponseMessage
+from h_message_bus.domain.request_messages.vector_save_request_message import VectorSaveRequestMessage
+
+from .priority_queue_service import PriorityQueueService
 from ..application.web_docs_service import WebDocsService
+from ..infrastructure.priorityqueue.in_memory_priority_queue_repository import InMemoryPriorityQueueRepository
 
 
 class HaiService:
     def __init__(self, nats_publisher_adapter: NatsPublisherAdapter):
         self.nats_publisher_adapter = nats_publisher_adapter
         self.web_docs_service = WebDocsService()
+        queue = InMemoryPriorityQueueRepository()
+        self.queue_service = PriorityQueueService(queue)
 
     async def detect_and_store_documentation(self, twitter_screen_name: str):
         req_message = TwitterGetUserRequestMessage.create_message(twitter_screen_name)
@@ -31,8 +36,7 @@ class HaiService:
                         document_id = f"{doc.title}_{chapter.heading}_{i}"
 
                         req_metadata = {
-                            "source": doc.url,
-                            "updated": datetime.datetime.utcnow().isoformat()
+                            "source": doc.url
                         }
                         i = i + 1
 
@@ -45,4 +49,10 @@ class HaiService:
                         await self.nats_publisher_adapter.publish(request)
 
         else:
-            print(f"No documentation found for {twitter_user.screen_name}")
+            print(f"No documentation found for {twitter_user.screen_name}")
+
+    async def load_current_knowledge_base_metadata(self):
+        message = VectorReadMetaDataRequestMessage.create_message()
+        response = await self.nats_publisher_adapter.request(message)
+        metadata_result = VectorReadMetaDataResponseMessage.from_hai_message(response)
+        print(metadata_result)

h_ai/application/priority_queue_service.py

@@ -0,0 +1,34 @@
+
+from typing import Any, List, Optional
+
+from ..domain.priorityqueue.priority_queue_repository import PriorityQueueRepository
+from ..domain.priorityqueue.queue_item import QueueItem
+
+
+class PriorityQueueService:
+    """Application service to manage priority queue operations"""
+
+    def __init__(self, repository: PriorityQueueRepository):
+        self.repository = repository
+
+    def add_item(self, queue_name: str, content: Any, priority: int, metadata: Optional[dict] = None) -> QueueItem:
+        """Add an item to the specified queue"""
+        item = QueueItem.create(content, priority, metadata)
+        self.repository.add_item(queue_name, item)
+        return item
+
+    def get_next_item(self, queue_name: str) -> Optional[QueueItem]:
+        """Get and remove the highest priority item from the queue"""
+        return self.repository.get_highest_priority_item(queue_name)
+
+    def get_items(self, queue_name: str, limit: int = 10) -> List[QueueItem]:
+        """Get multiple items from the queue in priority order without removing them"""
+        return self.repository.get_items(queue_name, limit)
+
+    def get_queue_length(self, queue_name: str) -> int:
+        """Get the number of items in the queue"""
+        return self.repository.queue_length(queue_name)
+
+    def get_available_queues(self) -> List[str]:
+        """Get a list of all available queue names"""
+        return self.repository.get_queue_names()

h_ai/domain/priorityqueue/priority_queue_repository.py

@@ -0,0 +1,34 @@
+
+from abc import ABC, abstractmethod
+from typing import List, Optional
+
+from .queue_item import QueueItem
+
+
+class PriorityQueueRepository(ABC):
+    """Repository interface for priority queue operations"""
+
+    @abstractmethod
+    def add_item(self, queue_name: str, item: QueueItem) -> None:
+        """Add an item to the specified queue"""
+        pass
+
+    @abstractmethod
+    def get_highest_priority_item(self, queue_name: str, block: bool = False, timeout: Optional[float] = None) -> Optional[QueueItem]:
+        """Get and remove the highest priority item from the queue"""
+        pass
+
+    # @abstractmethod
+    # def get_items(self, queue_name: str, limit: int = 10) -> List[QueueItem]:
+    #     """Get multiple items from the queue in priority order without removing them"""
+    #     pass
+
+    @abstractmethod
+    def queue_length(self, queue_name: str) -> int:
+        """Get the number of items in the queue"""
+        pass
+
+    @abstractmethod
+    def get_queue_names(self) -> List[str]:
+        """Get a list of all available queue names"""
+        pass

h_ai/domain/priorityqueue/queue_item.py

@@ -0,0 +1,43 @@
+
+import uuid
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+from h_message_bus import HaiMessage
+
+
+@dataclass(frozen=True)
+class QueueItem:
+    """Value object representing an item in the priority queue"""
+    id: str
+    content: HaiMessage
+    priority: int
+    created_at: datetime
+    metadata: Optional[dict] = None
+
+    @classmethod
+    def create(cls, content: HaiMessage, priority: int, metadata: Optional[dict] = None) -> "QueueItem":
+        """Factory method to create a new QueueItem"""
+        return cls(
+            id=str(uuid.uuid4()),
+            content=content,
+            priority=priority,
+            created_at=datetime.utcnow(),
+            metadata=metadata
+        )
+
+    def __lt__(self, other):
+        """Comparison method for priority queue ordering
+        - Primary sort by priority: Higher number = higher priority
+        - Secondary sort by timestamp: Earlier timestamp = higher priority (FIFO)
+        """
+        if not isinstance(other, QueueItem):
+            return NotImplemented
+
+        # First, compare by priority (higher priority value comes first)
+        if self.priority != other.priority:
+            return self.priority > other.priority
+
+        # If priorities are equal, compare by timestamp (older timestamp comes first)
+        return self.created_at < other.created_at

h_ai/infrastructure/priorityqueue/in_memory_priority_queue_repository.py

@@ -0,0 +1,98 @@
+import queue
+import threading
+from queue import PriorityQueue
+from typing import Dict, List, Optional
+
+from ...domain.priorityqueue.priority_queue_repository import PriorityQueueRepository
+from ...domain.priorityqueue.queue_item import QueueItem
+
+
+class InMemoryPriorityQueueRepository(PriorityQueueRepository):
+    """In-memory implementation of the PriorityQueueRepository using Python's PriorityQueue"""
+
+    def __init__(self):
+        # Dictionary mapping queue names to their PriorityQueue instances
+        self.queues: Dict[str, PriorityQueue] = {}
+        # Locks to ensure thread safety
+        self.locks: Dict[str, threading.Lock] = {}
+
+    def _get_or_create_queue(self, queue_name: str, maxsize: int = 10000) -> PriorityQueue:
+        """Get or create a queue with the given name"""
+        if queue_name not in self.queues:
+            self.queues[queue_name] = PriorityQueue(maxsize=maxsize)
+            self.locks[queue_name] = threading.Lock()
+        return self.queues[queue_name]
+
+    def _get_lock(self, queue_name: str) -> threading.Lock:
+        """Get the lock for the specified queue"""
+        if queue_name not in self.locks:
+            self.locks[queue_name] = threading.Lock()
+        return self.locks[queue_name]
+
+    def add_item(self, queue_name: str, item: QueueItem) -> None:
+        """Add an item to the specified queue"""
+        q = self._get_or_create_queue(queue_name)
+        with self._get_lock(queue_name):
+            # The queue automatically orders by priority
+            q.put(item)
+
+    def get_highest_priority_item(self, queue_name: str, block: bool = False, timeout: Optional[float] = None) -> Optional[QueueItem]:
+        """Get and remove the highest priority item from the queue"""
+        if queue_name not in self.queues:
+            return None
+
+        q = self.queues[queue_name]
+        try:
+            # We need to acquire the lock to check initially, but then we need to release it
+            # so that other threads can add items while we're blocking
+            with self._get_lock(queue_name):
+                # If not blocking and queue is empty, return immediately
+                if not block and q.empty():
+                    return None
+
+            # Note: queue.get() with block=True will internally manage locking
+            # We don't hold our custom lock during the blocking wait
+            return q.get(block=block, timeout=timeout)
+        except queue.Empty:
+            # This will be raised if timeout occurs with no items
+            return None
+
+
+    def get_items(self, queue_name: str, limit: int = 10) -> List[QueueItem]:
+         """Get multiple items from the queue in priority order without removing them"""
+         if queue_name not in self.queues:
+             return []
+
+         q = self.queues[queue_name]
+         result = []
+
+         with self._get_lock(queue_name):
+             # Create a temporary list to hold items that we'll put back
+             temp_items = []
+
+             # Get up to 'limit' items
+             count = 0
+             while not q.empty() and count < limit:
+                 item = q.get()
+                 temp_items.append(item)
+                 result.append(item)
+                 count += 1
+
+             # Put all the items back in the same order
+             for item in temp_items:
+                 q.put(item)
+
+         return result
+
+    def queue_length(self, queue_name: str) -> int:
+        """Get the number of items in the queue"""
+        if queue_name not in self.queues:
+            return 0
+
+        q = self.queues[queue_name]
+        with self._get_lock(queue_name):
+            return q.qsize()
+
+    def get_queue_names(self) -> List[str]:
+        """Get a list of all available queue names"""
+        return list(self.queues.keys())

{h_ai_brain-0.0.6.dist-info → h_ai_brain-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: h_ai_brain
-Version: 0.0.6
+Version: 0.0.8
 Summary: AI Research agent API
 Author-email: shoebill <shoebill.hai@gmail.com>
 Classifier: Programming Language :: Python :: 3

{h_ai_brain-0.0.6.dist-info → h_ai_brain-0.0.8.dist-info}/RECORD

@@ -1,10 +1,14 @@
 h_ai/__init__.py,sha256=bmHMDoui52Q73UvXdHslQ3w_LubmhRuKRlrjOYyCP8c,153
 h_ai/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-h_ai/application/hai_service.py,sha256=DpSx1_QYS_3N5OwY5U4My0WwH-e4tvRHNeJxSduGoZM,2200
+h_ai/application/hai_service.py,sha256=ZSbDLP8oCBliLpbhpKOf7Xv6cWDsLCSeDeurn207FsA,3005
+h_ai/application/priority_queue_service.py,sha256=qi1PZMLYxy3HzG6cu-2hLijUYGcYGYMpzAp4S0vl0I0,1462
 h_ai/application/web_docs_service.py,sha256=YiPBfPyjlloDq6CIOP0u7F1jNBK-elYRU8xl4qJ1oVc,1652
 h_ai/application/system_prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 h_ai/application/system_prompts/roles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 h_ai/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_ai/domain/priorityqueue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_ai/domain/priorityqueue/priority_queue_repository.py,sha256=_px-WFlsj439EKV1qN-z85rQDeybhs2p-xGEXRpOtHE,1104
+h_ai/domain/priorityqueue/queue_item.py,sha256=aP2Sd3ig9dgKnAsKE_rr3uRjJ_ClWIrvz0Y3nC8XbmE,1417
 h_ai/domain/reasoning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 h_ai/domain/reasoning/llm_chat_repository.py,sha256=rY2izDyaDnoyyrCRS1qc9erHB98vARj4Mp-SnPwNhyY,211
 h_ai/domain/reasoning/llm_generate_respository.py,sha256=DPiV6ldCE8YhDdVb5rj98MBudKalDQHV3CZ2ADTm_f8,178
@@ -42,9 +46,11 @@ h_ai/infrastructure/llm/ollama/models/ollama_chat_message.py,sha256=ZIz4PQ3869vI
 h_ai/infrastructure/llm/ollama/models/ollama_chat_session.py,sha256=GZ_ddpbWa8iy6NZq50vokUFVZBiX0WNa81z9-r9RzTY,392
 h_ai/infrastructure/playwright/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 h_ai/infrastructure/playwright/playwright_web_content_fetcher.py,sha256=FVwcK6hv_6aE4fYlJapLHyxNHsztQkKaulklHabyrEc,2684
-h_ai_brain-0.0.6.dist-info/licenses/LICENSE,sha256=SbvpEU5JIU3yzMMkyzrI0dGqHDoJR_lMKGdl6GZHsy4,11558
-h_ai_brain-0.0.6.dist-info/licenses/NOTICE.txt,sha256=vxeIKUiGqAePLvDW4AVm3Xh-3BcsvMtCMn1tbsr9zsE,668
-h_ai_brain-0.0.6.dist-info/METADATA,sha256=taZvGg8xXlBSu13t5DKFWXBPybB8k6Zi0Izjk3qpLv8,735
-h_ai_brain-0.0.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-h_ai_brain-0.0.6.dist-info/top_level.txt,sha256=3MChDBWvDJV4cEHuZhzeODxQ4ewtw-arOuyaDOc6sIo,5
-h_ai_brain-0.0.6.dist-info/RECORD,,
+h_ai/infrastructure/priorityqueue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_ai/infrastructure/priorityqueue/in_memory_priority_queue_repository.py,sha256=zxnrbzoLfiKQMB28dI1bPe0qUtvIDG8OEFcTQL_UeFg,3886
+h_ai_brain-0.0.8.dist-info/licenses/LICENSE,sha256=SbvpEU5JIU3yzMMkyzrI0dGqHDoJR_lMKGdl6GZHsy4,11558
+h_ai_brain-0.0.8.dist-info/licenses/NOTICE.txt,sha256=vxeIKUiGqAePLvDW4AVm3Xh-3BcsvMtCMn1tbsr9zsE,668
+h_ai_brain-0.0.8.dist-info/METADATA,sha256=tO3CbkRDXPuG4cTEIPA8sOtgyXqEMk7ew-KBTA0NGUA,735
+h_ai_brain-0.0.8.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+h_ai_brain-0.0.8.dist-info/top_level.txt,sha256=3MChDBWvDJV4cEHuZhzeODxQ4ewtw-arOuyaDOc6sIo,5
+h_ai_brain-0.0.8.dist-info/RECORD,,

{h_ai_brain-0.0.6.dist-info → h_ai_brain-0.0.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any