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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 14.0.1
+Version: 15.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-15.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='15.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-15.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-15.0.1}/src/ipulse_shared_core_ftredge/services/credit_service.py

@@ -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(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 = {
                     "updated_at": datetime.now(timezone.utc).isoformat(),
-                    "updated_by": "credit_service" # Consider making this configurable or more generic
+                    "updated_by": "credit_service"
                 }
 
-                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-15.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: 15.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-15.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-15.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__":