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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 15.0.1
+Version: 18.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.5.1
+Requires-Dist: ipulse_shared_base_ftredge==7.2.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page

{ipulse_shared_core_ftredge-15.0.1 → ipulse_shared_core_ftredge-18.0.1}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='ipulse_shared_core_ftredge',
-    version='15.0.1',
+    version='18.0.1',
     package_dir={'': 'src'},  # Specify the source directory
     packages=find_packages(where='src'),  # Look for packages in 'src'
     install_requires=[
@@ -12,7 +12,7 @@ setup(
         'python-dateutil~=2.8',
         'fastapi~=0.115.8',
         'pytest',
-        'ipulse_shared_base_ftredge==6.5.1',
+        'ipulse_shared_base_ftredge==7.2.0',
     ],
     author='Russlan Ramdowar',
     description='Shared Core models and Logger util for the Pulse platform project. Using AI for financial advisory and investment management.',

{ipulse_shared_core_ftredge-15.0.1 → ipulse_shared_core_ftredge-18.0.1}/src/ipulse_shared_core_ftredge/dependencies/authz_for_apis.py

@@ -140,10 +140,12 @@ async def get_userstatus(
         snapshot = await get_with_strict_timeout(user_ref, timeout)
 
         if not snapshot.exists:
+            # Log at DEBUG level since this might be expected for new users
+            logger.debug(f"User status document not found for user {user_uid} (document: {userstatus_id})")
             raise ResourceNotFoundError(
-                resource_type="authorization userstatus",
+                resource_type="authz_for_apis>userstatus",
                 resource_id=userstatus_id,
-                additional_info={"user_uid": user_uid}
+                additional_info={"user_uid": user_uid, "context": "authorization"}
             )
 
         status_data = snapshot.to_dict()
@@ -153,7 +155,10 @@ async def get_userstatus(
             userstatus_cache.set(user_uid, status_data)
         return status_data, cache_used
 
-    except TimeoutError as e:
+    except ResourceNotFoundError:
+        # Re-raise ResourceNotFoundError as-is - don't wrap in ServiceError
+        raise
+    except (TimeoutError, FirestoreTimeoutError) as e:
         logger.error(f"Timeout while fetching user status for {user_uid}: {str(e)}")
         raise ServiceError(
             operation="fetching user status for authz",
@@ -166,8 +171,6 @@ async def get_userstatus(
                 "timeout_seconds": timeout
             }
         )
-    except ResourceNotFoundError:
-        raise
     except Exception as e:
         logger.error(f"Error fetching user status for {user_uid}: {str(e)}")
         raise ServiceError(

{ipulse_shared_core_ftredge-15.0.1 → ipulse_shared_core_ftredge-18.0.1}/src/ipulse_shared_core_ftredge/models/__init__.py

@@ -4,7 +4,7 @@ from .user_status import UserStatus, IAMUnitRefAssignment
 from .user_profile_update import UserProfileUpdate
 from .user_auth import UserAuth
 from .organization_profile import OrganizationProfile
-from .base_api_response import BaseAPIResponse , CustomJSONResponse
+from .base_api_response import BaseAPIResponse , CustomJSONResponse, CreditChargeableAPIResponse, UserCreditBalance, UpdatedUserCreditInfo
 from .base_data_model import BaseDataModel
 
 

{ipulse_shared_core_ftredge-15.0.1 → ipulse_shared_core_ftredge-18.0.1}/src/ipulse_shared_core_ftredge/models/base_api_response.py

@@ -11,6 +11,7 @@ T = TypeVar('T')
 class BaseAPIResponse(BaseModel, Generic[T]):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     success: bool
+    chargeable: bool = False # Added chargeable attribute
     data: Optional[T] = None
     message: Optional[str] = None
     error: Optional[str] = None
@@ -19,6 +20,20 @@ class BaseAPIResponse(BaseModel, Generic[T]):
         "timestamp": dt.datetime.now(dt.timezone.utc).isoformat()
     }
 
+class UserCreditBalance(BaseModel):
+    sbscrptn_based_insight_credits: float
+    extra_insight_credits: float
+
+class UpdatedUserCreditInfo(BaseModel):
+    charge_attempted: bool
+    charge_successful: bool
+    cost_incurred: float
+    items_processed_for_charge: int
+    user_balance: UserCreditBalance
+
+class CreditChargeableAPIResponse(BaseAPIResponse[T], Generic[T]):
+    updated_user_credit_info: Optional[UpdatedUserCreditInfo] = None
+
 class PaginatedAPIResponse(BaseAPIResponse, Generic[T]):
     total_count: int
     page: int

{ipulse_shared_core_ftredge-15.0.1 → ipulse_shared_core_ftredge-18.0.1}/src/ipulse_shared_core_ftredge/models/base_data_model.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timezone
 from typing import Any
 from typing import ClassVar
+from typing import Optional, Dict
 from pydantic import BaseModel, Field, ConfigDict, field_validator
 import dateutil.parser
 

{ipulse_shared_core_ftredge-15.0.1 → ipulse_shared_core_ftredge-18.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-18.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-15.0.1/src/ipulse_shared_core_ftredge/services/credit_service.py → ipulse_shared_core_ftredge-18.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) -> Tuple[bool, Optional[Dict[str, float]]]:
+    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.
 
@@ -228,9 +228,9 @@ class CreditService:
                 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"
+                    "updated_by": "charging_service__charge_credits_transaction"  # Static identifier for this operation
                 }
 
                 if subscription_credits_deducted > 0:

{ipulse_shared_core_ftredge-15.0.1 → ipulse_shared_core_ftredge-18.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: 15.0.1
+Version: 18.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.5.1
+Requires-Dist: ipulse_shared_base_ftredge==7.2.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page

{ipulse_shared_core_ftredge-15.0.1 → ipulse_shared_core_ftredge-18.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-15.0.1 → ipulse_shared_core_ftredge-18.0.1}/src/ipulse_shared_core_ftredge.egg-info/requires.txt

@@ -2,4 +2,4 @@ pydantic[email]~=2.5
 python-dateutil~=2.8
 fastapi~=0.115.8
 pytest
-ipulse_shared_base_ftredge==6.5.1
+ipulse_shared_base_ftredge==7.2.0