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

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

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

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

{ipulse_shared_core_ftredge-14.0.1 → ipulse_shared_core_ftredge-16.0.1}/src/ipulse_shared_core_ftredge/cache/shared_cache.py

@@ -39,7 +39,7 @@ class SharedCache(Generic[T]):
         self._timestamps: Dict[str, float] = {}
 
         # Thread-safe attributes
-        self.lock = threading.Lock()
+        self.lock = threading.RLock()  # Changed from threading.Lock()
         self.hits = 0
         self.misses = 0
         self.sets = 0

{ipulse_shared_core_ftredge-14.0.1 → ipulse_shared_core_ftredge-16.0.1}/src/ipulse_shared_core_ftredge/services/__init__.py

@@ -7,8 +7,12 @@ 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 ipulse_shared_core_ftredge.services.charging_processors import (ChargingProcessor)
+from ipulse_shared_core_ftredge.services.charging_service import ChargingService
+
 __all__ = [
    'AuthorizationError', 'BaseServiceException', 'ServiceError', 'ValidationError',
     'ResourceNotFoundError',  'BaseFirestoreService',
-    'CacheAwareFirestoreService'
+    'CacheAwareFirestoreService', 'Servicemon',
+    'ChargingProcessor'
 ]

ipulse_shared_core_ftredge-16.0.1/src/ipulse_shared_core_ftredge/services/charging_processors.py

