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

ipulse_shared_core_ftredge/__init__.py

@@ -7,6 +7,6 @@ from .models import ( UserAuth, UserProfile,Subscription,
 
 
 from .services import (BaseFirestoreService,BaseServiceException, ResourceNotFoundError, AuthorizationError,
-                            ValidationError)
+                            ValidationError, ServiceError)
 
 from .utils import (EnsureJSONEncoderCompatibility)

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/dependencies/authz_for_apis.py

@@ -1,5 +1,8 @@
 import os
 import logging
+import json
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
 from typing import Optional, Iterable, Dict, Any, List
 from datetime import datetime, timedelta, timezone
 import json
@@ -10,10 +13,10 @@ from ipulse_shared_core_ftredge.services import ServiceError, AuthorizationError
 from ipulse_shared_core_ftredge.models import UserStatus
 from ipulse_shared_core_ftredge.utils.json_encoder import convert_to_json_serializable
 
-# Constants
-USERS_STATUS_COLLECTION_NAME = UserStatus.get_collection_name()
-USERS_STATUS_DOC_REF = "userstatus_"
-CACHE_TTL = 60 # 60 seconds
+# Constants derived from UserStatus model
+USERS_STATUS_COLLECTION_NAME = UserStatus.COLLECTION_NAME
+USERS_STATUS_DOC_REF = f"{UserStatus.OBJ_REF}_" # Use OBJ_REF and append underscore
+USERSTATUS_CACHE_TTL = 60 # 60 seconds
 
 class UserStatusCache:
     """Manages user status caching with dynamic invalidation"""
@@ -33,7 +36,7 @@ class UserStatusCache:
             status_data = self._cache[user_uid]
             # Force refresh for credit-consuming or sensitive operations
             # Check TTL for normal operations
-            if datetime.now() - self._timestamps[user_uid] < timedelta(seconds=CACHE_TTL):
+            if datetime.now() - self._timestamps[user_uid] < timedelta(seconds=USERSTATUS_CACHE_TTL):
                 return status_data
             self.invalidate(user_uid)
         return None
@@ -65,13 +68,59 @@ userstatus_cache = UserStatusCache()
 # Replace the logger dependency with a standard logger
 logger = logging.getLogger(__name__)
 
+# Create a custom FirestoreTimeoutError class that can be identified in middlewares
+class FirestoreTimeoutError(TimeoutError):
+    """Custom exception for Firestore timeout errors to make them more identifiable."""
+    pass
+
+
+# Define a function to get a Firestore document with a strict timeout
+async def get_with_strict_timeout(doc_ref, timeout_seconds: float):
+    """
+    Get a Firestore document with a strictly enforced timeout.
+
+    Args:
+        doc_ref: Firestore document reference
+        timeout_seconds: Maximum time to wait in seconds
+
+    Returns:
+        Document snapshot
+
+    Raises:
+        FirestoreTimeoutError: If the operation takes longer than timeout_seconds
+    """
+    loop = asyncio.get_running_loop()
+    with ThreadPoolExecutor() as executor:
+        try:
+            # Run the blocking Firestore get() operation in a thread and apply a strict timeout
+            logger.debug(f"Starting Firestore get with strict timeout of {timeout_seconds}s")
+            return await asyncio.wait_for(
+                loop.run_in_executor(executor, doc_ref.get),
+                timeout=timeout_seconds
+            )
+        except asyncio.TimeoutError:
+            error_message = f"User Status fetching for Authz timed out after {timeout_seconds} seconds, perhaps issue with Firestore Connectivity"
+            logger.error(error_message)
+            raise FirestoreTimeoutError(error_message)
+
+# Update get_userstatus to use our new strict timeout function
 async def get_userstatus(
     user_uid: str,
-    db: firestore.Client,  # Note: This expects the actual client, not a Depends
-    force_fresh: bool = False
+    db: firestore.Client,
+    force_fresh: bool = False,
+    timeout: float = 12.0  # Default timeout but allow override
 ) -> tuple[Dict[str, Any], bool]:
     """
-    Fetch user status with intelligent caching
+    Fetch user status with intelligent caching and configurable timeout
+
+    Args:
+        user_uid: User ID to fetch status for
+        db: Firestore client
+        force_fresh: Whether to bypass cache
+        timeout: Timeout for Firestore operations in seconds
+
+    Returns:
+        Tuple of (user status data, whether cache was used)
     """
     cache_used = False
     if not force_fresh:
@@ -85,8 +134,11 @@ async def get_userstatus(
         userstatus_id = USERS_STATUS_DOC_REF + user_uid
         user_ref = db.collection(USERS_STATUS_COLLECTION_NAME).document(userstatus_id)
 
-        # Get the document
-        snapshot = user_ref.get()
+        logger.debug(f"Fetching user status for {user_uid} with strict timeout {timeout}s")
+
+        # Use our strict timeout wrapper instead of the native timeout parameter
+        snapshot = await get_with_strict_timeout(user_ref, timeout)
+
         if not snapshot.exists:
             raise ResourceNotFoundError(
                 resource_type="authorization userstatus",
@@ -101,9 +153,23 @@ async def get_userstatus(
             userstatus_cache.set(user_uid, status_data)
         return status_data, cache_used
 
+    except TimeoutError as e:
+        logger.error(f"Timeout while fetching user status for {user_uid}: {str(e)}")
+        raise ServiceError(
+            operation="fetching user status for authz",
+            error=e,
+            resource_type="userstatus",
+            resource_id=user_uid,
+            additional_info={
+                "force_fresh": force_fresh,
+                "collection": USERS_STATUS_COLLECTION_NAME,
+                "timeout_seconds": timeout
+            }
+        )
     except ResourceNotFoundError:
         raise
     except Exception as e:
+        logger.error(f"Error fetching user status for {user_uid}: {str(e)}")
         raise ServiceError(
             operation=f"fetching user status",
             error=e,
@@ -156,15 +222,27 @@ async def extract_request_fields(request: Request) -> Optional[List[str]]:
         logger.warning(f"Could not extract fields from request body: {str(e)}")
         return None  # Return None instead of raising an error
 
+# Main authorization function with configurable timeout
 async def authorizeAPIRequest(
     request: Request,
-    db: firestore.Client,  # Changed: Now expects actual client instance
+    db: firestore.Client,
     request_resource_fields: Optional[Iterable[str]] = None,
+    firestore_timeout: float = 15.0  # Allow specifying timeout
 ) -> Dict[str, Any]:
     """
     Authorize API request based on user status and OPA policies.
     Enhanced with credit check information.
+
+    Args:
+        request: The incoming request
+        db: Firestore client
+        request_resource_fields: Fields being accessed/modified in the request
+        firestore_timeout: Timeout for Firestore operations in seconds
+
+    Returns:
+        Authorization result containing decision details
     """
+    opa_decision = None
     try:
         # Extract fields for both PATCH and POST if not provided
         if not request_resource_fields:
@@ -180,7 +258,12 @@ async def authorizeAPIRequest(
 
         # Determine if we need fresh status
         force_fresh = _should_force_fresh_status(request)
-        userstatus, cache_used = await get_userstatus(user_uid, db, force_fresh=force_fresh)
+        userstatus, cache_used = await get_userstatus(
+            user_uid,
+            db,
+            force_fresh=force_fresh,
+            timeout=firestore_timeout  # Pass the specified timeout
+        )
 
         # Prepare authorization input that matches OPA expectations
         # Extract required values from user status
@@ -214,7 +297,13 @@ async def authorizeAPIRequest(
         # Query OPA
         opa_url = f"{os.getenv('OPA_SERVER_URL', 'http://localhost:8181')}{os.getenv('OPA_DECISION_PATH', '/v1/data/http/authz/ingress/decision')}"
         logger.debug(f"Attempting to connect to OPA at: {opa_url}")
-        logger.debug(f"Authorization input: {authz_input}")
+
+        # Debug: Print raw JSON payload to identify any potential issues
+        try:
+            payload_json = json.dumps({"input": json_safe_authz_input})
+            logger.debug(f"OPA Request JSON payload: {payload_json}")
+        except Exception as json_err:
+            logger.error(f"Error serializing OPA request payload: {json_err}")
 
         async with httpx.AsyncClient() as client:
             try:
@@ -236,20 +325,35 @@ async def authorizeAPIRequest(
                 result = response.json()
                 logger.debug(f"Parsed OPA response: {result}")
 
-                if not result.get("result", {}).get("allow", False):
+                # 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,
+                        detail="Authorization service error: OPA response format unexpected"
+                    )
+
+                # Extract key fields from result with better default handling
+                allow = opa_decision.get("allow", False)
+
+                # Handle authorization denial
+                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": result.get("result", {})
+                            "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
                         }
                     )
 
-                # Extract credit check information from the OPA response
-                credit_check = result.get("result", {}).get("credit_check", {})
-
             except httpx.RequestError as e:
                 logger.error(f"Failed to connect to OPA: {str(e)}")
                 raise ServiceError(
@@ -267,9 +371,7 @@ async def authorizeAPIRequest(
             "used_cached_status": cache_used,
             "required_fresh_status": force_fresh,
             "status_retrieved_at": datetime.now(timezone.utc).isoformat(),
-            "credit_check": credit_check,
-            "allow_all_fields": result.get("result", {}).get("allow_all_fields", False),
-            "allowed_fields": result.get("result", {}).get("allowed_fields", [])
+            "opa_decision": opa_decision
         }
 
     except (AuthorizationError, ResourceNotFoundError):

ipulse_shared_core_ftredge/models/base_data_model.py

@@ -1,4 +1,5 @@
 from datetime import datetime, timezone
+from typing import Any
 from typing import ClassVar
 from pydantic import BaseModel, Field, ConfigDict, field_validator
 import dateutil.parser
@@ -32,10 +33,23 @@ class BaseDataModel(BaseModel):
 
     @field_validator('created_at', 'updated_at', mode='before')
     @classmethod
-    def parse_datetime(cls, v: any) -> datetime:
-        if isinstance(v, datetime):
-            return v
-        try:
-            return dateutil.parser.isoparse(v)
-        except (TypeError, ValueError) as e:
-            raise ValueError(f"Invalid datetime format: {e}")
+    def parse_datetime(cls, v: Any) -> datetime:
+        if isinstance(v, datetime): # If Firestore already gave a datetime object
+            return v # Just use it, no parsing needed
+        if isinstance(v, str): # If it's a string (e.g. from an API request, not Firestore direct)
+            try:
+                return dateutil.parser.isoparse(v)
+            except (TypeError, ValueError) as e:
+                raise ValueError(f"Invalid datetime string format: {v} - {e}")
+        # Firestore might send google.api_core.datetime_helpers.DatetimeWithNanoseconds
+        # which is a subclass of datetime.datetime, so isinstance(v, datetime) should catch it.
+        # If for some reason it's a different type not caught by isinstance(v, datetime)
+        # but has isoformat(), perhaps try that, but it's unlikely with current Firestore client.
+        # For example, if v is some custom timestamp object from an older library:
+        if hasattr(v, 'isoformat'): # Fallback for unknown datetime-like objects
+             try:
+                 return dateutil.parser.isoparse(v.isoformat())
+             except Exception as e:
+                 raise ValueError(f"Could not parse datetime-like object: {v} - {e}")
+
+        raise ValueError(f"Unsupported type for datetime parsing: {type(v)} value: {v}")

ipulse_shared_core_ftredge/models/user_status.py

@@ -51,6 +51,10 @@ class UserStatus(BaseDataModel):
     DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Subject.USER.name))
     OBJ_REF: ClassVar[str] = "userstatus"
 
+    # Centralized collection name and document ID prefix
+    COLLECTION_NAME: ClassVar[str] = "papp_core_user_userstatuss"
+
+
     # System-managed fields
     schema_version: float = Field(
         default=VERSION,

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/base_firestore_service.py

@@ -1,6 +1,7 @@
 """ Base class for Firestore services with common CRUD operations """
-from typing import Dict, Any, List, TypeVar, Generic
+from typing import Dict, Any, List, TypeVar, Generic, Optional
 import logging
+import time
 from datetime import datetime, timezone
 from pydantic import BaseModel
 from google.cloud import firestore
@@ -11,11 +12,20 @@ T = TypeVar('T', bound=BaseModel)
 class BaseFirestoreService(Generic[T]):
     """Base class for Firestore services with common CRUD operations"""
 
-    def __init__(self, db: firestore.Client, collection_name: str, resource_type: str, logger: logging.Logger):
+    def __init__(
+        self,
+        db: firestore.Client,
+        collection_name: str,
+        resource_type: str,
+        logger: logging.Logger,
+        timeout: float = 15.0  # Default to 15 seconds, but allow override
+    ):
         self.db = db
         self.collection_name = collection_name
         self.resource_type = resource_type
         self.logger = logger
+        self.timeout = timeout  # Store the timeout as an instance attribute
+        self.logger.info(f"Initialized {self.resource_type} service with timeout={timeout}s")
 
     async def create_document(self, doc_id: str, data: T, creator_uid: str) -> Dict[str, Any]:
         """Standard create method with audit fields"""
@@ -32,7 +42,8 @@ class BaseFirestoreService(Generic[T]):
             })
 
             doc_ref = self.db.collection(self.collection_name).document(doc_id)
-            doc_ref.set(doc_data)
+            # Apply timeout to the set operation
+            doc_ref.set(doc_data, timeout=self.timeout)
 
             self.logger.info(f"Created {self.resource_type}: {doc_id}")
             return doc_data
@@ -66,7 +77,8 @@ class BaseFirestoreService(Generic[T]):
                 batch.set(doc_ref, doc_data)
                 created_docs.append(doc_data)
 
-            batch.commit()
+            # Apply timeout to the commit operation
+            batch.commit(timeout=self.timeout)
             self.logger.info(f"Created {len(documents)} {self.resource_type}s in batch")
             return created_docs
 
@@ -81,24 +93,48 @@ class BaseFirestoreService(Generic[T]):
 
     async def get_document(self, doc_id: str) -> Dict[str, Any]:
         """Get a document by ID with standardized error handling"""
-        doc_ref = self.db.collection(self.collection_name).document(doc_id)
-        doc = doc_ref.get()
+        self.logger.debug(f"Getting {self.resource_type} document: {doc_id} with timeout={self.timeout}s")
+        start_time = time.time()
 
-        if not doc.exists:
-            raise ResourceNotFoundError(
+        try:
+            doc_ref = self.db.collection(self.collection_name).document(doc_id)
+
+            # Apply timeout to the get operation
+            doc = doc_ref.get(timeout=self.timeout)
+
+            elapsed = (time.time() - start_time) * 1000
+            self.logger.debug(f"Firestore get for {doc_id} completed in {elapsed:.2f}ms")
+
+            if not doc.exists:
+                self.logger.warning(f"Document {doc_id} not found in {self.collection_name}")
+                raise ResourceNotFoundError(
+                    resource_type=self.resource_type,
+                    resource_id=doc_id,
+                    additional_info={"collection": self.collection_name}
+                )
+
+            return doc.to_dict()
+
+        except ResourceNotFoundError:
+            raise
+        except Exception as e:
+            elapsed = (time.time() - start_time) * 1000
+            self.logger.error(f"Error getting document {doc_id} after {elapsed:.2f}ms: {str(e)}", exc_info=True)
+            raise ServiceError(
+                operation=f"retrieving {self.resource_type}",
+                error=e,
                 resource_type=self.resource_type,
                 resource_id=doc_id,
-                additional_info={"collection": self.collection_name}
-            )
-
-        return doc.to_dict()
+                additional_info={"collection": self.collection_name, "timeout": self.timeout}
+            ) from e
 
     async def update_document(self, doc_id: str, update_data: Dict[str, Any], updater_uid: str) -> Dict[str, Any]:
         """Standard update method with validation and audit fields"""
         try:
             doc_ref = self.db.collection(self.collection_name).document(doc_id)
 
-            if not doc_ref.get().exists:
+            # Apply timeout to the get operation
+            if not doc_ref.get(timeout=self.timeout).exists:
                 raise ResourceNotFoundError(
                     resource_type=self.resource_type,
                     resource_id=doc_id,
@@ -113,8 +149,10 @@ class BaseFirestoreService(Generic[T]):
                 'updated_by': updater_uid
             })
 
-            doc_ref.update(valid_fields)
-            return doc_ref.get().to_dict()
+            # Apply timeout to the update operation
+            doc_ref.update(valid_fields, timeout=self.timeout)
+            # Apply timeout to the get operation
+            return doc_ref.get(timeout=self.timeout).to_dict()
 
         except (ResourceNotFoundError, ValidationError):
             raise
@@ -131,13 +169,15 @@ class BaseFirestoreService(Generic[T]):
         """Standard delete method"""
         try:
             doc_ref = self.db.collection(self.collection_name).document(doc_id)
-            if not doc_ref.get().exists:
+            # Apply timeout to the get operation
+            if not doc_ref.get(timeout=self.timeout).exists:
                 raise ResourceNotFoundError(
                     resource_type=self.resource_type,
                     resource_id=doc_id
                 )
 
-            doc_ref.delete()
+            # Apply timeout to the delete operation
+            doc_ref.delete(timeout=self.timeout)
             self.logger.info(f"Deleted {self.resource_type}: {doc_id}")
 
         except ResourceNotFoundError:
@@ -151,6 +191,44 @@ class BaseFirestoreService(Generic[T]):
                 resource_id=doc_id
             ) from e
 
