ipulse-shared-core-ftredge 27.3.0__tar.gz → 27.4.0__tar.gz

{ipulse_shared_core_ftredge-27.3.0/src/ipulse_shared_core_ftredge.egg-info → ipulse_shared_core_ftredge-27.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 27.3.0
+Version: 27.4.0
 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-27.3.0 → ipulse_shared_core_ftredge-27.4.0}/setup.py

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

{ipulse_shared_core_ftredge-27.3.0 → ipulse_shared_core_ftredge-27.4.0}/src/ipulse_shared_core_ftredge/models/base_api_response.py

@@ -16,6 +16,10 @@ class BaseAPIResponse(BaseModel, Generic[T]):
     message: Optional[str] = None
     error: Optional[str] = None
 
+    # Optional fields for specific use cases
+    cache_hit: Optional[bool] = None  # Whether data came from cache
+    charged: Optional[bool] = None    # Whether credits were charged for this request
+
     metadata: Dict[str, Any] = {
         "timestamp": dt.datetime.now(dt.timezone.utc).isoformat()
     }

{ipulse_shared_core_ftredge-27.3.0 → ipulse_shared_core_ftredge-27.4.0}/src/ipulse_shared_core_ftredge/services/base/cache_aware_firestore_service.py

@@ -1,13 +1,14 @@
 """Cache-aware Firestore service base class."""
 import time
-from typing import TypeVar, Generic, Dict, Any, List, Optional, Union, Type
+from typing import TypeVar, Generic, Dict, Any, List, Optional, Union, Type, Tuple
 from google.cloud import firestore
 from . import BaseFirestoreService
 from ...exceptions import ResourceNotFoundError, ServiceError
 from ...cache.shared_cache import SharedCache
 from ...models import BaseDataModel
 
-T = TypeVar('T', bound=BaseDataModel)
+T = TypeVar('T', bound=BaseDataModel)0
+0
 
 class CacheAwareFirestoreService(BaseFirestoreService[T], Generic[T]):
     """
@@ -58,7 +59,9 @@ class CacheAwareFirestoreService(BaseFirestoreService[T], Generic[T]):
             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")
+                # SharedCache.get() already logs cache hit, only log timing if significant
+                if cache_check_time > 5.0:  # Only log if cache check took >5ms
+                    self.logger.debug(f"Cache HIT for document {doc_id} in {cache_check_time:.2f}ms")
                 if convert_to_model and self.model_class:
                     return self._convert_to_model(cached_doc, doc_id)
                 else:
@@ -68,7 +71,66 @@ class CacheAwareFirestoreService(BaseFirestoreService[T], Generic[T]):
                 self.logger.debug(f"Cache MISS for document {doc_id} - checking Firestore")
 
         # Fetch from Firestore using parent method
-        return await super().get_document(doc_id, convert_to_model)
+        result = await super().get_document(doc_id, convert_to_model)
+
+        # Cache the result if we have a cache and got valid data
+        if self.document_cache and result is not None:
+            if convert_to_model and isinstance(result, BaseDataModel):
+                # Cache the model's dict representation
+                self._cache_document_data(doc_id, result.model_dump())
+            elif isinstance(result, dict):
+                # Cache the dict directly
+                self._cache_document_data(doc_id, result)
+
+        return result
+
+    async def get_document_with_cache_info(self, doc_id: str, convert_to_model: bool = True) -> Tuple[Union[T, Dict[str, Any], None], bool]:
+        """
+        Get a document with cache hit information.
+
+        Args:
+            doc_id: Document ID to fetch
+            convert_to_model: Whether to convert to Pydantic model
+
+        Returns:
+            Tuple of (document, cache_hit) where cache_hit indicates if from cache
+
+        Raises:
+            ResourceNotFoundError: If document doesn't exist
+        """
+        cache_hit = False
+
+        # Check cache first
+        if self.document_cache:
+            cached_doc = self.document_cache.get(doc_id)
+            if cached_doc is not None:
+                cache_hit = True
+                # Note: SharedCache.get() already logs cache hit at DEBUG level
+                if convert_to_model and self.model_class:
+                    return self._convert_to_model(cached_doc, doc_id), cache_hit
+                else:
+                    cached_doc['id'] = doc_id
+                    return cached_doc, cache_hit
+
+        # Cache miss - fetch from Firestore
+        self.logger.debug(f"Cache MISS for document {doc_id} - checking Firestore")
+
+        try:
+            result = await super().get_document(doc_id, convert_to_model)
+
+            # Cache the result if we have a cache and got valid data
+            if self.document_cache and result is not None:
+                if convert_to_model and isinstance(result, BaseDataModel):
+                    # Cache the model's dict representation
+                    self._cache_document_data(doc_id, result.model_dump())
+                elif isinstance(result, dict):
+                    # Cache the dict directly
+                    self._cache_document_data(doc_id, result)
+
+            return result, cache_hit
+
+        except ResourceNotFoundError:
+            return None, cache_hit
 
     async def get_all_documents(self, cache_key: Optional[str] = None, as_models: bool = True) -> Union[List[T], List[Dict[str, Any]]]:
         """