@@ -0,0 +1,350 @@
+"""Reusable credit checking and charging utilities for services."""
+import os
+from typing import Dict, Any, List, Optional, Callable, Awaitable, TypeVar
+from ipulse_shared_core_ftredge.services.charging_service import ChargingService, ValidationError
+import logging
+
+T = TypeVar('T')
+
+class ChargingProcessor:
+    """Handles credit checking and charging for both single item and batch access."""
+
+    def __init__(self, charging_service: ChargingService, logger: logging.Logger):
+        self.charging_service = charging_service
+        self.logger = logger
+
+    async def process_single_item_charging(
+        self,
+        user_uid: str,
+        item_id: str,
+        get_cost_func: Callable[[], Awaitable[Optional[float]]],
+        pre_fetched_credits: Optional[Dict[str, float]] = None,
+        operation_description: str = "Resource access"
+    ) -> Dict[str, Any]:
+        """
+        Process credit check and charging for a single item.
+
+        Args:
+            user_uid: User's UID
+            item_id: ID of the item being accessed
+            get_cost_func: Async function that returns the cost for the item
+            pre_fetched_credits: Optional pre-fetched credit information
+            operation_description: Description for the charging operation
+
+        Returns:
+            Dict with keys:
+            - access_granted: bool
+            - charge_successful: bool (only meaningful if access_granted is True)
+            - cost: Optional[float]
+            - reason: str (explanation if access denied)
+            - updated_user_credits: Optional[Dict] (credits after charging, if applicable)
+        """
+        self.logger.info(f"Processing single item credit check for user {user_uid}, item {item_id}")
+        updated_user_credits = None # Initialize
+
+        try:
+            # Get the credit cost for this item
+            credit_cost = await get_cost_func()
+
+            # If item is free or cost not configured, allow access
+            if credit_cost is None or credit_cost <= 0:
+                if credit_cost is None:
+                    self.logger.info(f"Item {item_id} has no configured credit cost, treating as free.")
+
+                # For free items, provide current credits if available
+                if pre_fetched_credits:
+                    updated_user_credits = pre_fetched_credits
+                elif self.charging_service: # Attempt to get current credits if not pre-fetched
+                    try:
+                        _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, None)
+                        updated_user_credits = current_user_credits_from_verify
+                    except Exception: # pylint: disable=broad-except
+                        self.logger.warning(f"Could not fetch current credits for user {user_uid} for free item.")
+
+                return {
+                    'access_granted': True,
+                    'charge_successful': True,  # No charge needed
+                    'cost': credit_cost if credit_cost is not None else 0.0,
+                    'reason': 'free_item',
+                    'updated_user_credits': updated_user_credits
+                }
+
+            # Check for debug mode bypass
+            if os.getenv("BYPASS_CREDIT_CHECK", "").lower() == "true":
+                self.logger.info(f"Bypassing credit check for item {item_id} due to debug mode")
+                # Similar to free items, provide current credits if available
+                if pre_fetched_credits:
+                    updated_user_credits = pre_fetched_credits
+                elif self.charging_service:
+                    try:
+                        _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, None)
+                        updated_user_credits = current_user_credits_from_verify
+                    except Exception: # pylint: disable=broad-except
+                        self.logger.warning(f"Could not fetch current credits for user {user_uid} during debug bypass.")
+                return {
+                    'access_granted': True,
+                    'charge_successful': True,
+                    'cost': credit_cost,
+                    'reason': 'debug_bypass',
+                    'updated_user_credits': updated_user_credits
+                }
+
+            # Verify credit service is available
+            if not self.charging_service:
+                self.logger.error("ChargingService not initialized.")
+                return {
+                    'access_granted': False,
+                    'charge_successful': False,
+                    'cost': credit_cost,
+                    'reason': 'service_unavailable',
+                    'updated_user_credits': None
+                }
+
+            # Verify user has enough credits
+            has_credits, current_user_credits_from_verify = await self.charging_service.verify_credits(
+                user_uid,
+                credit_cost,
+                pre_fetched_user_credits=pre_fetched_credits
+            )
+            # Store current credits from verification, might be used if charge fails
+            updated_user_credits = current_user_credits_from_verify
+
+
+            if not has_credits:
+                self.logger.warning(f"User {user_uid} has insufficient credits for item {item_id} (cost: {credit_cost})")
+                return {
+                    'access_granted': False,
+                    'charge_successful': False,
+                    'cost': credit_cost,
+                    'reason': 'insufficient_credits',
+                    'updated_user_credits': updated_user_credits # Return credits state at time of failure
+                }
+
+            # Charge the user - this now returns (bool, Optional[Dict])
+            charged, calculated_updated_credits = await self.charging_service.charge_credits_transaction(
+                user_uid,
+                credit_cost,
+                operation_description
+            )
+
+            # Use the credits returned by charge_credits if successful
+            if calculated_updated_credits is not None:
+                updated_user_credits = calculated_updated_credits
+
+
+            return {
+                'access_granted': True, # Access granted because verify_credits passed
+                'charge_successful': charged,
+                'cost': credit_cost,
+                'reason': 'charged' if charged else 'charge_failed',
+                'updated_user_credits': updated_user_credits
+            }
+
+        except ValidationError as ve:
+            self.logger.error(f"Validation error for item {item_id}, user {user_uid}: {str(ve)}")
+            # Try to get current credits to return
+            if self.charging_service:
+                try:
+                    _, updated_user_credits = await self.charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
+                except Exception: # pylint: disable=broad-except
+                    pass # Keep updated_user_credits as None
+            ve.additional_info = ve.additional_info or {}
+            ve.additional_info['updated_user_credits'] = updated_user_credits
+            raise
+        except Exception as e:
+            self.logger.error(f"Unexpected error during credit processing for item {item_id}, user {user_uid}: {str(e)}", exc_info=True)
+            # Try to get current credits to return
+            current_user_credits_on_error = None
+            if self.charging_service:
+                try:
+                    _, current_user_credits_on_error = await self.charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
+                except Exception: # pylint: disable=broad-except
+                    pass
+            return {
+                'access_granted': False,
+                'charge_successful': False,
+                'cost': None, # Cost might not be determined if error was early
+                'reason': f'error: {str(e)}',
+                'updated_user_credits': current_user_credits_on_error
+            }
+    async def process_batch_items_charging(
+        self,
+        user_uid: str,
+        items: List[Dict[str, Any]],
+        pre_fetched_credits: Optional[Dict[str, float]] = None,
+        operation_description: str = "Batch resource access"
+    ) -> Dict[str, Any]:
+        """
+        Process credit check and charging for a batch of items.
+
+        Args:
+            user_uid: User's UID
+            items: List of dicts with keys: 'id', 'data', 'get_cost_func'
+            pre_fetched_credits: Optional pre-fetched credit information
+            operation_description: Description for the charging operation
+
+        Returns:
+            Dict with keys:
+            - accessible_items: List[Dict] (items user can access)
+            - charge_successful: bool
+            - total_cost: float
+            - paid_items_count: int
+            - free_items_count: int
+            - updated_user_credits: Optional[Dict] (credits after charging, if applicable)
+        """
+        self.logger.info(f"Processing batch credit check for user {user_uid}, {len(items)} items")
+        updated_user_credits = None # Initialize
+
+        if not items:
+            return {
+                'accessible_items': [],
+                'charge_successful': True,
+                'total_cost': 0.0,
+                'paid_items_count': 0,
+                'free_items_count': 0,
+                'updated_user_credits': None
+            }
+
+        # Separate free and paid items
+        free_items = []
+        paid_items = []
+        total_cost = 0.0
+
+        for item in items:
+            try:
+                cost = await item['get_cost_func']()
+                if cost is None or cost <= 0:
+                    free_items.append(item)
+                else:
+                    paid_items.append(item)
+                    total_cost += cost
+            except Exception as cost_err:
+                self.logger.error(f"Error getting cost for item {item.get('id', 'unknown')}: {cost_err}")
+                free_items.append(item)
+
+        self.logger.info(f"User {user_uid}: {len(free_items)} free items, {len(paid_items)} paid items (total cost: {total_cost})")
+
+        # If no paid items, return all free items
+        if not paid_items:
+            if pre_fetched_credits:
+                updated_user_credits = pre_fetched_credits
+            elif self.charging_service:
+                try:
+                    _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, None)
+                    updated_user_credits = current_user_credits_from_verify
+
+                except Exception: # pylint: disable=broad-except
+                    self.logger.warning(f"Could not fetch current credits for user {user_uid} for free batch.")
+
+            return {
+                'accessible_items': free_items,
+                'charge_successful': True,
+                'total_cost': 0.0,
+                'paid_items_count': 0,
+                'free_items_count': len(free_items),
+                'updated_user_credits': updated_user_credits
+            }
+
+        # Check for debug mode bypass
+        if os.getenv("BYPASS_CREDIT_CHECK", "").lower() == "true":
+            self.logger.info(f"Bypassing credit check for {len(paid_items)} paid items due to debug mode")
+            if pre_fetched_credits:
+                updated_user_credits = pre_fetched_credits
+            elif self.charging_service:
+                try:
+                    _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, None)
+                    updated_user_credits = current_user_credits_from_verify
+                except Exception: # pylint: disable=broad-except
+                    self.logger.warning(f"Could not fetch current credits for user {user_uid} during debug bypass for batch.")
+
+            return {
+                'accessible_items': free_items + paid_items,
+                'charge_successful': True,
+                'total_cost': total_cost,
+                'paid_items_count': len(paid_items),
+                'free_items_count': len(free_items),
+                'updated_user_credits': updated_user_credits
+            }
+
+        # Verify credit service is available
+        if not self.charging_service:
+            self.logger.error("ChargingService not initialized for batch processing.")
+            return {
+                'accessible_items': free_items,
+                'charge_successful': False,
+                'total_cost': total_cost,
+                'paid_items_count': len(paid_items),
+                'free_items_count': len(free_items),
+                'updated_user_credits': None
+            }
+
+        try:
+            # Verify user has enough credits for total cost
+            has_credits, current_user_credits_from_verify = await self.charging_service.verify_credits(
+                user_uid,
+                total_cost,
+                pre_fetched_user_credits=pre_fetched_credits
+            )
+            updated_user_credits = current_user_credits_from_verify
+
+
+            if not has_credits:
+                self.logger.warning(f"User {user_uid} has insufficient credits for batch (cost: {total_cost}). Returning free items only.")
+                return {
+                    'accessible_items': free_items,
+                    'charge_successful': False,
+                    'total_cost': total_cost,
+                    'paid_items_count': len(paid_items),
+                    'free_items_count': len(free_items),
+                    'updated_user_credits': updated_user_credits # Return credits state at time of failure
+                }
+
+            # Charge the user for all paid items
+            charged, calculated_updated_credits = await self.charging_service.charge_credits_transaction(
+                user_uid,
+                total_cost,
+                f"{operation_description} ({len(paid_items)} items, total cost: {total_cost})"
+            )
+
+            if calculated_updated_credits is not None:
+                updated_user_credits = calculated_updated_credits
+
+
+            # Return all items (free + paid) since credits were verified (even if charge failed post-verification)
+            return {
+                'accessible_items': free_items + paid_items,
+                'charge_successful': charged,
+                'total_cost': total_cost,
+                'paid_items_count': len(paid_items),
+                'free_items_count': len(free_items),
+                'updated_user_credits': updated_user_credits
+            }
+
+        except ValidationError as ve:
+            self.logger.error(f"Validation error during batch credit check for user {user_uid}: {str(ve)}")
+            if self.charging_service:
+                try:
+                    _, current_user_credits_from_verify = await self.charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
+                    updated_user_credits = current_user_credits_from_verify
+                except Exception: # pylint: disable=broad-except
+                    pass
+            ve.additional_info = ve.additional_info or {}
+            ve.additional_info['updated_user_credits'] = updated_user_credits
+            raise
+        except Exception as e:
+            self.logger.error(f"Unexpected error during batch credit check for user {user_uid}: {str(e)}", exc_info=True)
+            current_credits_on_error = None
+            if self.charging_service:
+                try:
+                    _, current_credits_on_error = await self.charging_service.verify_credits(user_uid, 0, pre_fetched_credits)
+                    updated_user_credits = current_credits_on_error
+                except Exception: # pylint: disable=broad-except
+                    pass
+            return {
+                'accessible_items': free_items, # Only free items if error
+                'charge_successful': False,
+                'total_cost': total_cost, # This is the cost of paid items that were attempted
+                'paid_items_count': len(paid_items),
+                'free_items_count': len(free_items),
+                'updated_user_credits': updated_user_credits
+            }