+    # Add query method with timeout
+    async def query_documents(
+        self,
+        filters: Optional[List[tuple]] = None,
+        limit: Optional[int] = None,
+        order_by: Optional[tuple] = None
+    ) -> List[Dict[str, Any]]:
+        """Query documents with filters, limit, and ordering"""
+        try:
+            # Start with the collection reference
+            query = self.db.collection(self.collection_name)
+
+            # Apply filters if provided
+            if filters:
+                for field, op, value in filters:
+                    query = query.where(field=field, op_string=op, value=value)
+
+            # Apply ordering if provided
+            if order_by:
+                field, direction = order_by
+                query = query.order_by(field, direction=direction)
+
+            # Apply limit if provided
+            if limit:
+                query = query.limit(limit)
+
+            # Execute query with timeout
+            docs = query.stream(timeout=self.timeout)
+            return [doc.to_dict() for doc in docs]
+
+        except Exception as e:
+            self.logger.error(f"Error querying {self.resource_type}: {e}", exc_info=True)
+            raise ServiceError(
+                operation=f"querying {self.resource_type}",
+                error=e,
+                resource_type=self.resource_type
+            ) from e
+
     def _validate_update_fields(self, update_data: Dict[str, Any]) -> Dict[str, Any]:
         """Centralized update fields validation"""
         if not isinstance(update_data, dict):

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

