ipulse-shared-core-ftredge 12.0.1__py3-none-any.whl → 13.0.1__py3-none-any.whl

ipulse_shared_core_ftredge/cache/__init__.py

@@ -0,0 +1,4 @@
+"""Cache utilities for shared core."""
+from ipulse_shared_core_ftredge.cache.shared_cache import SharedCache
+
+__all__ = ['SharedCache']

ipulse_shared_core_ftredge/cache/shared_cache.py

@@ -0,0 +1,249 @@
+"""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/services/__init__.py

@@ -1,6 +1,14 @@
-from .base_firestore_service  import BaseFirestoreService
+"""Service utilities for shared core."""
+# Import existing components
+from ipulse_shared_core_ftredge.services.base_service_exceptions import (
+    BaseServiceException, ServiceError, ValidationError, ResourceNotFoundError, AuthorizationError
+)
+from ipulse_shared_core_ftredge.services.servicemon import Servicemon
+from ipulse_shared_core_ftredge.services.base_firestore_service import BaseFirestoreService
+from ipulse_shared_core_ftredge.services.cache_aware_firestore_service import CacheAwareFirestoreService
 
-from .base_service_exceptions import (BaseServiceException, ResourceNotFoundError, AuthorizationError,
-                            ValidationError ,ServiceError)
-from .servicemon import Servicemon
-from .fastapiservicemon import FastAPIServiceMon
+__all__ = [
+   'AuthorizationError', 'BaseServiceException', 'ServiceError', 'ValidationError',
+    'ResourceNotFoundError',  'BaseFirestoreService',
+    'CacheAwareFirestoreService'
+]

ipulse_shared_core_ftredge/services/cache_aware_firestore_service.py

@@ -0,0 +1,171 @@
+"""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}")

ipulse_shared_core_ftredge/services/credit_service.py

@@ -135,7 +135,7 @@ class CreditService:
                 error=e,
                 resource_type="user_credits",
                 resource_id=user_uid,
-                additional_info={"credits_to_charge": credits_to_charge}
+                additional_info={"credits_to_charge": required_credits_for_resource}
             ) from e
 
     async def charge_credits(self, user_uid: str, credits_to_charge: Optional[float], operation_details: str) -> bool:

{ipulse_shared_core_ftredge-12.0.1.dist-info → ipulse_shared_core_ftredge-13.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 12.0.1
+Version: 13.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-12.0.1.dist-info → ipulse_shared_core_ftredge-13.0.1.dist-info}/RECORD

@@ -1,4 +1,6 @@
 ipulse_shared_core_ftredge/__init__.py,sha256=Bj1WgZq6EmiZeFC-3gYludUpoWgsUrRq1NME5nMN22Q,501
+ipulse_shared_core_ftredge/cache/__init__.py,sha256=i2fPojmZiBwAoY5ovnnnME9USl4bi8MRPYkAgEfACfI,136
+ipulse_shared_core_ftredge/cache/shared_cache.py,sha256=pDHJuMRU6zkqbykaK2ldpyVmUHLa0TAI4Xu3P9M-0B0,9454
 ipulse_shared_core_ftredge/dependencies/__init__.py,sha256=HGsR8HUguKTfjz_BorCILS4izX8CAjG-apE0kIPE0Yo,68
 ipulse_shared_core_ftredge/dependencies/auth_firebase_token_validation.py,sha256=EFWyhoVOI0tGYOWqN5St4JNIy4cMwpxeBhKdjOwEfbg,1888
 ipulse_shared_core_ftredge/dependencies/auth_protected_router.py,sha256=em5D5tE7OkgZmuCtYCKuUAnIZCgRJhCF8Ye5QmtGWlk,1807
@@ -13,17 +15,18 @@ ipulse_shared_core_ftredge/models/user_auth.py,sha256=YgCeK0uJ-JOkPavwzogl4wGC3R
 ipulse_shared_core_ftredge/models/user_profile.py,sha256=5cTTZa7pMkgKCsLgTPpvz_aPn-ZyQcJ3xSEtu3jq3HE,4138
 ipulse_shared_core_ftredge/models/user_profile_update.py,sha256=3BqAAqnVKXPKhAcfV_aOERe8GyIkX0NU_LJcQa02aLw,1319
 ipulse_shared_core_ftredge/models/user_status.py,sha256=rAx8l5GrB8TN7RvZ1eIMskphRxdYqO1OZ8NnaIxUUW8,23660
-ipulse_shared_core_ftredge/services/__init__.py,sha256=Ji9AhDy1HVwcJjYMdyfggerxa0b8e78JAnCQ-o-_sSA,304
+ipulse_shared_core_ftredge/services/__init__.py,sha256=iwbBlviqOxVPmJC9tRsOyU6zzQlAn7Do0Gc3WKRi4Ao,697
 ipulse_shared_core_ftredge/services/base_firestore_service.py,sha256=n1lymQEFcu6zHkdscNNCNIzTIVmja8cBtNy2yi5vfTE,9817
 ipulse_shared_core_ftredge/services/base_service_exceptions.py,sha256=Bi0neeMY0YncWDeqUavu5JUslkjJ6QcDVRU32Ipjc08,4294
-ipulse_shared_core_ftredge/services/credit_service.py,sha256=gYG8-akg0DiGzCcERaw1sKZdlxIwprHezMN2-KRXQmA,12026
+ipulse_shared_core_ftredge/services/cache_aware_firestore_service.py,sha256=DLNS1BegJUPSHs41j5jkP3g6w2tGSDUIurIWjI__xf4,6486
+ipulse_shared_core_ftredge/services/credit_service.py,sha256=C07rOr58LsK4udznu64mQFUSBxY8AdfRaxw_9Pw_AOI,12038
 ipulse_shared_core_ftredge/services/fastapiservicemon.py,sha256=27clTZXH32mbju8o-HLO_8VrmugmpXwHLuX-OOoIAew,5308
 ipulse_shared_core_ftredge/services/servicemon.py,sha256=wWhsLwU1_07emaEyCNziZA1bDQVLxcfvQj0OseTLSTI,7969
 ipulse_shared_core_ftredge/utils/__init__.py,sha256=JnxUb8I2MRjJC7rBPXSrpwBIQDEOku5O9JsiTi3oun8,56
 ipulse_shared_core_ftredge/utils/custom_json_encoder.py,sha256=DblQLD0KOSNDyQ58wQRogBrShIXzPIZUw_oGOBATnJY,1366
 ipulse_shared_core_ftredge/utils/json_encoder.py,sha256=QkcaFneVv3-q-s__Dz4OiUWYnM6jgHDJrDMdPv09RCA,2093
-ipulse_shared_core_ftredge-12.0.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
-ipulse_shared_core_ftredge-12.0.1.dist-info/METADATA,sha256=YjOLhvTykOjl4vKNAV7Tds7uhPHb1C4yPIV6-ULXW2I,803
-ipulse_shared_core_ftredge-12.0.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-ipulse_shared_core_ftredge-12.0.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
-ipulse_shared_core_ftredge-12.0.1.dist-info/RECORD,,
+ipulse_shared_core_ftredge-13.0.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
+ipulse_shared_core_ftredge-13.0.1.dist-info/METADATA,sha256=OYQw5kTq7LHJinYen7EVx-NryTit726UoMoNm6PxtMA,803
+ipulse_shared_core_ftredge-13.0.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+ipulse_shared_core_ftredge-13.0.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
+ipulse_shared_core_ftredge-13.0.1.dist-info/RECORD,,