ipulse_shared_core_ftredge-14.0.1/src/ipulse_shared_core_ftredge/services/credit_service.py → ipulse_shared_core_ftredge-16.0.1/src/ipulse_shared_core_ftredge/services/charging_service.py

@@ -9,9 +9,9 @@ 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:
+class ChargingService:
     """
-    Service class for credit operations.
+    Service class for charging operations.
     Designed to be project-agnostic and directly uses UserStatus model constants.
     """
 
@@ -22,7 +22,7 @@ class CreditService:
         firestore_timeout: float = DEFAULT_FIRESTORE_TIMEOUT
     ):
         """
-        Initialize the credit service.
+        Initialize the charging service.
 
         Args:
             db: Firestore client.
@@ -37,7 +37,7 @@ class CreditService:
         self.timeout = firestore_timeout
 
         self.logger.info(
-            f"CreditService initialized using UserStatus constants. Collection: {self.users_status_collection_name}, "
+            f"ChargingService initialized using UserStatus constants. Collection: {self.users_status_collection_name}, "
             f"Doc Prefix: {self.user_status_doc_prefix}, Timeout: {self.timeout}s"
         )
 
@@ -93,13 +93,13 @@ class CreditService:
                 f"(subscription: {subscription_credits}, extra: {extra_credits})"
             )
 
-            userstatus_data_to_return = {
+            user_credits = {
                 "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
+            return has_enough_credits, user_credits
 
         try:
             self.logger.info(
@@ -118,12 +118,12 @@ class CreditService:
 
             has_enough_credits = total_credits >= required_credits_for_resource
 
-            userstatus_data_to_return = {
+            user_credits = {
                 "sbscrptn_based_insight_credits": subscription_credits,
                 "extra_insight_credits": extra_credits
             }
 
-            return has_enough_credits, userstatus_data_to_return
+            return has_enough_credits, user_credits
 
         except ResourceNotFoundError:
             self.logger.warning(f"User status not found for {user_uid} in {self.users_status_collection_name}. Assuming no credits.")
@@ -138,7 +138,7 @@ class CreditService:
                 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:
+    async def charge_credits_transaction(self, user_uid: str, credits_to_charge: Optional[float], operation_details: str) -> Tuple[bool, Optional[Dict[str, float]]]:
         """
         Charge a user's credits for an operation.
 
