h-ai-brain 0.0.5__py3-none-any.whl → 0.0.7__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) -> 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/domain/web_docs/ecosystem_link_scorer_service.py

@@ -0,0 +1,83 @@
+import re
+from urllib.parse import urlparse
+
+from ...domain.web_docs.ecosystem_pattern_repository import EcosystemPatternRepository
+
+
+class EcosystemLinkScorerService:
+    """Service for scoring potential ecosystem-related links and content"""
+
+    def __init__(self, pattern_repo: EcosystemPatternRepository):
+        self.pattern_repo = pattern_repo
+
+    def score(self, full_url: str, link_text: str) -> float:
+        """
+        Score a link based on how likely it is to be ecosystem-related
+        Returns a value between 0.0 and 1.0
+        """
+        score = 0.0
+        max_score = 3.0  # Maximum possible score
+
+        # Parse the URL
+        parsed_url = urlparse(full_url)
+        domain = parsed_url.netloc
+        path = parsed_url.path
+
+        # Check domain patterns
+        for eco_domain in self.pattern_repo.ecosystem_domains:
+            if eco_domain in domain:
+                score += 1.0
+                break
+
+        # Check path patterns
+        for path_pattern in self.pattern_repo.ecosystem_path_patterns:
+            if re.search(path_pattern, path):
+                score += 1.0
+                break
+
+        # Check link text patterns
+        for text_pattern in self.pattern_repo.ecosystem_text_patterns:
+            if re.search(text_pattern, link_text):
+                score += 1.0
+                break
+
+        # Normalize score to 0.0-1.0 range
+        return min(score / max_score, 1.0)
+
+    def score_page(self, page_url: str, page_title: str, page_content: str) -> float:
+        """
+        Score an entire page based on how likely it is to contain ecosystem information
+        Returns a value between 0.0 and 1.0
+
+        Args:
+            page_url: The URL of the page
+            page_title: The title of the page
+            page_content: The full text content of the page
+        """
+        # Start with the URL and title scoring
+        url_score = self.score(page_url, page_title)
+
+        # Content-based scoring
+        content_score = 0.0
+        max_content_score = 2.0
+
+        # Check content patterns
+        content_matches = 0
+        for content_pattern in self.pattern_repo.ecosystem_content_patterns:
+            if re.search(content_pattern, page_content):
+                content_matches += 1
+
+        # Score based on number of content matches
+        if content_matches >= 3:
+            content_score += 1.0
+        elif content_matches > 0:
+            content_score += 0.5
+
+        # Check for header patterns
+        for header_pattern in self.pattern_repo.ecosystem_header_patterns:
+            if re.search(header_pattern, page_content):
+                content_score += 1.0
+                break
+
+        # Combined score with higher weight on content
+        return min((url_score + (content_score / max_content_score) * 2) / 3, 1.0)

h_ai/domain/web_docs/ecosystem_pattern_repository.py

