ipulse-shared-core-ftredge 13.0.1__tar.gz → 14.0.1__tar.gz

{ipulse_shared_core_ftredge-13.0.1/src/ipulse_shared_core_ftredge.egg-info → ipulse_shared_core_ftredge-14.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 13.0.1
+Version: 14.0.1
 Summary: Shared Core models and Logger util for the Pulse platform project. Using AI for financial advisory and investment management.
 Home-page: https://github.com/TheFutureEdge/ipulse_shared_core
 Author: Russlan Ramdowar

{ipulse_shared_core_ftredge-13.0.1 → ipulse_shared_core_ftredge-14.0.1}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='ipulse_shared_core_ftredge',
-    version='13.0.1',
+    version='14.0.1',
     package_dir={'': 'src'},  # Specify the source directory
     packages=find_packages(where='src'),  # Look for packages in 'src'
     install_requires=[

{ipulse_shared_core_ftredge-13.0.1 → ipulse_shared_core_ftredge-14.0.1}/src/ipulse_shared_core_ftredge/__init__.py

@@ -2,7 +2,7 @@
 from .models import ( UserAuth, UserProfile,Subscription,
                      UserStatus, IAMUnitRefAssignment, UserProfileUpdate,
                      OrganizationProfile, BaseAPIResponse,
-                      CustomJSONResponse )
+                      CustomJSONResponse, BaseDataModel )
 
 
 

ipulse_shared_core_ftredge-14.0.1/src/ipulse_shared_core_ftredge/cache/shared_cache.py

@@ -0,0 +1,312 @@
+"""Module for shared caching functionality that can be used across microservices."""
+import os
+import time
+import logging
+import traceback
+import inspect
+import asyncio
+import threading
+from typing import Dict, Any, Optional, TypeVar, Generic, Callable, Tuple, List, Awaitable
+
+T = TypeVar('T')
+
+class SharedCache(Generic[T]):
+    """
+    Generic shared cache implementation that can be used across services.
+
+    Attributes:
+        name: The name of the cache for logging and identification.
+        ttl: Time-to-live in seconds for cached items.
+        enabled: Whether the cache is enabled.
+        logger: Logger for cache operations.
+        _cache: Dictionary holding cached values.
+        _timestamps: Dictionary holding timestamps for each cached item.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        ttl: float,
+        enabled: bool = True,
+        logger: Optional[logging.Logger] = None
+    ):
+        """Initialize the cache with name, TTL and enabled state."""
+        self.name = name
+        self.ttl = ttl
+        self.enabled = enabled
+        self.logger = logger or logging.getLogger(__name__)
+        self._cache: Dict[str, T] = {}
+        self._timestamps: Dict[str, float] = {}
+
+        # Thread-safe attributes
+        self.lock = threading.Lock()
+        self.hits = 0
+        self.misses = 0
+        self.sets = 0
+        self.evictions = 0
+
+        self.logger.info(f"{name} cache initialized. Enabled: {enabled}, TTL: {ttl} seconds")
+
+    def get(self, key: str) -> Optional[T]:
+        """
+        Get a value from the cache if it exists and hasn't expired.
+
+        Args:
+            key: The cache key to retrieve.
+
+        Returns:
+            The cached value if found and valid, None otherwise.
+        """
+        if not self.enabled:
+            return None
+
+        with self.lock:
+            try:
+                if key in self._cache:
+                    timestamp = self._timestamps.get(key, 0)
+                    if time.time() - timestamp < self.ttl:
+                        self.hits += 1
+                        self.logger.debug(f"Cache hit for {key} in {self.name}")
+                        return self._cache[key]
+                    else:
+                        # Expired item, remove it
+                        self.invalidate(key)
+                        self.logger.debug(f"Cache expired for {key} in {self.name}")
+                else:
+                    self.misses += 1
+            except Exception as e:
+                self.logger.error(f"Error getting item from {self.name} cache with key {key}: {str(e)}")
+                self.logger.error(traceback.format_exc())
+
+            return None
+
+    def set(self, key: str, value: T) -> None:
+        """
+        Set a value in the cache.
+
+        Args:
+            key: The cache key to set.
+            value: The value to cache.
+        """
+        if not self.enabled:
+            return
+
+        with self.lock:
+            try:
+                if len(self._cache) >= 1000 and key not in self._cache:
+                    # Basic LRU-like eviction: remove the first item found (not true LRU)
+                    try:
+                        oldest_key = next(iter(self._cache))
+                        self.invalidate(oldest_key)
+                        self.evictions += 1
+                    except StopIteration:
+                        # Cache was empty, which shouldn't happen if len >= max_size > 0
+                        pass # Or log an error
+
+                self._cache[key] = value
+                self._timestamps[key] = time.time()
+                self.sets += 1
+                self.logger.debug(f"Cached item {key} in {self.name}")
+            except Exception as e:
+                self.logger.error(f"Error setting item in {self.name} cache with key {key}: {str(e)}")
+                self.logger.error(traceback.format_exc())
+
+    def invalidate(self, key: str) -> None:
+        """
+        Remove a specific key from the cache.
+
+        Args:
+            key: The cache key to invalidate.
+        """
+        with self.lock:
+            try:
+                self._cache.pop(key, None)
+                self._timestamps.pop(key, None)
+                self.evictions += 1
+                self.logger.debug(f"Invalidated cache for {key} in {self.name}")
+            except Exception as e:
+                self.logger.error(f"Error invalidating cache in {self.name} for key {key}: {str(e)}")
+                self.logger.error(traceback.format_exc())
+
+    def invalidate_all(self) -> None:
+        """Clear all cached items."""
+        with self.lock:
+            try:
+                cache_size = len(self._cache)
+                self._cache.clear()
+                self._timestamps.clear()
+                self.evictions += cache_size
+                self.logger.info(f"Invalidated all {cache_size} entries in {self.name} cache")
+            except Exception as e:
+                self.logger.error(f"Error invalidating all cache entries in {self.name}: {str(e)}")
+                self.logger.error(traceback.format_exc())
+
+    def get_or_set(
+        self,
+        key: str,
+        data_loader: Callable[[], T]
+    ) -> Tuple[T, bool]:
+        """
+        Get a value from cache or set it using the data_loader if missing or expired.
+
+        Args:
+            key: The cache key.
+            data_loader: Function to load data if not in cache.
+
+        Returns:
+            Tuple of (data, was_cached) where was_cached indicates if from cache.
+        """
+        try:
+            cached_data = self.get(key)
+            if cached_data is not None:
+                return cached_data, True
+
+            # Not in cache or expired, load the data
+            self.logger.debug(f"Cache miss for {key} in {self.name}, loading data...")
+
+            # Check if the data_loader is a coroutine function
+            if inspect.iscoroutinefunction(data_loader):
+                self.logger.error(
+                    f"Error in get_or_set for {key} in {self.name}: "
+                    f"data_loader is a coroutine function which is not supported. "
+                    f"Use a regular function that returns a value, not a coroutine."
+                )
+                # Fall back to running the coroutine in the event loop if possible
+                try:
+                    loop = asyncio.get_event_loop()
+                    fresh_data = loop.run_until_complete(data_loader())
+                except Exception as coro_err:
+                    self.logger.error(f"Failed to execute coroutine data_loader: {str(coro_err)}")
+                    raise RuntimeError(f"Cannot use coroutine data_loader in cache: {str(coro_err)}")
+            else:
+                # Regular function, just call it
+                fresh_data = data_loader()
+
+            if fresh_data is not None:  # Only cache if we got valid data
+                self.set(key, fresh_data)
+
+            if fresh_data is None:
+                raise ValueError(f"Data loader returned None for key {key} in {self.name}")
+            return fresh_data, False
+        except Exception as e:
+            self.logger.error(f"Error in get_or_set for {key} in {self.name}: {str(e)}")
+            self.logger.error(traceback.format_exc())
+
+            # Since this is a critical function, re-raise the exception
+            # after logging it, but add context about the cache
+            raise RuntimeError(f"Cache error in {self.name} for key {key}: {str(e)}") from e
+
+    async def async_get_or_set(
+        self,
+        key: str,
+        async_data_loader: Callable[[], Awaitable[T]]
+    ) -> Tuple[T, bool]:
+        """
+        Async version of get_or_set for use with async data loaders.
+
+        Args:
+            key: The cache key.
+            async_data_loader: Async function to load data if not in cache.
+
+        Returns:
+            Tuple of (data, was_cached) where was_cached indicates if from cache.
+        """
+        if not self.enabled:
+            self.logger.debug(f"Cache {self.name} is disabled. Loading data directly for key {key}.")
+            try:
+                fresh_data = await async_data_loader()
+                if fresh_data is None:
+                    self.logger.error(f"Async data loader returned None for key {key} in disabled cache {self.name}")
+                    raise ValueError(f"Async data loader returned None for key {key} in {self.name} (cache disabled)")
+                return fresh_data, False
+            except Exception as e:
+                self.logger.error(f"Error in async_data_loader for key {key} in disabled cache {self.name}: {str(e)}")
+                self.logger.error(traceback.format_exc())
+                raise RuntimeError(f"Cache error (disabled) in {self.name} for key {key}: {str(e)}") from e
+
+        try:
+            cached_data = self.get(key) # self.get() is synchronous, assumed to be fast.
+            if cached_data is not None:
+                self.logger.debug(f"Cache HIT for key {key} in {self.name} (async_get_or_set)")
+                return cached_data, True
+
+            self.logger.debug(f"Cache MISS for key {key} in {self.name} (async_get_or_set). Loading data.")
+            # Not in cache or expired, load the data asynchronously
+            fresh_data = await async_data_loader()
+
+            if fresh_data is not None:  # Only cache if we got valid data
+                self.set(key, fresh_data)
+            else:
+                # Log an error if data_loader returns None, as it's unexpected.
+                self.logger.error(f"Async data loader returned None for key {key} in {self.name}")
+                raise ValueError(f"Async data loader returned None for key {key} in {self.name}")
+
+            return fresh_data, False
+        except Exception as e:
+            self.logger.error(f"Error in async_get_or_set for key {key} in {self.name}: {str(e)}")
+            self.logger.error(traceback.format_exc())
+            # Re-raise the exception after logging, adding context
+            raise RuntimeError(f"Cache error in {self.name} for key {key} (async): {str(e)}") from e
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about the current cache state."""
+        with self.lock:
+            try:
+                # Clean up expired items before reporting size
+                current_time = time.time()
+                # Corrected: Use self._timestamps to find expired keys
+                expired_keys = [k for k, ts in self._timestamps.items() if current_time - ts >= self.ttl]
+                for k in expired_keys:
+                    self._cache.pop(k, None)
+                    self._timestamps.pop(k, None)
+                    self.evictions += 1
+
+                return {
+                    "name": self.name,
+                    "enabled": self.enabled,
+                    "ttl_seconds": self.ttl,
+                    "item_count": len(self._cache),
+                    "first_20_keys": list(self._cache.keys())[:20],  # Limit to first 20 keys
+                    "total_keys": len(self._cache.keys()),
+                    "memory_usage_estimate_megabytes": round(
+                        sum(len(str(k)) + self._estimate_size(v) for k, v in self._cache.items()) / (1024 * 1024),
+                        3
+                    ),
+                    "hits": self.hits,
+                    "misses": self.misses,
+                    "sets": self.sets,
+                    "evictions": self.evictions,
+                    "default_ttl": self.ttl
+                }
+            except Exception as e:
+                self.logger.error(f"Error getting stats for {self.name} cache: {str(e)}")
+                self.logger.error(traceback.format_exc())
+                return {
+                    "name": self.name,
+                    "enabled": self.enabled,
+                    "error": str(e),
+                    "ttl_seconds": self.ttl,
+                    "item_count": len(self._cache) if self._cache else 0
+                }
+
+    def _estimate_size(self, obj: Any) -> int:
+        """Estimate the memory size of an object in bytes."""
+        try:
+            if obj is None:
+                return 0
+            if isinstance(obj, (str, bytes, bytearray)):
+                return len(obj)
+            if isinstance(obj, (int, float, bool)):
+                return 8
+            if isinstance(obj, dict):
+                return sum(len(str(k)) + self._estimate_size(v) for k, v in obj.items())
+            if isinstance(obj, (list, tuple, set)):
+                return sum(self._estimate_size(i) for i in obj)
+            # For other objects, use a rough approximation
+            return len(str(obj))
+        except Exception:
+            # If we can't estimate, return a reasonable default
+            return 100
+
+    def __str__(self) -> str:
+        return f"SharedCache(name='{self.name}', size={len(self._cache)}, max_size={self.max_size}, hits={self.hits}, misses={self.misses})"

{ipulse_shared_core_ftredge-13.0.1 → ipulse_shared_core_ftredge-14.0.1}/src/ipulse_shared_core_ftredge/dependencies/authz_for_apis.py

@@ -231,7 +231,7 @@ async def authorizeAPIRequest(
 ) -> Dict[str, Any]:
     """
     Authorize API request based on user status and OPA policies.
-    Enhanced with credit check information.
+    Enhanced with credit check information and proper exception handling.
 
     Args:
         request: The incoming request
@@ -241,6 +241,9 @@ async def authorizeAPIRequest(
 
     Returns:
         Authorization result containing decision details
+
+    Raises:
+        HTTPException: For authorization failures (403) or service errors (500)
     """
     opa_decision = None
     try:
@@ -251,9 +254,11 @@ async def authorizeAPIRequest(
         # Extract request context
         user_uid = request.state.user.get('uid')
         if not user_uid:
-            raise AuthorizationError(
-                action="access API",
-                additional_info={"path": str(request.url)}
+            # Log authorization failures at DEBUG level, not ERROR
+            logger.debug(f"Authorization denied for {request.method} {request.url.path}: No user UID found")
+            raise HTTPException(
+                status_code=403,
+                detail="Not authorized to access this resource"
             )
 
         # Determine if we need fresh status
@@ -313,7 +318,7 @@ async def authorizeAPIRequest(
                     timeout=5.0  # 5 seconds timeout
                 )
                 logger.debug(f"OPA Response Status: {response.status_code}")
-                logger.debug(f"OPA Response Body: {response.text}")
+                # logger.debug(f"OPA Response Body: {response.text}")
 
                 if response.status_code != 200:
                     logger.error(f"OPA authorization failed: {response.text}")
@@ -326,11 +331,9 @@ async def authorizeAPIRequest(
                 logger.debug(f"Parsed OPA response: {result}")
 
                 # Handle unusual OPA response formats
-                # Try to find "decision" field as an alternative
                 if "result" in result:
                     opa_decision = result["result"]
                 else:
-                    # If we still don't have a result after all attempts, use default structure
                     logger.warning(f"OPA response missing 'result' field, using default")
                     raise HTTPException(
                         status_code=500,
@@ -340,31 +343,21 @@ async def authorizeAPIRequest(
                 # Extract key fields from result with better default handling
                 allow = opa_decision.get("allow", False)
 
-                # Handle authorization denial
+                # Handle authorization denial - log at DEBUG level, not ERROR
                 if not allow:
-                    logger.error(f"Authorization denied: {result}")
-                    raise AuthorizationError(
-                        action=f"{request.method} {request.url.path}",
-                        additional_info={
-                            "user_uid": user_uid,
-                            "resource_fields": request_resource_fields,
-                            "opa_decision": opa_decision,  # Include the full OPA decision result
-                            # Include the raw result if it's different from the processed decision
-                            "raw_opa_response": result if result != {"result": opa_decision} else None
-                        }
+                    logger.debug(f"Authorization denied for {request.method} {request.url.path}: insufficient permissions")
+                    raise HTTPException(
+                        status_code=403,
+                        detail=f"Not authorized to {request.method} {request.url.path}"
                     )
 
             except httpx.RequestError as e:
+                # Only log actual system errors at ERROR level
                 logger.error(f"Failed to connect to OPA: {str(e)}")
-                raise ServiceError(
-                    operation="API authorization",
-                    error=e,
-                    resource_type="authorization",
-                    additional_info={
-                        "opa_url": opa_url,
-                        "connection_error": str(e)
-                    }
-                ) from e
+                raise HTTPException(
+                    status_code=500,
+                    detail="Authorization service temporarily unavailable"
+                )
 
         # More descriptive metadata about the data freshness
         return {
@@ -374,21 +367,16 @@ async def authorizeAPIRequest(
             "opa_decision": opa_decision
         }
 
-    except (AuthorizationError, ResourceNotFoundError):
+    except HTTPException:
+        # Re-raise HTTPExceptions as-is (they're already properly formatted)
         raise
     except Exception as e:
-        logger.exception(f"Exception in authorizeAPIRequest: {e}")
-        raise ServiceError(
-            operation="API authorization",
-            error=e,
-            resource_type="authorization",
-            additional_info={
-                "path": str(request.url),
-                "method": request.method,
-                "user_uid": request.state.user.get('uid'),
-                "resource_fields": request_resource_fields
-            }
-        ) from e
+        # Only log unexpected errors at ERROR level
+        logger.error(f"Unexpected error during authorization for {request.method} {request.url.path}: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal authorization error"
+        )
 
 def _should_force_fresh_status(request: Request) -> bool:
     """

{ipulse_shared_core_ftredge-13.0.1 → ipulse_shared_core_ftredge-14.0.1}/src/ipulse_shared_core_ftredge/models/__init__.py

@@ -5,7 +5,6 @@ from .user_profile_update import UserProfileUpdate
 from .user_auth import UserAuth
 from .organization_profile import OrganizationProfile
 from .base_api_response import BaseAPIResponse , CustomJSONResponse
-
-
+from .base_data_model import BaseDataModel
 
 

ipulse_shared_core_ftredge-14.0.1/src/ipulse_shared_core_ftredge/services/cache_aware_firestore_service.py

@@ -0,0 +1,169 @@
+"""Cache-aware Firestore service base class."""
+import time
+from typing import TypeVar, Generic, Dict, Any, List, Optional
+from google.cloud import firestore
+from ipulse_shared_core_ftredge.services.base_firestore_service import BaseFirestoreService
+from ipulse_shared_core_ftredge.services.base_service_exceptions import ResourceNotFoundError, ServiceError
+from ipulse_shared_core_ftredge.cache.shared_cache import SharedCache
+from ipulse_shared_core_ftredge import BaseDataModel
+
+T = TypeVar('T', bound=BaseDataModel)
+
+class CacheAwareFirestoreService(BaseFirestoreService[T], Generic[T]):
+    """
+    Base service class that adds caching capabilities to BaseFirestoreService.
+    Supports both document-level and collection-level caching.
+    """
+
+    def __init__(
+        self,
+        db: firestore.Client,
+        collection_name: str,
+        resource_type: str,
+        logger,
+        document_cache: Optional[SharedCache] = None,
+        collection_cache: Optional[SharedCache] = None,
+        timeout: float = 30.0
+    ):
+        super().__init__(db, collection_name, resource_type, logger)
+        self.document_cache = document_cache
+        self.collection_cache = collection_cache
+        self.timeout = timeout
+
+        # Log cache configuration
+        if self.document_cache:
+            self.logger.info(f"Document cache enabled for {resource_type}: {self.document_cache.name}")
+        if self.collection_cache:
+            self.logger.info(f"Collection cache enabled for {resource_type}: {self.collection_cache.name}")
+
+    async def get_document(self, doc_id: str) -> Dict[str, Any]:
+        """
+        Get a document with caching support.
+
+        Args:
+            doc_id: Document ID to fetch
+
+        Returns:
+            Document data as dictionary
+
+        Raises:
+            ResourceNotFoundError: If document doesn't exist
+        """
+        # Check cache first
+        if self.document_cache:
+            start_time = time.time()
+            cached_doc = self.document_cache.get(doc_id)
+            cache_check_time = (time.time() - start_time) * 1000
+
+            if cached_doc is not None:
+                self.logger.debug(f"Cache HIT for document {doc_id} in {cache_check_time:.2f}ms")
+                return cached_doc
+            else:
+                self.logger.debug(f"Cache MISS for document {doc_id} - checking Firestore")
+
+        # Fetch from Firestore
+        start_time = time.time()
+        doc_ref = self.db.collection(self.collection_name).document(doc_id)
+        doc = doc_ref.get(timeout=self.timeout)
+        firestore_time = (time.time() - start_time) * 1000
+
+        if not doc.exists:
+            self.logger.info(f"Document {doc_id} not found in Firestore after {firestore_time:.2f}ms")
+            raise ResourceNotFoundError(self.resource_type, doc_id)
+
+        doc_data = doc.to_dict()
+        self.logger.debug(f"Fetched document {doc_id} from Firestore in {firestore_time:.2f}ms")
+
+        # Cache the result
+        if self.document_cache and doc_data:
+            self.document_cache.set(doc_id, doc_data)
+            self.logger.debug(f"Cached document {doc_id}")
+
+        return doc_data
+
+    async def get_all_documents(self, cache_key: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Retrieves all documents from the collection.
+        Uses collection_cache if cache_key is provided and cache is available.
+        Also populates document_cache for each retrieved document.
+        """
+        if cache_key and self.collection_cache:
+            cached_collection_data = self.collection_cache.get(cache_key)
+            if cached_collection_data is not None:
+                self.logger.debug(f"Cache HIT for collection key '{cache_key}' in {self.collection_cache.name}")
+                # Ensure individual documents are also in document_cache if possible
+                if self.document_cache:
+                    for doc_data in cached_collection_data:
+                        if "id" in doc_data and not self.document_cache.get(doc_data["id"]):
+                            self._cache_document_data(doc_data["id"], doc_data)
+                return cached_collection_data
+            else:
+                self.logger.debug(f"Cache MISS for collection key '{cache_key}' in {self.collection_cache.name} - checking Firestore")
+
+        self.logger.info(f"Fetching all documents for {self.resource_type} from Firestore.")
+        start_time = time.time()
+
+        try:
+            docs_stream = self.db.collection(self.collection_name).stream(timeout=self.timeout)
+            docs_data_list = []
+            for doc in docs_stream:
+                doc_data = doc.to_dict()
+                if doc_data is not None:
+                    doc_data["id"] = doc.id  # Ensure 'id' field is present
+                    docs_data_list.append(doc_data)
+
+            fetch_time = (time.time() - start_time) * 1000
+            self.logger.debug(f"Fetched {len(docs_data_list)} documents for {self.resource_type} from Firestore in {fetch_time:.2f}ms")
+
+            # Cache the entire collection if cache_key and collection_cache are available
+            if cache_key and self.collection_cache:
+                self.collection_cache.set(cache_key, docs_data_list)
+                self.logger.debug(f"Cached collection with key '{cache_key}' in {self.collection_cache.name}")
+
+            # Populate individual document cache
+            if self.document_cache:
+                self.logger.debug(f"Populating document cache ({self.document_cache.name}) with {len(docs_data_list)} items for {self.resource_type}.")
+                for doc_data in docs_data_list:
+                    # _cache_document_data expects 'id' to be in doc_data for keying
+                    self._cache_document_data(doc_data["id"], doc_data)
+
+            return docs_data_list
+
+        except Exception as e:
+            self.logger.error(f"Error fetching all documents for {self.resource_type}: {str(e)}", exc_info=True)
+            raise ServiceError(operation=f"fetching all {self.resource_type}s", error=e, resource_type=self.resource_type) from e
+
+    def _cache_document_data(self, doc_id: str, data: Dict[str, Any]):
+        """Helper to cache document data if document_cache is available."""
+        if self.document_cache:
+            self.document_cache.set(doc_id, data)
+            self.logger.debug(f"Cached item {doc_id} in {self.document_cache.name}")
+
+    async def create_document(self, doc_id: str, data: T, creator_uid: str) -> Dict[str, Any]:
+        """Create document and invalidate cache."""
+        result = await super().create_document(doc_id, data, creator_uid)
+        self._invalidate_document_cache(doc_id)
+        return result
+
+    async def update_document(self, doc_id: str, update_data: Dict[str, Any], updater_uid: str) -> Dict[str, Any]:
+        """Update document and invalidate cache."""
+        result = await super().update_document(doc_id, update_data, updater_uid)
+        self._invalidate_document_cache(doc_id)
+        return result
+
+    async def delete_document(self, doc_id: str, deleter_uid: Optional[str] = None) -> None:
+        """Delete document and invalidate cache."""
+        await super().delete_document(doc_id)
+        self._invalidate_document_cache(doc_id)
+
+    def _invalidate_document_cache(self, doc_id: str) -> None:
+        """Invalidate document cache for a specific document."""
+        if self.document_cache:
+            self.document_cache.invalidate(doc_id)
+            self.logger.debug(f"Invalidated cache for document {doc_id}")
+
+    def _invalidate_collection_cache(self, cache_key: str) -> None:
+        """Invalidate collection cache for a specific cache key."""
+        if self.collection_cache:
+            self.collection_cache.invalidate(cache_key)
+            self.logger.debug(f"Invalidated collection cache for key {cache_key}")

{ipulse_shared_core_ftredge-13.0.1 → ipulse_shared_core_ftredge-14.0.1/src/ipulse_shared_core_ftredge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 13.0.1
+Version: 14.0.1
 Summary: Shared Core models and Logger util for the Pulse platform project. Using AI for financial advisory and investment management.
 Home-page: https://github.com/TheFutureEdge/ipulse_shared_core
 Author: Russlan Ramdowar

ipulse_shared_core_ftredge-13.0.1/src/ipulse_shared_core_ftredge/cache/shared_cache.py

@@ -1,249 +0,0 @@
-"""Module for shared caching functionality that can be used across microservices."""
-import os
-import time
-import logging
-import traceback
-import inspect
-import asyncio
-from typing import Dict, Any, Optional, TypeVar, Generic, Callable, Tuple, List, Awaitable
-
-T = TypeVar('T')
-
-class SharedCache(Generic[T]):
-    """
-    Generic shared cache implementation that can be used across services.
-
-    Attributes:
-        name: The name of the cache for logging and identification.
-        ttl: Time-to-live in seconds for cached items.
-        enabled: Whether the cache is enabled.
-        logger: Logger for cache operations.
-        _cache: Dictionary holding cached values.
-        _timestamps: Dictionary holding timestamps for each cached item.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        ttl: float,
-        enabled: bool = True,
-        logger: Optional[logging.Logger] = None
-    ):
-        """Initialize the cache with name, TTL and enabled state."""
-        self.name = name
-        self.ttl = ttl
-        self.enabled = enabled
-        self.logger = logger or logging.getLogger(__name__)
-        self._cache: Dict[str, T] = {}
-        self._timestamps: Dict[str, float] = {}
-
-        self.logger.info(f"{name} cache initialized. Enabled: {enabled}, TTL: {ttl} seconds")
-
-    def get(self, key: str) -> Optional[T]:
-        """
-        Get a value from the cache if it exists and hasn't expired.
-
-        Args:
-            key: The cache key to retrieve.
-
-        Returns:
-            The cached value if found and valid, None otherwise.
-        """
-        if not self.enabled:
-            return None
-
-        try:
-            if key in self._cache:
-                timestamp = self._timestamps.get(key, 0)
-                if time.time() - timestamp < self.ttl:
-                    self.logger.debug(f"Cache hit for {key} in {self.name}")
-                    return self._cache[key]
-                else:
-                    # Expired item, remove it
-                    self.invalidate(key)
-                    self.logger.debug(f"Cache expired for {key} in {self.name}")
-        except Exception as e:
-            self.logger.error(f"Error getting item from {self.name} cache with key {key}: {str(e)}")
-            self.logger.error(traceback.format_exc())
-
-        return None
-
-    def set(self, key: str, value: T) -> None:
-        """
-        Set a value in the cache.
-
-        Args:
-            key: The cache key to set.
-            value: The value to cache.
-        """
-        if not self.enabled:
-            return
-
-        try:
-            self._cache[key] = value
-            self._timestamps[key] = time.time()
-            self.logger.debug(f"Cached item {key} in {self.name}")
-        except Exception as e:
-            self.logger.error(f"Error setting item in {self.name} cache with key {key}: {str(e)}")
-            self.logger.error(traceback.format_exc())
-
-    def invalidate(self, key: str) -> None:
-        """
-        Remove a specific key from the cache.
-
-        Args:
-            key: The cache key to invalidate.
-        """
-        try:
-            self._cache.pop(key, None)
-            self._timestamps.pop(key, None)
-            self.logger.debug(f"Invalidated cache for {key} in {self.name}")
-        except Exception as e:
-            self.logger.error(f"Error invalidating cache in {self.name} for key {key}: {str(e)}")
-            self.logger.error(traceback.format_exc())
-
-    def invalidate_all(self) -> None:
-        """Clear all cached items."""
-        try:
-            cache_size = len(self._cache)
-            self._cache.clear()
-            self._timestamps.clear()
-            self.logger.info(f"Invalidated all {cache_size} entries in {self.name} cache")
-        except Exception as e:
-            self.logger.error(f"Error invalidating all cache entries in {self.name}: {str(e)}")
-            self.logger.error(traceback.format_exc())
-
-    def get_or_set(
-        self,
-        key: str,
-        data_loader: Callable[[], T]
-    ) -> Tuple[T, bool]:
-        """
-        Get a value from cache or set it using the data_loader if missing or expired.
-
-        Args:
-            key: The cache key.
-            data_loader: Function to load data if not in cache.
-
-        Returns:
-            Tuple of (data, was_cached) where was_cached indicates if from cache.
-        """
-        try:
-            cached_data = self.get(key)
-            if cached_data is not None:
-                return cached_data, True
-
-            # Not in cache or expired, load the data
-            self.logger.debug(f"Cache miss for {key} in {self.name}, loading data...")
-
-            # Check if the data_loader is a coroutine function
-            if inspect.iscoroutinefunction(data_loader):
-                self.logger.error(
-                    f"Error in get_or_set for {key} in {self.name}: "
-                    f"data_loader is a coroutine function which is not supported. "
-                    f"Use a regular function that returns a value, not a coroutine."
-                )
-                # Fall back to running the coroutine in the event loop if possible
-                try:
-                    loop = asyncio.get_event_loop()
-                    fresh_data = loop.run_until_complete(data_loader())
-                except Exception as coro_err:
-                    self.logger.error(f"Failed to execute coroutine data_loader: {str(coro_err)}")
-                    raise RuntimeError(f"Cannot use coroutine data_loader in cache: {str(coro_err)}")
-            else:
-                # Regular function, just call it
-                fresh_data = data_loader()
-
-            if fresh_data is not None:  # Only cache if we got valid data
-                self.set(key, fresh_data)
-
-            if fresh_data is None:
-                raise ValueError(f"Data loader returned None for key {key} in {self.name}")
-            return fresh_data, False
-        except Exception as e:
-            self.logger.error(f"Error in get_or_set for {key} in {self.name}: {str(e)}")
-            self.logger.error(traceback.format_exc())
-
-            # Since this is a critical function, re-raise the exception
-            # after logging it, but add context about the cache
-            raise RuntimeError(f"Cache error in {self.name} for key {key}: {str(e)}") from e
-
-    async def async_get_or_set(
-        self,
-        key: str,
-        async_data_loader: Callable[[], Awaitable[T]]
-    ) -> Tuple[T, bool]:
-        """
-        Async version of get_or_set for use with async data loaders.
-
-        Args:
-            key: The cache key.
-            async_data_loader: Async function to load data if not in cache.
-
-        Returns:
-            Tuple of (data, was_cached) where was_cached indicates if from cache.
-        """
-        try:
-            cached_data = self.get(key)
-            if cached_data is not None:
-                return cached_data, True
-
-            # Not in cache or expired, load the data asynchronously
-            self.logger.debug(f"Cache miss for {key} in {self.name}, loading data asynchronously...")
-
-            # Execute the async data loader
-            fresh_data = await async_data_loader()
-
-            if fresh_data is not None:  # Only cache if we got valid data
-                self.set(key, fresh_data)
-
-            return fresh_data, False
-        except Exception as e:
-            self.logger.error(f"Error in async_get_or_set for {key} in {self.name}: {str(e)}")
-            self.logger.error(traceback.format_exc())
-            raise RuntimeError(f"Cache error in {self.name} for key {key}: {str(e)}") from e
-
-    def get_stats(self) -> Dict[str, Any]:
-        """Get statistics about the current cache state."""
-        try:
-            return {
-                "name": self.name,
-                "enabled": self.enabled,
-                "ttl_seconds": self.ttl,
-                "item_count": len(self._cache),
-                "keys": list(self._cache.keys())[:20],  # Limit to first 20 keys
-                "has_more_keys": len(self._cache.keys()) > 20,
-                "memory_usage_estimate_bytes": sum(
-                    len(str(k)) + self._estimate_size(v)
-                    for k, v in self._cache.items()
-                )
-            }
-        except Exception as e:
-            self.logger.error(f"Error getting stats for {self.name} cache: {str(e)}")
-            self.logger.error(traceback.format_exc())
-            return {
-                "name": self.name,
-                "enabled": self.enabled,
-                "error": str(e),
-                "ttl_seconds": self.ttl,
-                "item_count": len(self._cache) if self._cache else 0
-            }
-
-    def _estimate_size(self, obj: Any) -> int:
-        """Estimate the memory size of an object in bytes."""
-        try:
-            if obj is None:
-                return 0
-            if isinstance(obj, (str, bytes, bytearray)):
-                return len(obj)
-            if isinstance(obj, (int, float, bool)):
-                return 8
-            if isinstance(obj, dict):
-                return sum(len(str(k)) + self._estimate_size(v) for k, v in obj.items())
-            if isinstance(obj, (list, tuple, set)):
-                return sum(self._estimate_size(i) for i in obj)
-            # For other objects, use a rough approximation
-            return len(str(obj))
-        except Exception:
-            # If we can't estimate, return a reasonable default
-            return 100

ipulse_shared_core_ftredge-13.0.1/src/ipulse_shared_core_ftredge/services/cache_aware_firestore_service.py

@@ -1,171 +0,0 @@
-"""Base service with built-in cache awareness for Firestore operations."""
-
-from typing import Dict, Any, List, Optional, TypeVar, Generic
-from google.cloud import firestore
-from pydantic import BaseModel
-import logging
-from ipulse_shared_core_ftredge.cache.shared_cache import SharedCache
-from ipulse_shared_core_ftredge.services import BaseFirestoreService
-
-T = TypeVar('T', bound=BaseModel)
-
-class CacheAwareFirestoreService(BaseFirestoreService, Generic[T]):
-    """
-    Base service class that integrates caching with Firestore operations.
-    This allows services to inherit cache-aware CRUD methods without reimplementing them.
-    """
-
-    def __init__(
-        self,
-        db: firestore.Client,
-        collection_name: str,
-        resource_type: str,
-        logger: logging.Logger,
-        document_cache: Optional[SharedCache] = None,
-        collection_cache: Optional[SharedCache] = None,
-        timeout: float = 15.0
-    ):
-        """
-        Initialize the service with optional cache instances.
-
-        Args:
-            db: Firestore client
-            collection_name: Firestore collection name
-            resource_type: Resource type for error messages
-            logger: Logger instance
-            document_cache: Cache for individual documents (optional)
-            collection_cache: Cache for collection-level queries (optional)
-            timeout: Firestore operation timeout in seconds
-        """
-        super().__init__(
-            db=db,
-            collection_name=collection_name,
-            resource_type=resource_type,
-            logger=logger,
-            timeout=timeout
-        )
-        self.document_cache = document_cache
-        self.collection_cache = collection_cache
-
-        # Log cache configuration
-        if document_cache:
-            self.logger.info(f"Document cache enabled for {resource_type}: {document_cache.name}")
-        if collection_cache:
-            self.logger.info(f"Collection cache enabled for {resource_type}: {collection_cache.name}")
-
-    async def create_document(self, doc_id: str, data: T, creator_uid: str) -> Dict[str, Any]:
-        """Create a document and invalidate relevant caches."""
-        result = await super().create_document(doc_id, data, creator_uid)
-
-        # Invalidate document cache if it exists
-        self._invalidate_document_cache(doc_id)
-
-        # Invalidate collection cache if it exists
-        self._invalidate_collection_cache()
-
-        return result
-
-    async def update_document(self, doc_id: str, update_data: Dict[str, Any], updater_uid: str) -> Dict[str, Any]:
-        """Update a document and invalidate relevant caches."""
-        result = await super().update_document(doc_id, update_data, updater_uid)
-
-        # Invalidate document cache if it exists
-        self._invalidate_document_cache(doc_id)
-
-        # Invalidate collection cache if it exists
-        self._invalidate_collection_cache()
-
-        return result
-
-    async def delete_document(self, doc_id: str, deleter_uid: Optional[str] = None) -> None:
-        """Delete a document and invalidate relevant caches."""
-        # Invalidate caches before deletion to handle potential failures
-        self._invalidate_document_cache(doc_id)
-        self._invalidate_collection_cache()
-
-        # Delete the document
-        await super().delete_document(doc_id)
-
-    async def get_document(self, doc_id: str) -> Dict[str, Any]:
-        """
-        Get a document by ID with caching if available.
-
-        Args:
-            doc_id: The document ID to fetch
-
-        Returns:
-            The document data
-        """
-        # Check document cache first if available
-        if self.document_cache:
-            cached_data = self.document_cache.get(doc_id)
-            if cached_data is not None:
-                self.logger.debug(f"Cache hit for document {doc_id}")
-                return cached_data
-
-        # Cache miss or no cache configured, fetch from Firestore
-        doc_data = await super().get_document(doc_id)
-
-        # Store in cache if available
-        if self.document_cache and doc_data:
-            # Make sure ID is included in the cached data
-            if 'id' not in doc_data:
-                doc_data['id'] = doc_id
-            self.document_cache.set(doc_id, doc_data)
-            self.logger.debug(f"Cached document {doc_id}")
-
-        return doc_data
-
-    async def get_all_documents(self, cache_key: str = "all_documents") -> List[Dict[str, Any]]:
-        """
-        Get all documents in the collection with caching.
-
-        Args:
-            cache_key: The key to use for caching the full collection
-
-        Returns:
-            List of all documents in the collection
-        """
-        # Check collection cache first if available
-        if self.collection_cache:
-            cached_data = self.collection_cache.get(cache_key)
-            if cached_data is not None:
-                self.logger.debug(f"Cache hit for collection query: {cache_key}")
-                return cached_data
-
-        # Cache miss or no cache configured, fetch from Firestore
-        query = self.db.collection(self.collection_name).stream(timeout=self.timeout)
-        documents = []
-
-        for doc in query:
-            doc_data = doc.to_dict()
-
-            # Make sure ID is included in the data
-            if 'id' not in doc_data:
-                doc_data['id'] = doc.id
-
-            # Also update the document cache if configured
-            if self.document_cache:
-                self.document_cache.set(doc.id, doc_data)
-
-            documents.append(doc_data)
-
-        # Store in collection cache if available
-        if self.collection_cache:
-            self.collection_cache.set(cache_key, documents)
-            self.logger.debug(f"Cached collection query result: {cache_key} with {len(documents)} documents")
-
-        return documents
-
-    def _invalidate_document_cache(self, doc_id: str) -> None:
-        """Invalidate the document cache for a specific document ID."""
-        if self.document_cache:
-            self.document_cache.invalidate(doc_id)
-            self.logger.debug(f"Invalidated document cache for {doc_id}")
-
-    def _invalidate_collection_cache(self, cache_key: str = "all_documents") -> None:
-        """Invalidate the collection cache."""
-        if self.collection_cache:
-            # For single key collection cache
-            self.collection_cache.invalidate(cache_key)
-            self.logger.debug(f"Invalidated collection cache: {cache_key}")