@@ -148,7 +148,9 @@ class CreditService:
             operation_details: Details about the operation (for logging).
 
         Returns:
-            Whether the charging was successful.
+            Tuple of (success_status: bool, updated_credits: Optional[Dict[str, float]])
+            where updated_credits contains 'sbscrptn_based_insight_credits' and 'extra_insight_credits'
+            if charging was successful.
 
         Raises:
             ValidationError: If credits_to_charge is None (pricing not properly configured).
@@ -164,7 +166,12 @@ class CreditService:
 
         if credits_to_charge == 0:
             self.logger.info(f"No credits to charge for user {user_uid}, operation: {operation_details}")
-            return True
+            # If no charge, current credits are unchanged. Fetch them if needed by caller.
+            # For simplicity here, returning None for updated_credits as no transaction occurred.
+            # The caller (CreditProcessor) will handle fetching if it needs the current state.
+            # Alternatively, we could fetch here, but it's cleaner if CreditProcessor handles it.
+            return True, None
+
 
         try:
             userstatus_id = f"{self.user_status_doc_prefix}{user_uid}"
@@ -173,60 +180,89 @@ class CreditService:
             transaction = self.db.transaction()
 
             @firestore.transactional
-            def update_credits_transaction(transaction_obj, current_user_ref):
+            def update_credits_transaction(transaction_obj, current_user_ref) -> Tuple[bool, Optional[Dict[str, float]]]:
                 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
