quantalogic 0.35.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

quantalogic/tools/product_hunt/services.py

@@ -0,0 +1,63 @@
+"""Product Hunt API services.
+
+This module provides service functions for interacting with the Product Hunt GraphQL API.
+"""
+
+import os
+from typing import Any, Dict
+
+import requests
+from loguru import logger
+
+
+class ProductHuntService:
+    """Service class for Product Hunt API interactions."""
+    
+    def __init__(self):
+        """Initialize the Product Hunt API service."""
+        self.api_key = os.getenv("PRODUCT_HUNT_API_KEY")
+        self.api_secret = os.getenv("PRODUCT_HUNT_API_SECRET")
+        self.bearer_token = os.getenv("PRODUCT_HUNT_BEARER_TOKEN")
+        self.base_url = "https://api.producthunt.com/v2/api/graphql"
+        
+        if not self.bearer_token:
+            raise ValueError("PRODUCT_HUNT_BEARER_TOKEN environment variable is required")
+
+    def execute_query(self, query: str, variables: Dict[str, Any] | None = None) -> Dict[str, Any]:
+        """Execute a GraphQL query against the Product Hunt API.
+        
+        Args:
+            query: The GraphQL query string
+            variables: Optional variables for the GraphQL query
+            
+        Returns:
+            The API response data
+            
+        Raises:
+            RuntimeError: If the API request fails
+        """
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.bearer_token}",
+            "X-Product-Hunt-Api-Key": self.api_key,
+            "User-Agent": "QuantaLogic/1.0"
+        }
+        try:
+            response = requests.post(
+                self.base_url,
+                json={"query": query, "variables": variables or {}},
+                headers=headers
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                if "errors" in data:
+                    raise RuntimeError(f"GraphQL query failed: {data['errors']}")
+                return data
+            else:
+                raise RuntimeError(f"API request failed with status {response.status_code}: {response.text}")
+                
+        except Exception as e:
+            logger.error(f"Failed to execute Product Hunt API query: {str(e)}")
+            raise RuntimeError(f"Failed to execute Product Hunt API query: {str(e)}")

quantalogic/tools/rag_tool/__init__.py

@@ -0,0 +1,48 @@
+"""RAG Tool and related components."""
+
+import importlib
+import sys
+from typing import Any
+
+
+class LazyLoader:
+    """
+    Lazily import a module only when its attributes are accessed.
+    This helps reduce startup time by deferring imports until needed.
+    """
+    def __init__(self, module_path: str):
+        self.module_path = module_path
+        self._module = None
+
+    def __getattr__(self, name: str) -> Any:
+        if self._module is None:
+            self._module = importlib.import_module(self.module_path)
+        return getattr(self._module, name)
+
+
+# Map of class names to their import paths
+_IMPORTS = {
+    "DocumentMetadata": ".document_metadata",
+    "QueryResponse": ".query_response",
+    "RagTool": ".rag_tool"
+}
+
+# Create lazy loaders for each module
+_lazy_modules = {}
+for cls_name, path in _IMPORTS.items():
+    full_path = f"{__package__}{path}"
+    if (full_path not in _lazy_modules):
+        _lazy_modules[full_path] = LazyLoader(full_path)
+
+# Map each class to its lazy module
+_class_to_lazy_module = {}
+for cls_name, path in _IMPORTS.items():
+    full_path = f"{__package__}{path}"
+    _class_to_lazy_module[cls_name] = _lazy_modules[full_path]
+
+# Define __all__ so that import * works properly
+__all__ = list(_IMPORTS.keys())
+
+# Set up lazy loading for each class
+for cls_name, lazy_module in _class_to_lazy_module.items():
+    setattr(sys.modules[__name__], cls_name, getattr(lazy_module, cls_name))

quantalogic/tools/rag_tool/document_metadata.py

@@ -0,0 +1,15 @@
+from datetime import datetime
+from typing import Any, Dict
+
+from pydantic import BaseModel, Field
+
+
+class DocumentMetadata(BaseModel):
+    """Metadata for indexed documents."""
+    source_path: str
+    file_type: str
+    creation_date: datetime
+    last_modified: datetime
+    chunk_size: int
+    overlap: int
+    custom_metadata: Dict[str, Any] = Field(default_factory=dict)

quantalogic/tools/rag_tool/query_response.py

@@ -0,0 +1,20 @@
+from typing import Any, Dict, List
+
+from pydantic import BaseModel
+
+
+class QueryResponse(BaseModel):
+    """Structured query response with source attribution."""
+    answer: str
+    sources: List[Dict[str, Any]]
+    relevance_scores: List[float]
+    total_chunks_searched: int
+    query_time_ms: float
+
+    def __len__(self) -> int:
+        """Support len() operation by returning length of the answer."""
+        return len(self.answer)
+
+    def __str__(self) -> str:
+        """String representation of the response."""
+        return self.answer