@@ -0,0 +1,182 @@
+class EcosystemPatternRepository:
+    """Repository of patterns that identify ecosystem relationships, builders, and collaboration"""
+
+    def __init__(self):
+        # Domains commonly associated with ecosystem and project showcases
+        self.ecosystem_domains = [
+            "showcase.",
+            "ecosystem.",
+            "community.",
+            "gallery.",
+            "partners.",
+            "developers.",
+            "marketplace.",
+            "expo.",
+            "apps.",
+            "extensions.",
+            "plugins.",
+        ]
+
+        # URL path patterns indicating ecosystem/builder content
+        self.ecosystem_path_patterns = [
+            r"/ecosystem/",
+            r"/showcase/",
+            r"/community/",
+            r"/built-with/",
+            r"/case-studies/",
+            r"/customers/",
+            r"/partners/",
+            r"/users/",
+            r"/success-stories/",
+            r"/integrations/",
+            r"/extensions/",
+            r"/marketplace/",
+            r"/plugins/",
+            r"/addons/",
+            r"/gallery/",
+            r"/examples/",
+            r"/projects/",
+            r"/contributors/",
+            r"/whos-using/",
+        ]
+
+        # Link text patterns suggesting ecosystem content
+        self.ecosystem_text_patterns = [
+            r"(?i)ecosystem",
+            r"(?i)showcase",
+            r"(?i)built with",
+            r"(?i)powered by",
+            r"(?i)case stud(y|ies)",
+            r"(?i)success stor(y|ies)",
+            r"(?i)who('s| is) using",
+            r"(?i)our users",
+            r"(?i)our customers",
+            r"(?i)integrations?",
+            r"(?i)extensions?",
+            r"(?i)plugins?",
+            r"(?i)addons?",
+            r"(?i)community projects",
+            r"(?i)community contributions",
+            r"(?i)user contributions",
+            r"(?i)featured projects",
+            r"(?i)gallery",
+        ]
+
+        # Header/title patterns suggesting ecosystem sections
+        self.ecosystem_header_patterns = [
+            r"(?i)ecosystem",
+            r"(?i)who('s| is) using",
+            r"(?i)built (on|with)",
+            r"(?i)powered by",
+            r"(?i)trusted by",
+            r"(?i)customer(s| success)",
+            r"(?i)case stud(y|ies)",
+            r"(?i)success stor(y|ies)",
+            r"(?i)showcase",
+            r"(?i)featured (users|customers|projects)",
+            r"(?i)community (projects|showcase)",
+            r"(?i)partner(s| program)",
+            r"(?i)(our|notable) users",
+            r"(?i)companies using",
+            r"(?i)in production",
+            r"(?i)contributor(s| showcase)",
+            r"(?i)extension (gallery|showcase)",
+            r"(?i)plugin (directory|marketplace)",
+            r"(?i)apps? (built|marketplace|gallery)",
+        ]
+
+        # Content phrases that suggest ecosystem descriptions
+        self.ecosystem_content_patterns = [
+            r"(?i)built (on|with) (our|this)",
+            r"(?i)(companies|organizations|projects) (using|powered by)",
+            r"(?i)(is|are) using (our|this)",
+            r"(?i)powered by (our|this)",
+            r"(?i)extend(s|ing)? (the|our) (platform|ecosystem)",
+            r"(?i)integrated with",
+            r"(?i)build(s|ing)? (on top of|with)",
+            r"(?i)leverage(s|ing)? (our|this)",
+            r"(?i)extend(s|ing)? (the|our) (functionality|capabilities)",
+            r"(?i)based on (our|this)",
+            r"(?i)implemented (with|using)",
+            r"(?i)developed (with|using)",
+            r"(?i)(join|be part of) (our|the) ecosystem",
+        ]
+
+        # Builder and contribution-specific patterns
+        self.builder_patterns = [
+            r"(?i)how to (build|contribute)",
+            r"(?i)build(ing)? (with|on)",
+            r"(?i)develop(ing)? (with|on)",
+            r"(?i)contribute to",
+            r"(?i)contributor guide",
+            r"(?i)developer program",
+            r"(?i)join (our|the) (ecosystem|community)",
+            r"(?i)become a (contributor|partner)",
+            r"(?i)extend (our|the) (platform|ecosystem)",
+            r"(?i)create (your own|an?) (plugin|extension|integration)",
+            r"(?i)developer (resources|portal)",
+            r"(?i)sdk",
+            r"(?i)api (access|integration)",
+            r"(?i)partner (program|portal)",
+        ]
+
+        # Visual cues that often indicate ecosystem showcases
+        self.visual_indicators = [
+            r"logo grid",
+            r"logo carousel",
+            r"client logos",
+            r"partner logos",
+            r"customer logos",
+            r"company logos",
+            r"card gallery",
+            r"project cards",
+            r"showcase gallery",
+            r"case study cards",
+            r"testimonials",
+            r"user testimonials",
+        ]
+
+        # Collaboration-specific patterns
+        self.collaboration_patterns = [
+            r"(?i)how to collaborate",
+            r"(?i)collaboration (guide|opportunities)",
+            r"(?i)working together",
+            r"(?i)partner(ship|ing) (opportunities|program)",
+            r"(?i)join (our|the) (community|ecosystem)",
+            r"(?i)community (contribution|participation)",
+            r"(?i)open (source|collaboration)",
+            r"(?i)contribute (code|documentation|resources)",
+            r"(?i)become a (partner|contributor|maintainer)",
+            r"(?i)collaboration (framework|model)",
+            r"(?i)(business|technical) partnership",
+            r"(?i)developer relations",
+            r"(?i)community (engagement|involvement)",
+        ]
+
+        # Key meta tags that might indicate ecosystem content
+        self.meta_tag_patterns = [
+            r"(?i)ecosystem",
+            r"(?i)showcase",
+            r"(?i)community",
+            r"(?i)partner program",
+            r"(?i)integration",
+            r"(?i)extension",
+            r"(?i)plugin",
+            r"(?i)marketplace",
+            r"(?i)collaboration",
+            r"(?i)use cases",
+            r"(?i)case studies",
+            r"(?i)success stories",
+        ]
+
+        # Schema.org types that often indicate ecosystem relationships
+        self.schema_types = [
+            "Product",
+            "SoftwareApplication",
+            "Organization",
+            "BusinessPartner",
+            "ProgramMembership",
+            "CreativeWork",
+            "SoftwareSourceCode",
+            "WebApplication",
+        ]