+                    return False, None
 
                 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
+                current_subscription_credits = userstatus.get("sbscrptn_based_insight_credits", 0.0)
+                current_extra_credits = userstatus.get("extra_insight_credits", 0.0)
+                total_available_credits = current_subscription_credits + current_extra_credits
 
-                if total_credits < credits_to_charge:
+                if total_available_credits < credits_to_charge:
                     self.logger.warning(
                         f"Insufficient credits for user {user_uid} during transaction: "
-                        f"has {total_credits}, needs {credits_to_charge}"
+                        f"has {total_available_credits}, needs {credits_to_charge}"
+                    )
+                    # Return current credits if charge fails due to insufficient funds
+                    return False, {
+                        "sbscrptn_based_insight_credits": current_subscription_credits,
+                        "extra_insight_credits": current_extra_credits
+                    }
+
+                # Calculate how much to deduct from each type of credit
+                subscription_credits_deducted = min(current_subscription_credits, credits_to_charge)
+                remaining_charge = credits_to_charge - subscription_credits_deducted
+                extra_credits_deducted = min(current_extra_credits, remaining_charge)
+
+                # This check should ideally not be needed if total_available_credits was sufficient,
+                # but as a safeguard:
+                if (subscription_credits_deducted + extra_credits_deducted) < credits_to_charge:
+                    self.logger.error(
+                        f"Credit calculation error for user {user_uid}. "
+                        f"Required: {credits_to_charge}, Calculated deduction: {subscription_credits_deducted + extra_credits_deducted}"
                     )
-                    return False
+                    # This case implies a logic flaw or race condition if not for the initial check.
+                    # Return current credits as charge effectively failed.
+                    return False, {
+                        "sbscrptn_based_insight_credits": current_subscription_credits,
+                        "extra_insight_credits": current_extra_credits
+                    }
+
 
-                subscription_credits_to_charge = min(subscription_credits, credits_to_charge)
-                extra_credits_to_charge = credits_to_charge - subscription_credits_to_charge
+                new_subscription_credits = current_subscription_credits - subscription_credits_deducted
+                new_extra_credits = current_extra_credits - extra_credits_deducted
 
-                update_data = {
+                update_data: Dict[str, Any] = {
                     "updated_at": datetime.now(timezone.utc).isoformat(),
-                    "updated_by": "credit_service" # Consider making this configurable or more generic
+                    "updated_by": "charging_service__charge_credits_transaction"  # Static identifier for this operation
                 }
 
-                if subscription_credits_to_charge > 0:
-                    update_data["sbscrptn_based_insight_credits"] = firestore.Increment(-subscription_credits_to_charge)
+                if subscription_credits_deducted > 0:
+                    update_data["sbscrptn_based_insight_credits"] = firestore.Increment(-subscription_credits_deducted)
                     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)