@@ -0,0 +1,270 @@
+"""Service for managing credit operations in a generic way."""
+import logging
+from typing import Dict, Any, Optional, Tuple
+from datetime import datetime, timezone
+from google.cloud import firestore
+from ipulse_shared_core_ftredge.services import ServiceError, ResourceNotFoundError, ValidationError
+from ipulse_shared_core_ftredge.models.user_status import UserStatus
+
+# Default Firestore timeout if not provided by the consuming application
+DEFAULT_FIRESTORE_TIMEOUT = 15.0
+
+class CreditService:
+    """
+    Service class for credit operations.
+    Designed to be project-agnostic and directly uses UserStatus model constants.
+    """
+
+    def __init__(
+        self,
+        db: firestore.Client,
+        logger: Optional[logging.Logger] = None,
+        firestore_timeout: float = DEFAULT_FIRESTORE_TIMEOUT
+    ):
+        """
+        Initialize the credit service.
+
+        Args:
+            db: Firestore client.
+            logger: Optional logger instance. Defaults to a new logger for this module.
+            firestore_timeout: Timeout for Firestore operations in seconds.
+        """
+        self.db = db
+        # Use UserStatus constants directly
+        self.users_status_collection_name = UserStatus.COLLECTION_NAME
+        self.user_status_doc_prefix = f"{UserStatus.OBJ_REF}_" # Append underscore to OBJ_REF
+        self.logger = logger or logging.getLogger(__name__)
+        self.timeout = firestore_timeout
+
+        self.logger.info(
+            f"CreditService initialized using UserStatus constants. Collection: {self.users_status_collection_name}, "
+            f"Doc Prefix: {self.user_status_doc_prefix}, Timeout: {self.timeout}s"
+        )
+
+    async def verify_credits(
+        self,
+        user_uid: str,
+        required_credits_for_resource: float,
+        pre_fetched_user_credits: Optional[Dict[str, float]] = None
+    ) -> Tuple[bool, Dict[str, Any]]:
+        """
+        Verify if a user has enough credits for an operation.
+
+        Args:
+            user_uid: The user's UID.
+            required_credits_for_resource: The number of credits required for the operation.
+            pre_fetched_user_credits: Optional dict with pre-fetched credit info.
+                                      (keys: 'sbscrptn_based_insight_credits', 'extra_insight_credits')
+
+        Returns:
+            Tuple of (has_enough_credits, user_status_data) where user_status_data
+            will be a dict with keys 'sbscrptn_based_insight_credits' and 'extra_insight_credits'.
+
+        Raises:
+            ValidationError: If required_credits_for_resource is None (pricing not properly configured).
+        """
+        self.logger.info(
+            f"verify_credits called for user {user_uid}, "
+            f"required_credits={required_credits_for_resource}, "
+            f"pre_fetched_credits={pre_fetched_user_credits}"
+        )
+
+        if required_credits_for_resource is None:
+            self.logger.error(f"Credit cost is None for user {user_uid}, pricing not properly configured")
+            raise ValidationError(
+                resource_type="credit_cost",
+                detail="Credit cost is not configured for this resource",
+                resource_id=None, # Resource ID might not be known here, or could be passed
+                additional_info={"user_uid": user_uid}
+            )
+
+        if required_credits_for_resource <= 0:
+            self.logger.info(f"No credits required for user {user_uid}, bypassing credit verification")
+            return True, {"sbscrptn_based_insight_credits": 0, "extra_insight_credits": 0}
+
+        if pre_fetched_user_credits is not None:
+            self.logger.info(f"Using pre-fetched credit info for user {user_uid}")
+            subscription_credits = pre_fetched_user_credits.get("sbscrptn_based_insight_credits", 0)
+            extra_credits = pre_fetched_user_credits.get("extra_insight_credits", 0)
+            total_credits = subscription_credits + extra_credits
+
+            self.logger.info(
+                f"User {user_uid} has {total_credits} total pre-fetched credits "
+                f"(subscription: {subscription_credits}, extra: {extra_credits})"
+            )
+
+            userstatus_data_to_return = {
+                "sbscrptn_based_insight_credits": subscription_credits,
+                "extra_insight_credits": extra_credits
+            }
+
+            has_enough_credits = total_credits >= required_credits_for_resource
+            return has_enough_credits, userstatus_data_to_return
+
+        try:
+            self.logger.info(
+                f"Fetching user status from Firestore for user {user_uid} (collection: {self.users_status_collection_name})"
+            )
+            full_userstatus_doc = await self._get_userstatus(user_uid)
+
+            subscription_credits = full_userstatus_doc.get("sbscrptn_based_insight_credits", 0)
+            extra_credits = full_userstatus_doc.get("extra_insight_credits", 0)
+            total_credits = subscription_credits + extra_credits
+
+            self.logger.info(
+                f"User {user_uid} has {total_credits} total credits from Firestore "
+                f"(subscription: {subscription_credits}, extra: {extra_credits})"
+            )
+
+            has_enough_credits = total_credits >= required_credits_for_resource
+
+            userstatus_data_to_return = {
+                "sbscrptn_based_insight_credits": subscription_credits,
+                "extra_insight_credits": extra_credits
+            }
+
+            return has_enough_credits, userstatus_data_to_return
+
+        except ResourceNotFoundError:
+            self.logger.warning(f"User status not found for {user_uid} in {self.users_status_collection_name}. Assuming no credits.")
+            return False, {"sbscrptn_based_insight_credits": 0, "extra_insight_credits": 0}
+        except Exception as e:
+            self.logger.error(f"Error verifying credits for user {user_uid}: {str(e)}")
+            raise ServiceError(
+                operation="verifying credits",
+                error=e,
+                resource_type="user_credits",
+                resource_id=user_uid,
+                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:
+        """
+        Charge a user's credits for an operation.
+
+        Args:
+            user_uid: The user's UID.
+            credits_to_charge: The number of credits to charge.
+            operation_details: Details about the operation (for logging).
+
+        Returns:
+            Whether the charging was successful.
+
+        Raises:
+            ValidationError: If credits_to_charge is None (pricing not properly configured).
+        """
+        if credits_to_charge is None:
+            self.logger.error(f"Credit cost is None for user {user_uid} (charge_credits), pricing not properly configured")
+            raise ValidationError(
+                resource_type="credit_cost",
+                detail="Credit cost is not configured for this resource (charge_credits)",
+                resource_id=None,
+                additional_info={"user_uid": user_uid}
+            )
+
+        if credits_to_charge == 0:
+            self.logger.info(f"No credits to charge for user {user_uid}, operation: {operation_details}")
+            return True
+
+        try:
+            userstatus_id = f"{self.user_status_doc_prefix}{user_uid}"
+            user_ref = self.db.collection(self.users_status_collection_name).document(userstatus_id)
+
+            transaction = self.db.transaction()
+
+            @firestore.transactional
+            def update_credits_transaction(transaction_obj, current_user_ref):
+                user_doc = current_user_ref.get(transaction=transaction_obj)
+                if not user_doc.exists:
+                    self.logger.warning(
+                        f"Cannot charge credits - user status not found for {user_uid} in {self.users_status_collection_name}"
+                    )
+                    return False
+
+                userstatus = user_doc.to_dict()
+
+                subscription_credits = userstatus.get("sbscrptn_based_insight_credits", 0)
+                extra_credits = userstatus.get("extra_insight_credits", 0)
+                total_credits = subscription_credits + extra_credits
+
+                if total_credits < credits_to_charge:
+                    self.logger.warning(
+                        f"Insufficient credits for user {user_uid} during transaction: "
+                        f"has {total_credits}, needs {credits_to_charge}"
+                    )
+                    return False
+
+                subscription_credits_to_charge = min(subscription_credits, credits_to_charge)
+                extra_credits_to_charge = credits_to_charge - subscription_credits_to_charge
+
+                update_data = {
+                    "updated_at": datetime.now(timezone.utc).isoformat(),
+                    "updated_by": "credit_service" # Consider making this configurable or more generic
+                }
+
+                if subscription_credits_to_charge > 0:
+                    update_data["sbscrptn_based_insight_credits"] = firestore.Increment(-subscription_credits_to_charge)
+                    update_data["sbscrptn_based_insight_credits_updtd_on"] = datetime.now(timezone.utc).isoformat()
+
+                if extra_credits_to_charge > 0:
+                    update_data["extra_insight_credits"] = firestore.Increment(-extra_credits_to_charge)
+                    update_data["extra_insight_credits_updtd_on"] = datetime.now(timezone.utc).isoformat()
+
+                transaction_obj.update(current_user_ref, update_data)
+                return True
+
+            success = update_credits_transaction(transaction, user_ref)
+
+            if success:
+                self.logger.info(
+                    f"Successfully charged {credits_to_charge} credits for user {user_uid}. "
+                    f"Operation: {operation_details}"
+                )
+            else:
+                self.logger.warning(
+                    f"Failed to charge {credits_to_charge} credits for user {user_uid} (transaction outcome). "
+                    f"Operation: {operation_details}"
+                )
+
+            return success
+
+        except Exception as e:
+            self.logger.error(f"Error charging credits for user {user_uid}: {str(e)}")
+            raise ServiceError(
+                operation="charging credits",
+                error=e,
+                resource_type="user_credits",
+                resource_id=user_uid,
+                additional_info={"credits_to_charge": credits_to_charge}
+            ) from e
+
+    async def _get_userstatus(self, user_uid: str) -> Dict[str, Any]:
+        """Get a user's status document."""
+        try:
+            userstatus_id = f"{self.user_status_doc_prefix}{user_uid}"
+            doc_ref = self.db.collection(self.users_status_collection_name).document(userstatus_id)
+
+            # Using the timeout value set during initialization
+            doc = await doc_ref.get(timeout=self.timeout)
+
+            if not doc.exists:
+                raise ResourceNotFoundError(
+                    resource_type="user_status", # Generic resource type
+                    resource_id=userstatus_id,
+                    additional_info={"collection": self.users_status_collection_name}
+                )
+
+            return doc.to_dict()
+
+        except ResourceNotFoundError:
+            raise
+        except Exception as e: # Catch generic Exception to handle potential timeout errors from Firestore client
+            self.logger.error(f"Error getting user status for {user_uid} from {self.users_status_collection_name}: {str(e)}")
+            raise ServiceError(
+                operation="getting user status",
+                error=e,
+                resource_type="user_status",
+                resource_id=user_uid,
+                additional_info={"collection": self.users_status_collection_name}
+            ) from e
+

{ipulse_shared_core_ftredge-11.1.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: 11.1.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
@@ -13,7 +13,7 @@ Requires-Dist: pydantic[email]~=2.5
 Requires-Dist: python-dateutil~=2.8
 Requires-Dist: fastapi~=0.115.8
 Requires-Dist: pytest
-Requires-Dist: ipulse_shared_base_ftredge>=6.4.1
+Requires-Dist: ipulse_shared_base_ftredge==6.5.1
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page

{ipulse_shared_core_ftredge-11.1.1.dist-info → ipulse_shared_core_ftredge-13.0.1.dist-info}/RECORD

@@ -1,28 +1,32 @@
-ipulse_shared_core_ftredge/__init__.py,sha256=j9xKQsFCG-9A7PSZMORVvi96RrBMo4IRo1uUs7Rr3N8,487
+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
-ipulse_shared_core_ftredge/dependencies/authz_for_apis.py,sha256=aP98NecFL_7URD7AiLEo5INBd_9ciMFFXXYD_6verC8,11813
+ipulse_shared_core_ftredge/dependencies/authz_for_apis.py,sha256=e_UZ_jY1xhC3XX8r3xffb06t6buLfXT2SQf46-DXVoo,15977
 ipulse_shared_core_ftredge/dependencies/firestore_client.py,sha256=VbTb121nsc9EZPd1RDEsHBLW5pIiVw6Wdo2JFL4afMg,714
 ipulse_shared_core_ftredge/models/__init__.py,sha256=cf2P65BXRQoOrcuvlbmT6yW50U7wyj8ZNvHTuTvlETo,344
 ipulse_shared_core_ftredge/models/base_api_response.py,sha256=WOHxtv_FEk5MKzXORgIsp-sKP4O5WJCgrJMI6tYph4U,1880
-ipulse_shared_core_ftredge/models/base_data_model.py,sha256=SMyU794JFUJz04q6dZYvkT36DMl1GX0audJoN7igHM0,1450
+ipulse_shared_core_ftredge/models/base_data_model.py,sha256=frvUDiKnjMGPXIQX_qdpNgGcm3SauCth6GiRuabmD5s,2509
 ipulse_shared_core_ftredge/models/organization_profile.py,sha256=OnjsSVcp_LSB65F9Tl9udwNgqMg7gjSpv38eArpVXPc,3668
 ipulse_shared_core_ftredge/models/subscription.py,sha256=bu6BtyDQ4jDkK3PLY97dZ_A3cmjzZahTkuaFOFybdxI,6892
 ipulse_shared_core_ftredge/models/user_auth.py,sha256=YgCeK0uJ-JOkPavwzogl4wGC3RpA8PVfl-5MPS4Kxhk,432
 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=zLWorgW4EIp6VgMY_LAaboCAnXdrgmNch5e7RMX1bug,23535
-ipulse_shared_core_ftredge/services/__init__.py,sha256=Ji9AhDy1HVwcJjYMdyfggerxa0b8e78JAnCQ-o-_sSA,304
-ipulse_shared_core_ftredge/services/base_firestore_service.py,sha256=VtJ7iffCFR4hpGHf987fH0LiprPtHWAb7KlYsARZ0Ik,6570
+ipulse_shared_core_ftredge/models/user_status.py,sha256=rAx8l5GrB8TN7RvZ1eIMskphRxdYqO1OZ8NnaIxUUW8,23660
+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/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-11.1.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
-ipulse_shared_core_ftredge-11.1.1.dist-info/METADATA,sha256=cRat1rfIJh81_UGsuab_UOB5_XEhK-YgappY1WmRum4,803
-ipulse_shared_core_ftredge-11.1.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-ipulse_shared_core_ftredge-11.1.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
-ipulse_shared_core_ftredge-11.1.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,,

{ipulse_shared_core_ftredge-11.1.1.dist-info → ipulse_shared_core_ftredge-13.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any