@@ -151,7 +213,7 @@ class CacheAwareFirestoreService(BaseFirestoreService[T], Generic[T]):
         """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}")
+            # Note: SharedCache.set() already logs at DEBUG level
 
     async def create_document(self, doc_id: str, data: Union[T, Dict[str, Any]], creator_uid: str, merge: bool = False) -> Dict[str, Any]:
         """Create document and invalidate cache."""

{ipulse_shared_core_ftredge-27.3.0 → ipulse_shared_core_ftredge-27.4.0/src/ipulse_shared_core_ftredge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 27.3.0
+Version: 27.4.0
 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-27.3.0 → ipulse_shared_core_ftredge-27.4.0}/src/ipulse_shared_core_ftredge.egg-info/SOURCES.txt

@@ -56,7 +56,5 @@ src/ipulse_shared_core_ftredge/services/user/userauth_operations.py
 src/ipulse_shared_core_ftredge/services/user/userprofile_operations.py
 src/ipulse_shared_core_ftredge/services/user/userstatus_operations.py
 src/ipulse_shared_core_ftredge/utils/__init__.py
-src/ipulse_shared_core_ftredge/utils/authz_credit_extraction.py
 src/ipulse_shared_core_ftredge/utils/custom_json_encoder.py
-src/ipulse_shared_core_ftredge/utils/json_encoder.py
-tests/test_shared_cache.py
+src/ipulse_shared_core_ftredge/utils/json_encoder.py

ipulse_shared_core_ftredge-27.3.0/tests/test_shared_cache.py

@@ -1,147 +0,0 @@
-"""Tests for the SharedCache implementation."""
-
-import time
-import unittest
-import logging
-from ipulse_shared_core_ftredge.cache.shared_cache import SharedCache
-
-# Configure logging for tests
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-class TestSharedCache(unittest.TestCase):
-    """Test cases for SharedCache."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.cache = SharedCache[str](
-            name="TestCache",
-            ttl=0.5,  # Short TTL for faster testing
-            enabled=True,
-            logger=logger
-        )
-
-    def test_cache_set_get(self):
-        """Test basic cache set and get operations."""
-        # Set a value
-        self.cache.set("test_key", "test_value")
-
-        # Get the value
-        cached_value = self.cache.get("test_key")
-
-        # Verify value was cached
-        self.assertEqual(cached_value, "test_value")
-
-    def test_cache_ttl_expiration(self):
-        """Test cache TTL expiration."""
-        # Set a value
-        self.cache.set("expiring_key", "expiring_value")
-
-        # Verify it's initially cached
-        self.assertEqual(self.cache.get("expiring_key"), "expiring_value")
-
-        # Wait for TTL to expire
-        time.sleep(0.6)  # Slightly longer than TTL (0.5s)
-
-        # Verify value is no longer cached
-        self.assertIsNone(self.cache.get("expiring_key"))
-
-    def test_cache_invalidate(self):
-        """Test cache invalidation."""
-        # Set multiple values
-        self.cache.set("key1", "value1")
-        self.cache.set("key2", "value2")
-
-        # Invalidate specific key
-        self.cache.invalidate("key1")
-
-        # Verify key1 is gone but key2 remains
-        self.assertIsNone(self.cache.get("key1"))
-        self.assertEqual(self.cache.get("key2"), "value2")
-
-    def test_cache_invalidate_all(self):
-        """Test invalidating all cache entries."""
-        # Set multiple values
-        self.cache.set("key1", "value1")
-        self.cache.set("key2", "value2")
-
-        # Invalidate all
-        self.cache.invalidate_all()
-
-        # Verify both keys are gone
-        self.assertIsNone(self.cache.get("key1"))
-        self.assertIsNone(self.cache.get("key2"))
-
-    def test_cache_get_or_set(self):
-        """Test get_or_set functionality."""
-        # Define a counter to verify how many times the loader is called
-        counter = [0]
-
-        def data_loader():
-            counter[0] += 1
-            return f"loaded_value_{counter[0]}"
-
-        # First call should use data_loader
-        value1, was_cached1 = self.cache.get_or_set("loader_key", data_loader)
-
-        # Second call should use cached value
-        value2, was_cached2 = self.cache.get_or_set("loader_key", data_loader)
-
-        # Verify results
-        self.assertEqual(value1, "loaded_value_1")
-        self.assertEqual(value2, "loaded_value_1")  # Same value from cache
-        self.assertFalse(was_cached1)  # First call was not cached
-        self.assertTrue(was_cached2)   # Second call was cached
-        self.assertEqual(counter[0], 1)  # Loader called exactly once
-
-    def test_cache_disabled(self):
-        """Test cache behavior when disabled."""
-        # Create disabled cache
-        disabled_cache = SharedCache[str](
-            name="DisabledCache",
-            ttl=1.0,
-            enabled=False,
-            logger=logger
-        )
-
-        # Set a value
-        disabled_cache.set("disabled_key", "disabled_value")
-
-        # Attempt to get - should return None since cache is disabled
-        cached_value = disabled_cache.get("disabled_key")
-        self.assertIsNone(cached_value)
-
-    def test_cache_generic_typing(self):
-        """Test cache with different data types."""
-        # Integer cache
-        int_cache = SharedCache[int](name="IntCache", ttl=1.0, enabled=True)
-        int_cache.set("int_key", 123)
-        self.assertEqual(int_cache.get("int_key"), 123)
-
-        # Dictionary cache
-        dict_cache = SharedCache[dict](name="DictCache", ttl=1.0, enabled=True)
-        dict_cache.set("dict_key", {"a": 1, "b": 2})
-        self.assertEqual(dict_cache.get("dict_key"), {"a": 1, "b": 2})
-
-    def test_cache_stats(self):
-        """Test cache statistics."""
-        # Add some data
-        self.cache.set("stats_key1", "stats_value1")
-        self.cache.set("stats_key2", "stats_value2")
-
-        # Get stats
-        stats = self.cache.get_stats()
-
-        # Verify stats
-        self.assertEqual(stats["name"], "TestCache")
-        self.assertEqual(stats["enabled"], True)
-        self.assertEqual(stats["ttl_seconds"], 0.5)
-        self.assertEqual(stats["item_count"], 2)
-        self.assertIn("stats_key1", stats["first_20_keys"])
-        self.assertIn("stats_key2", stats["first_20_keys"])
-        self.assertEqual(stats["total_keys"], 2)
-
-
-if __name__ == "__main__":
-    unittest.main()