+                if extra_credits_deducted > 0:
+                    update_data["extra_insight_credits"] = firestore.Increment(-extra_credits_deducted)
                     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)
+                # Return success and the calculated new credit balances
+                return True, {
+                    "sbscrptn_based_insight_credits": new_subscription_credits,
+                    "extra_insight_credits": new_extra_credits
+                }
+
+            success, updated_credits_dict = 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}"
+                    f"Operation: {operation_details}. New balances: {updated_credits_dict}"
                 )
             else:
                 self.logger.warning(
                     f"Failed to charge {credits_to_charge} credits for user {user_uid} (transaction outcome). "
-                    f"Operation: {operation_details}"
+                    f"Operation: {operation_details}. Current balances: {updated_credits_dict}"
                 )
 
-            return success
+            return success, updated_credits_dict
 
         except Exception as e:
             self.logger.error(f"Error charging credits for user {user_uid}: {str(e)}")

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

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

@@ -28,7 +28,8 @@ src/ipulse_shared_core_ftredge/services/__init__.py
 src/ipulse_shared_core_ftredge/services/base_firestore_service.py
 src/ipulse_shared_core_ftredge/services/base_service_exceptions.py
 src/ipulse_shared_core_ftredge/services/cache_aware_firestore_service.py
-src/ipulse_shared_core_ftredge/services/credit_service.py
+src/ipulse_shared_core_ftredge/services/charging_processors.py
+src/ipulse_shared_core_ftredge/services/charging_service.py
 src/ipulse_shared_core_ftredge/services/fastapiservicemon.py
 src/ipulse_shared_core_ftredge/services/servicemon.py
 src/ipulse_shared_core_ftredge/utils/__init__.py

{ipulse_shared_core_ftredge-14.0.1 → ipulse_shared_core_ftredge-16.0.1}/tests/test_cache_aware_service.py

@@ -208,13 +208,14 @@ class TestCacheAwareFirestoreService(unittest.TestCase):
         """Test _invalidate_collection_cache method."""
         # Prepare cached data
         test_docs = [{"id": "doc1", "name": "Doc 1"}, {"id": "doc2", "name": "Doc 2"}]
-        self.collection_cache.set("all_documents", test_docs)
+        cache_key_to_invalidate = "all_documents"
+        self.collection_cache.set(cache_key_to_invalidate, test_docs)
 
         # Execute invalidation
-        self.service._invalidate_collection_cache()
+        self.service._invalidate_collection_cache(cache_key_to_invalidate)
 
-        # Verify cache was invalidated
-        self.assertIsNone(self.collection_cache.get("all_documents"))
+        # Verify cache is empty for that key
+        self.assertIsNone(self.collection_cache.get(cache_key_to_invalidate))
 
     def test_invalidate_collection_cache_custom_key(self):
         """Test _invalidate_collection_cache method with custom key."""

{ipulse_shared_core_ftredge-14.0.1 → ipulse_shared_core_ftredge-16.0.1}/tests/test_shared_cache.py

@@ -42,7 +42,7 @@ class TestSharedCache(unittest.TestCase):
         self.assertEqual(self.cache.get("expiring_key"), "expiring_value")
 
         # Wait for TTL to expire
-        time.sleep(0.6)  # Slightly longer than TTL
+        time.sleep(0.6)  # Slightly longer than TTL (0.5s)
 
         # Verify value is no longer cached
         self.assertIsNone(self.cache.get("expiring_key"))
@@ -138,8 +138,9 @@ class TestSharedCache(unittest.TestCase):
         self.assertEqual(stats["enabled"], True)
         self.assertEqual(stats["ttl_seconds"], 0.5)
         self.assertEqual(stats["item_count"], 2)
-        self.assertIn("stats_key1", stats["keys"])
-        self.assertIn("stats_key2", stats["keys"])
+        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__":