h_ai/infrastructure/playwright/playwright_web_content_fetcher.py

@@ -19,7 +19,13 @@ class PlayWrightWebContentFetcher(WebFetcherRepository):
 
     async def fetch(self, url: str) -> Optional[str]:
         async with async_playwright() as p:
-            browser = await p.chromium.launch(headless=True)
+            browser = await p.chromium.launch(headless=True, args=[
+            '--disable-dev-shm-usage',  # Required for Docker
+            '--no-sandbox',  # Required for Docker non-root user
+            '--disable-setuid-sandbox',  # Required for Docker security
+            '--disable-gpu',  # Reduces resource usage
+            ])
+
             logger.debug(
                 f"Launching headless browser with user agent: {self.headers.get('User-Agent')}"
             )

h_ai/infrastructure/priorityqueue/in_memory_priority_queue_repository.py

@@ -0,0 +1,87 @@
+
+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"""
+        queue = self._get_or_create_queue(queue_name)
+        with self._get_lock(queue_name):
+            # The queue automatically orders by priority
+            queue.put(item)
+
+    def get_highest_priority_item(self, queue_name: str) -> Optional[QueueItem]:
+        """Get and remove the highest priority item from the queue"""
+        if queue_name not in self.queues:
+            return None
+
+        queue = self.queues[queue_name]
+        with self._get_lock(queue_name):
+            if queue.empty():
+                return None
+            return queue.get()
+
+    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 []
+
+        queue = 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 queue.empty() and count < limit:
+                item = queue.get()
+                temp_items.append(item)
+                result.append(item)
+                count += 1
+
+            # Put all the items back in the same order
+            for item in temp_items:
+                queue.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
+
+        queue = self.queues[queue_name]
+        with self._get_lock(queue_name):
+            return queue.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.5.dist-info → h_ai_brain-0.0.7.dist-info}/METADATA

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

{h_ai_brain-0.0.5.dist-info → h_ai_brain-0.0.7.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=XCjBrJezloblcqOPJUStTmU5tofx954h-mzxOsYIAbg,1042
+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
@@ -14,6 +18,8 @@ h_ai/domain/reasoning/tool_message.py,sha256=jpbfbJXj6oqZyB3lDxGOUyFB4faHtXAaEOV
 h_ai/domain/web_docs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 h_ai/domain/web_docs/doc_link_scorer_service.py,sha256=EmLSOaX7BCUQcKHZquaUt-Ps_DssZrRqpch5MgbUhAc,1444
 h_ai/domain/web_docs/documentation_pattern_repository.py,sha256=VhNzP3PUqgg9MaWhBVefj13XNxRBh6ZPUt-KH70ww2w,1302
+h_ai/domain/web_docs/ecosystem_link_scorer_service.py,sha256=Slin3ZAdJ3o3CxTvJtfD-vd4R4f-MINd3PY2G3bCCQg,2899
+h_ai/domain/web_docs/ecosystem_pattern_repository.py,sha256=uHBhEvz3HmhXRvFJ6BzJddZmngPSAQw-q39TgRLJiPg,6609
 h_ai/domain/web_docs/gitbook_web_fetcher_service.py,sha256=Ye-TcuwgW1fhIY8x6v9_-pmPN9pVFWzlOpwRt-4teaA,6490
 h_ai/domain/web_docs/web_docs_link_detector.py,sha256=NyMKFNs-41bqrxx6u-9GqIufy7pkDF_-_f1h8HECBK8,1192
 h_ai/domain/web_docs/web_link.py,sha256=J4KC3MmjkvWlAPDdEdjcqAZCvuSnJMahudCohiBk3wk,307
@@ -39,10 +45,12 @@ h_ai/infrastructure/llm/ollama/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCe
 h_ai/infrastructure/llm/ollama/models/ollama_chat_message.py,sha256=ZIz4PQ3869vI3xAYYufPrxXpacajRDtOI8RDl5Dm9RQ,305
 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=fcf8ZxIR2bLU1rV378ASQUaI26PvaX7sYqQb1SDlkt4,2401
-h_ai_brain-0.0.5.dist-info/licenses/LICENSE,sha256=SbvpEU5JIU3yzMMkyzrI0dGqHDoJR_lMKGdl6GZHsy4,11558
-h_ai_brain-0.0.5.dist-info/licenses/NOTICE.txt,sha256=vxeIKUiGqAePLvDW4AVm3Xh-3BcsvMtCMn1tbsr9zsE,668
-h_ai_brain-0.0.5.dist-info/METADATA,sha256=d6J1f3gTeJaS90RwHDfPLuwPila1TzYFxbRInOqHqHM,735
-h_ai_brain-0.0.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-h_ai_brain-0.0.5.dist-info/top_level.txt,sha256=3MChDBWvDJV4cEHuZhzeODxQ4ewtw-arOuyaDOc6sIo,5
-h_ai_brain-0.0.5.dist-info/RECORD,,
+h_ai/infrastructure/playwright/playwright_web_content_fetcher.py,sha256=FVwcK6hv_6aE4fYlJapLHyxNHsztQkKaulklHabyrEc,2684
+h_ai/infrastructure/priorityqueue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+h_ai/infrastructure/priorityqueue/in_memory_priority_queue_repository.py,sha256=-DodmvFBUFnglJJmbUFEi3HpqxEdZvYrOpwZrWZrSU0,3262
+h_ai_brain-0.0.7.dist-info/licenses/LICENSE,sha256=SbvpEU5JIU3yzMMkyzrI0dGqHDoJR_lMKGdl6GZHsy4,11558
+h_ai_brain-0.0.7.dist-info/licenses/NOTICE.txt,sha256=vxeIKUiGqAePLvDW4AVm3Xh-3BcsvMtCMn1tbsr9zsE,668
+h_ai_brain-0.0.7.dist-info/METADATA,sha256=KxLN_FGexCNE_QbLb9lpyx_YWEM7-P8VO_Zoy--v1Yk,735
+h_ai_brain-0.0.7.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+h_ai_brain-0.0.7.dist-info/top_level.txt,sha256=3MChDBWvDJV4cEHuZhzeODxQ4ewtw-arOuyaDOc6sIo,5
+h_ai_brain-0.0.7.dist-info/RECORD,,

{h_ai_brain-0.0.5.dist-info → h_ai_brain-0.0.7.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