ipulse-shared-core-ftredge 27.1.1__tar.gz → 27.6.2__tar.gz

{ipulse_shared_core_ftredge-27.1.1/src/ipulse_shared_core_ftredge.egg-info → ipulse_shared_core_ftredge-27.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 27.1.1
+Version: 27.6.2
 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
@@ -12,7 +12,7 @@ License-File: LICENCE
 Requires-Dist: pydantic[email]~=2.5
 Requires-Dist: python-dateutil~=2.8
 Requires-Dist: fastapi~=0.115.8
-Requires-Dist: ipulse_shared_base_ftredge==11.1.1
+Requires-Dist: ipulse_shared_base_ftredge~=12.6.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='ipulse_shared_core_ftredge',
-    version='27.1.1',
+    version='27.6.2',
     package_dir={'': 'src'},  # Specify the source directory
     packages=find_packages(where='src'),  # Look for packages in 'src'
     install_requires=[
@@ -11,7 +11,7 @@ setup(
         'pydantic[email]~=2.5',
         'python-dateutil~=2.8',
         'fastapi~=0.115.8',
-        'ipulse_shared_base_ftredge==11.1.1',
+        'ipulse_shared_base_ftredge~=12.6.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-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/dependencies/authz_for_apis.py

@@ -110,8 +110,13 @@ async def get_userstatus(
             else:
                 raise ValueError(f"Expected UserStatus object or dict, got {type(status_obj)}")
 
+    except ResourceNotFoundError:
+        # Let ResourceNotFoundError bubble up as 404 - this is a user issue, not a server error
+        log.warning(f"User status not found for user {user_uid} during authorization")
+        raise
     except Exception as e:
-        log.error(f"Error fetching user status via UserCoreService: {str(e)}")
+        # Only wrap true service errors (database failures, network issues, etc) in ServiceError
+        log.error(f"Service error fetching user status via UserCoreService: {str(e)}")
         raise ServiceError(
             operation="fetching user status for authz via UserCoreService",
             error=e,

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/models/__init__.py

@@ -1,4 +1,4 @@
-from .base_data_model import BaseDataModel
+from .base_nosql_model import BaseNoSQLModel
 from .base_api_response import BaseAPIResponse, PaginatedAPIResponse
 from .credit_api_response import CreditChargeableAPIResponse, UserCreditBalance, UpdatedUserCreditInfo
 from .custom_json_response import CustomJSONResponse

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/models/base_api_response.py

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

ipulse_shared_core_ftredge-27.1.1/src/ipulse_shared_core_ftredge/models/base_data_model.py → ipulse_shared_core_ftredge-27.6.2/src/ipulse_shared_core_ftredge/models/base_nosql_model.py

@@ -1,31 +1,55 @@
 from datetime import datetime, timezone
-from typing import Any
-from typing import ClassVar
-from pydantic import BaseModel, Field, ConfigDict, field_validator
+from typing import Any , Optional, ClassVar
+from pydantic import BaseModel, Field, ConfigDict, field_validator, model_validator
 import dateutil.parser
 
-class BaseDataModel(BaseModel):
+class BaseNoSQLModel(BaseModel):
     """Base model with common fields and configuration"""
     model_config = ConfigDict(frozen=False, extra="forbid")
 
     # Required class variables that must be defined in subclasses
-    VERSION: ClassVar[float]
+    SCHEMA_ID: ClassVar[str]
+    SCHEMA_NAME: ClassVar[str]
+    VERSION: ClassVar[int]
     DOMAIN: ClassVar[str]
     OBJ_REF: ClassVar[str]
 
-    # Schema versioning
-    schema_version: float = Field(
-        ...,  # Make this required
+    # Schema versioning - these will be auto-populated from class variables
+    schema_version: int = Field(
+        default=None,  # Will be auto-populated by model_validator
         description="Version of this Class == version of DB Schema",
         frozen=True  # Keep schema version frozen for data integrity
     )
 
+    schema_id: str = Field(
+        default=None,  # Will be auto-populated by model_validator
+        description="Identifier for the schema this document adheres to"
+    )
+    schema_name: str = Field(
+        default=None,  # Will be auto-populated by model_validator
+        description="Name of the schema this document adheres to"
+    )
+
     # Audit fields - created fields are frozen after creation, updated fields are mutable
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), frozen=True)
-    created_by: str = Field(..., frozen=True)
+    created_at: Optional[datetime] = Field(default_factory=lambda: datetime.now(timezone.utc), frozen=True)
+    created_by: Optional[str] = Field(..., frozen=True)
     updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     updated_by: str = Field(...)
 
+    @model_validator(mode='before')
+    @classmethod
+    def populate_schema_fields(cls, values):
+        """Auto-populate schema fields from class variables if not provided"""
+        if isinstance(values, dict):
+            # Set if not already provided or if None
+            if ('schema_version' not in values or values.get('schema_version') is None) and hasattr(cls, 'VERSION'):
+                values['schema_version'] = cls.VERSION
+            if ('schema_id' not in values or values.get('schema_id') is None) and hasattr(cls, 'SCHEMA_ID'):
+                values['schema_id'] = cls.SCHEMA_ID
+            if ('schema_name' not in values or values.get('schema_name') is None) and hasattr(cls, 'SCHEMA_NAME'):
+                values['schema_name'] = cls.SCHEMA_NAME
+        return values
+
     @classmethod
     def get_collection_name(cls) -> str:
         """Generate standard collection name"""

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/models/catalog/subscriptionplan.py

@@ -10,9 +10,9 @@ from enum import StrEnum
 from datetime import datetime, timezone, timedelta
 from pydantic import Field, ConfigDict, field_validator,model_validator, BaseModel
 from ipulse_shared_base_ftredge import (Layer, Module, list_enums_as_lower_strings,
-                                        Subject, SubscriptionPlanName,ObjectOverallStatus,
+                                        SystemSubject, SubscriptionPlanName,ObjectOverallStatus,
                                         SubscriptionStatus, TimeUnit)
-from ..base_data_model import BaseDataModel
+from ..base_nosql_model import BaseNoSQLModel
 from ..user.user_permissions import UserPermission
 
 
@@ -51,25 +51,19 @@ class PlanUpgradePath(BaseModel):
 
 
 ############################################ !!!!! ALWAYS UPDATE SCHEMA VERSION IF SCHEMA IS BEING MODIFIED !!! ############################################
-class SubscriptionPlan(BaseDataModel):
+class SubscriptionPlan(BaseNoSQLModel):
     """
     Configuration template for subscription plans stored in Firestore.
     These templates define the default settings applied when creating user subscriptions.
     """
 
     model_config = ConfigDict(extra="forbid")
-
-    VERSION: ClassVar[float] = 1.0
-    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, Subject.CATALOG))
+    SCHEMA_ID: ClassVar[str] = ""
+    SCHEMA_NAME: ClassVar[str] = ""
+    VERSION: ClassVar[int] = 2
+    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, SystemSubject.CATALOG))
     OBJ_REF: ClassVar[str] = "subscriptionplan"
 
-    # System-managed fields
-    schema_version: float = Field(
-        default=VERSION,
-        description="Version of this Class == version of DB Schema",
-        frozen=True
-    )
-
     id: Optional[str] = Field(
         default=None,
         description="Unique identifier for this plan template (e.g., 'free_subscription_1'). Auto-generated if not provided.",

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/models/catalog/usertype.py

@@ -9,9 +9,9 @@ based on their user type (superadmin, admin, internal, authenticated, anonymous)
 from typing import Dict, Any, Optional, ClassVar, List
 from datetime import datetime
 from pydantic import Field, ConfigDict, field_validator, model_validator
-from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, Subject, ObjectOverallStatus
+from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, SystemSubject, ObjectOverallStatus
 from ipulse_shared_base_ftredge.enums.enums_iam import IAMUserType
-from ipulse_shared_core_ftredge.models.base_data_model import BaseDataModel
+from ipulse_shared_core_ftredge.models.base_nosql_model import BaseNoSQLModel
 from ipulse_shared_core_ftredge.models.user.user_permissions import UserPermission
 
 # ORIGINAL AUTHOR ="russlan.ramdowar;russlan@ftredge.com"
@@ -19,7 +19,7 @@ from ipulse_shared_core_ftredge.models.user.user_permissions import UserPermissi
 
 
 ############################################ !!!!! ALWAYS UPDATE SCHEMA VERSION IF SCHEMA IS BEING MODIFIED !!! ############################################
-class UserType(BaseDataModel):
+class UserType(BaseNoSQLModel):
     """
     Configuration template for user type defaults stored in Firestore.
     These templates define the default settings applied when creating users of specific types.
@@ -27,17 +27,12 @@ class UserType(BaseDataModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    VERSION: ClassVar[float] = 1.0
-    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Subject.CATALOG.name))
+    SCHEMA_ID: ClassVar[str] = ""
+    SCHEMA_NAME: ClassVar[str] = ""
+    VERSION: ClassVar[int] = 1
+    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, SystemSubject.CATALOG.name))
     OBJ_REF: ClassVar[str] = "usertype"
 
-    # System-managed fields
-    schema_version: float = Field(
-        default=VERSION,
-        description="Version of this Class == version of DB Schema",
-        frozen=True
-    )
-
     id: Optional[str] = Field(
         default=None,
         description="Unique identifier for this user type template (e.g., 'superadmin_1', 'authenticated_1'). Auto-generated if not provided.",

ipulse_shared_core_ftredge-27.6.2/src/ipulse_shared_core_ftredge/models/time_series_packaged_dataset_model.py

@@ -0,0 +1,44 @@
+# pylint: disable=missing-module-docstring, missing-class-docstring
+from typing import List, Optional, TypeVar, Generic, ClassVar
+from datetime import datetime
+from pydantic import Field, BaseModel
+from ipulse_shared_core_ftredge.models.base_nosql_model import BaseNoSQLModel
+
+# Generic type for the records within the dataset
+RecordsSamplingType = TypeVar('RecordsSamplingType', bound=BaseModel)
+
+class TimeSeriesPackagedDatasetModel(BaseNoSQLModel, Generic[RecordsSamplingType]):
+    """
+    An intermediary model for time series datasets that holds aggregated records.
+    It provides a generic way to handle different types of time series records.
+    """
+    SCHEMA_ID: ClassVar[str] = ""
+    SCHEMA_NAME: ClassVar[str] = ""
+    VERSION: ClassVar[int] = 1
+
+
+    subject_id: str = Field(default="", description="The unique identifier for the subject.")
+    subject_category: str = Field(default="", description="The subject category eg. EQUITY, DERIVATIVE, CRYPTO etc.")
+
+    # Generic lists for different temporal buckets of records
+    max_bulk_records: List[RecordsSamplingType] = Field(default_factory=list)
+    latest_bulk_records: Optional[List[RecordsSamplingType]] = Field(default_factory=list)
+    latest_intraday_records: Optional[List[RecordsSamplingType]] = Field(default_factory=list)
+
+    # Metadata fields
+    max_bulk_updated_at: Optional[datetime] = None
+    max_bulk_updated_by: Optional[str] = None
+    max_bulk_recent_date_id: Optional[datetime] = None
+    max_bulk_oldest_date_id: Optional[datetime] = None
+    latest_bulk_recent_date_id: Optional[datetime] = None
+    latest_bulk_oldest_date_id: Optional[datetime] = None
+    latest_record_updated_at: Optional[datetime] = None
+    latest_record_updated_by: Optional[str] = None
+    latest_record_change_id: Optional[str] = None
+    latest_intraday_bulk_updated_at: Optional[datetime] = None
+    latest_intraday_bulk_updated_by: Optional[str] = None
+
+    @property
+    def id(self) -> str:
+        """Return subject_id for backward compatibility and consistency."""
+        return self.subject_id

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/models/user/user_subscription.py

@@ -3,8 +3,8 @@ from dateutil.relativedelta import relativedelta
 import uuid
 from typing import Optional, ClassVar, Dict, Any, List
 from pydantic import Field, ConfigDict, model_validator
-from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, Subject, SubscriptionPlanName, SubscriptionStatus, TimeUnit
-from ..base_data_model import BaseDataModel
+from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, SystemSubject, SubscriptionPlanName, SubscriptionStatus, TimeUnit
+from ..base_nosql_model import BaseNoSQLModel
 from .user_permissions import UserPermission
 # ORIGINAL AUTHOR ="russlan.ramdowar;russlan@ftredge.com"
 # CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
@@ -14,23 +14,19 @@ DEFAULT_SUBSCRIPTION_PLAN = SubscriptionPlanName.FREE_SUBSCRIPTION
 DEFAULT_SUBSCRIPTION_STATUS = SubscriptionStatus.ACTIVE
 
 ############################################ !!!!! ALWAYS UPDATE SCHEMA VERSION , IF SCHEMA IS BEING MODIFIED !!! ############################################
-class UserSubscription(BaseDataModel):
+class UserSubscription(BaseNoSQLModel):
     """
     Represents a single subscription cycle with enhanced flexibility and tracking.
     """
 
     model_config = ConfigDict(frozen=True, extra="forbid")
 
-    VERSION: ClassVar[float] = 3.0  # Incremented version for direct fields instead of computed
-    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, Subject.SUBSCRIPTION))
+    SCHEMA_ID: ClassVar[str] = ""
+    SCHEMA_NAME: ClassVar[str] = ""
+    VERSION: ClassVar[int] = 3  # Incremented version for direct fields instead of computed
+    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, SystemSubject.SUBSCRIPTION))
     OBJ_REF: ClassVar[str] = "subscription"
 
-    # System-managed fields (read-only)
-    schema_version: float = Field(
-        default=VERSION,
-        description="Version of this Class == version of DB Schema",
-        frozen=True
-    )
 
     # Unique identifier for this specific subscription instance - now auto-generated
     id: Optional[str] = Field(

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/models/user/userprofile.py

@@ -3,28 +3,25 @@ from datetime import date, datetime
 import re  # Add re import
 from typing import Set, Optional, ClassVar, Dict, Any, List
 from pydantic import EmailStr, Field, ConfigDict, model_validator, field_validator
-from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, Subject, IAMUserType
-from ..base_data_model import BaseDataModel
+from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, SystemSubject, IAMUserType
+from ..base_nosql_model import BaseNoSQLModel
 # ORIGINAL AUTHOR ="Russlan Ramdowar;russlan@ftredge.com"
 # CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
 
 ############################ !!!!! ALWAYS UPDATE SCHEMA VERSION , IF SCHEMA IS BEING MODIFIED !!! #################################
-class UserProfile(BaseDataModel):
+class UserProfile(BaseNoSQLModel):
     """
     User Profile model for storing personal information and settings.
     """
     model_config = ConfigDict(frozen=False, extra="forbid")  # Allow field modification
 
     # Class constants
-    VERSION: ClassVar[float] = 5.0  # Incremented version for primary_usertype addition
-    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, Subject.USER))
+    SCHEMA_ID: ClassVar[str] = ""
+    SCHEMA_NAME: ClassVar[str] = ""
+    VERSION: ClassVar[int] = 5  # Incremented version for primary_usertype addition
+    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, SystemSubject.USER))
     OBJ_REF: ClassVar[str] = "userprofile"
 
-    schema_version: float = Field(
-        default=VERSION,
-        frozen=True,
-        description="Version of this Class == version of DB Schema"
-    )
 
     id: Optional[str] = Field(
         default=None,  # Will be auto-generated from user_uid if not provided
@@ -104,7 +101,7 @@ class UserProfile(BaseDataModel):
         description="Additional metadata for the user"
     )
 
-    # Remove audit fields as they're inherited from BaseDataModel
+    # Remove audit fields as they're inherited from BaseNoSQLModel
 
     @field_validator('user_uid')
     @classmethod

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/models/user/userstatus.py

@@ -2,16 +2,16 @@
 from datetime import datetime, timezone, timedelta
 from typing import Set, Optional, Dict, List, ClassVar, Any
 from pydantic import Field, ConfigDict, model_validator, field_validator
-from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, Subject, TimeUnit
+from ipulse_shared_base_ftredge import Layer, Module, list_enums_as_lower_strings, SystemSubject, TimeUnit
 from ipulse_shared_base_ftredge.enums.enums_iam import IAMUnit
 from .user_subscription import UserSubscription
-from ..base_data_model import BaseDataModel
+from ..base_nosql_model import BaseNoSQLModel
 from .user_permissions import UserPermission
 
 
 
 ############################ !!!!! ALWAYS UPDATE SCHEMA VERSION , IF SCHEMA IS BEING MODIFIED !!! #################################
-class UserStatus(BaseDataModel):
+class UserStatus(BaseNoSQLModel):
     """
     User Status model for tracking user subscription and access rights.
     """
@@ -19,21 +19,14 @@ class UserStatus(BaseDataModel):
     model_config = ConfigDict(frozen=False, extra="forbid")
 
     # Class constants
-    VERSION: ClassVar[float] = 7.0  # Major version bump for flattened IAM permissions structure
-    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, Subject.USER))
+    SCHEMA_ID: ClassVar[str] = ""
+    SCHEMA_NAME: ClassVar[str] = ""
+    VERSION: ClassVar[int] = 7  # Major version bump for flattened IAM permissions structure
+    DOMAIN: ClassVar[str] = "_".join(list_enums_as_lower_strings(Layer.PULSE_APP, Module.CORE, SystemSubject.USER))
     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,
-        frozen=True,
-        description="Version of this Class == version of DB Schema"
-    )
-
     id: Optional[str] = Field(
         default=None,  # Will be auto-generated from user_uid if not provided
         description=f"User ID, format: {OBJ_REF}_user_uid"

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/services/__init__.py

@@ -2,7 +2,7 @@
 
 
 # Import from base services
-from .base import BaseFirestoreService, CacheAwareFirestoreService
+from .base import BaseFirestoreService, CacheAwareFirestoreService, MultiCollectionCacheAwareFirestoreService
 
 from .charging_processors import ChargingProcessor
 from .user_charging_service import UserChargingService

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/services/base/__init__.py

@@ -7,6 +7,7 @@ preventing circular import dependencies.
 
 from .base_firestore_service import BaseFirestoreService
 from .cache_aware_firestore_service import CacheAwareFirestoreService
+from .multi_collection_cache_aware_firestore_service import MultiCollectionCacheAwareFirestoreService
 
 __all__ = [
     'BaseFirestoreService',

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/services/base/cache_aware_firestore_service.py

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

ipulse_shared_core_ftredge-27.6.2/src/ipulse_shared_core_ftredge/services/base/multi_collection_cache_aware_firestore_service.py

@@ -0,0 +1,244 @@
+"""
+Generic multi-collection cache-aware Firestore service.
+
+This service extends CacheAwareFirestoreService to support dynamic collection operations
+while maintaining all proven infrastructure patterns. It's designed to be generic and
+reusable across different model types.
+"""
+from typing import Dict, Any, List, Optional, Union, Type, TypeVar, Generic
+from google.cloud import firestore
+from .cache_aware_firestore_service import CacheAwareFirestoreService
+from ...exceptions import ServiceError, ValidationError, ResourceNotFoundError
+from ...cache.shared_cache import SharedCache
+from ...models import BaseNoSQLModel
+import logging
+
+# Generic type for BaseNoSQLModel subclasses
+T = TypeVar('T', bound=BaseNoSQLModel)
+
+
+class MultiCollectionCacheAwareFirestoreService(CacheAwareFirestoreService[T], Generic[T]):
+    """
+    Generic multi-collection extension of CacheAwareFirestoreService.
+
+    This service extends the proven CacheAwareFirestoreService infrastructure to support
+    dynamic collection operations based on storage_location_path while maintaining
+    all caching, error handling, and CRUD capabilities.
+
+    This is a generic base class that can be extended for specific model types.
+    """
+
+    def __init__(self,
+                 db: firestore.Client,
+                 logger: logging.Logger,
+                 model_class: Type[T],
+                 resource_type: str,
+                 base_collection_name: str,
+                 timeout: float = 30.0):
+
+        # Initialize the parent CacheAwareFirestoreService with a base collection
+        # We'll override the collection_name dynamically per operation
+        super().__init__(
+            db=db,
+            collection_name=base_collection_name,  # Base collection name
+            resource_type=resource_type,
+            model_class=model_class,
+            logger=logger,
+            document_cache=None,  # We'll manage caches per collection
+            collection_cache=None,  # We'll manage caches per collection
+            timeout=timeout
+        )
+
+        # Cache for per-collection cache instances
+        self._collection_caches: Dict[str, Dict[str, SharedCache]] = {}
+
+        self.logger.info(f"MultiCollectionCacheAwareFirestoreService initialized for {resource_type}")
+
+    def _get_collection_caches(self, storage_location_path: str) -> Dict[str, SharedCache]:
+        """Get or create cache instances for a specific storage location."""
+        if storage_location_path not in self._collection_caches:
+            # Create collection-specific cache instances
+            # No need for safe_name transformation - dots are fine in strings
+
+            document_cache = SharedCache(
+                name=f"MultiColDoc_{storage_location_path}",
+                ttl=600.0,  # 10 minutes
+                enabled=True,
+                logger=self.logger
+            )
+
+            collection_cache = SharedCache(
+                name=f"MultiColCollection_{storage_location_path}",
+                ttl=600.0,  # 10 minutes
+                enabled=True,
+                logger=self.logger
+            )
+
+            self._collection_caches[storage_location_path] = {
+                'document': document_cache,
+                'collection': collection_cache
+            }
+
+            self.logger.info(f"Created cache instances for collection: {storage_location_path}")
+
+        return self._collection_caches[storage_location_path]
+
+    def _set_collection_context(self, storage_location_path: str):
+        """Set the collection context for the current operation."""
+        # Update the collection name for this operation
+        self.collection_name = storage_location_path
+
+        # Update the cache references for this collection
+        caches = self._get_collection_caches(storage_location_path)
+        self.document_cache = caches['document']
+        self.collection_cache = caches['collection']
+
+    async def get_document_from_collection(self,
+                                         storage_location_path: str,
+                                         doc_id: str,
+                                         convert_to_model: bool = True) -> Union[T, Dict[str, Any], None]:
+        """
+        Get a document from a specific collection using the cache-aware infrastructure.
+        """
+        try:
+            # Set collection context
+            self._set_collection_context(storage_location_path)
+
+            # Use the parent's cache-aware get_document method
+            return await super().get_document(doc_id, convert_to_model)
+
+        except ResourceNotFoundError:
+            self.logger.info(f"Document {doc_id} not found in {storage_location_path}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting document {doc_id} from {storage_location_path}: {str(e)}", exc_info=True)
+            raise ServiceError(
+                operation=f"getting document from {storage_location_path}",
+                error=e,
+                resource_type=self.resource_type,
+                resource_id=doc_id
+            ) from e
+
+    async def get_all_documents_from_collection(self,
+                                              storage_location_path: str,
+                                              cache_key: Optional[str] = None) -> List[T]:
+        """
+        Get all documents from a specific collection using cache-aware infrastructure.
+        """
+        try:
+            # Set collection context
+            self._set_collection_context(storage_location_path)
+
+            # Use cache key if not provided
+            if not cache_key:
+                cache_key = f"all_documents_{storage_location_path}"
+
+            # Use the parent's cache-aware get_all_documents method
+            results = await super().get_all_documents(cache_key=cache_key, as_models=True)
+
+            # Ensure we return model instances
+            model_results: List[T] = []
+            for item in results:
+                if isinstance(item, BaseNoSQLModel) and self.model_class and isinstance(item, self.model_class):
+                    model_results.append(item)  # type: ignore
+                elif isinstance(item, dict) and self.model_class:
+                    try:
+                        model_results.append(self.model_class.model_validate(item))
+                    except Exception as e:
+                        self.logger.warning(f"Failed to convert dict to model: {e}")
+
+            return model_results
+
+        except Exception as e:
+            self.logger.error(f"Error getting all documents from {storage_location_path}: {str(e)}", exc_info=True)
+            raise ServiceError(
+                operation=f"getting all documents from {storage_location_path}",
+                error=e,
+                resource_type=self.resource_type
+            ) from e
+
+    async def create_document_in_collection(self,
+                                          storage_location_path: str,
+                                          doc_id: str,
+                                          data: Union[T, Dict[str, Any]],
+                                          creator_uid: str,
+                                          merge: bool = False) -> Dict[str, Any]:
+        """
+        Create a document in a specific collection using cache-aware infrastructure.
+        Automatically handles cache invalidation.
+        """
+        try:
+            # Set collection context
+            self._set_collection_context(storage_location_path)
+
+            # Use the parent's cache-aware create_document method
+            return await super().create_document(doc_id, data, creator_uid, merge)
+
+        except Exception as e:
+            self.logger.error(f"Error creating document {doc_id} in {storage_location_path}: {str(e)}", exc_info=True)
+            raise ServiceError(
+                operation=f"creating document in {storage_location_path}",
+                error=e,
+                resource_type=self.resource_type,
+                resource_id=doc_id
+            ) from e
+
+    async def update_document_in_collection(self,
+                                          storage_location_path: str,
+                                          doc_id: str,
+                                          update_data: Dict[str, Any],
+                                          updater_uid: str,
+                                          require_exists: bool = True) -> Dict[str, Any]:
+        """
+        Update a document in a specific collection using cache-aware infrastructure.
+        Automatically handles cache invalidation.
+        """
+        try:
+            # Set collection context
+            self._set_collection_context(storage_location_path)
+
+            # Use the parent's cache-aware update_document method
+            return await super().update_document(doc_id, update_data, updater_uid, require_exists)
+
+        except Exception as e:
+            self.logger.error(f"Error updating document {doc_id} in {storage_location_path}: {str(e)}", exc_info=True)
+            raise ServiceError(
+                operation=f"updating document in {storage_location_path}",
+                error=e,
+                resource_type=self.resource_type,
+                resource_id=doc_id
+            ) from e
+
+    async def delete_document_from_collection(self,
+                                            storage_location_path: str,
+                                            doc_id: str,
+                                            require_exists: bool = True) -> bool:
+        """
+        Delete a document from a specific collection using cache-aware infrastructure.
+        Automatically handles cache invalidation.
+        """
+        try:
+            # Set collection context
+            self._set_collection_context(storage_location_path)
+
+            # Use the parent's cache-aware delete_document method
+            return await super().delete_document(doc_id, require_exists)
+
+        except Exception as e:
+            self.logger.error(f"Error deleting document {doc_id} from {storage_location_path}: {str(e)}", exc_info=True)
+            raise ServiceError(
+                operation=f"deleting document from {storage_location_path}",
+                error=e,
+                resource_type=self.resource_type,
+                resource_id=doc_id
+            ) from e
+
+    def get_cache_stats(self) -> Dict[str, Any]:
+        """Get cache statistics for all collections managed by this service."""
+        stats = {}
+        for storage_path, caches in self._collection_caches.items():
+            stats[storage_path] = {
+                'document_cache': caches['document'].get_stats(),
+                'collection_cache': caches['collection'].get_stats()
+            }
+        return stats

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/services/catalog/catalog_usertype_service.py

@@ -358,6 +358,17 @@ class CatalogUserTypeService(BaseFirestoreService[UserType]):
             limit=1
         )
 
+        # Fallback to AUTHENTICATED if primary usertype not found (especially for CUSTOMER)
+        if not usertypes and primary_usertype == IAMUserType.CUSTOMER:
+            self.logger.warning(f"No CUSTOMER usertype found, falling back to AUTHENTICATED for email: {email}")
+            usertypes = await self.list_usertypes(
+                primary_usertype=IAMUserType.AUTHENTICATED,
+                pulse_status=ObjectOverallStatus.ACTIVE,
+                latest_version_only=True,
+                limit=1
+            )
+            primary_usertype = IAMUserType.AUTHENTICATED  # Update for logging
+
         if not usertypes:
             from ipulse_shared_core_ftredge.exceptions import ServiceError
             raise ServiceError(

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge/services/charging_processors.py

@@ -56,7 +56,7 @@ class ChargingProcessor:
                     updated_user_credits = pre_fetched_credits
                 elif self.user_charging_service: # Attempt to get current credits if not pre-fetched
                     try:
-                        _, current_user_credits_from_verify = await self.user_charging_service.verify_enough_credits(user_uid, 0, None)
+                        _, current_user_credits_from_verify = await self.user_charging_service.verify_enough_credits(user_uid=user_uid, required_credits_for_resource=0, pre_fetched_user_credits=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.")
@@ -77,7 +77,7 @@ class ChargingProcessor:
                     updated_user_credits = pre_fetched_credits
                 elif self.user_charging_service:
                     try:
-                        _, current_user_credits_from_verify = await self.user_charging_service.verify_enough_credits(user_uid, 0, None)
+                        _, current_user_credits_from_verify = await self.user_charging_service.verify_enough_credits(user_uid=user_uid, required_credits_for_resource=0, pre_fetched_user_credits=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.")

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2/src/ipulse_shared_core_ftredge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 27.1.1
+Version: 27.6.2
 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
@@ -12,7 +12,7 @@ License-File: LICENCE
 Requires-Dist: pydantic[email]~=2.5
 Requires-Dist: python-dateutil~=2.8
 Requires-Dist: fastapi~=0.115.8
-Requires-Dist: ipulse_shared_base_ftredge==11.1.1
+Requires-Dist: ipulse_shared_base_ftredge~=12.6.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge.egg-info/SOURCES.txt

@@ -21,9 +21,10 @@ src/ipulse_shared_core_ftredge/exceptions/base_exceptions.py
 src/ipulse_shared_core_ftredge/exceptions/user_exceptions.py
 src/ipulse_shared_core_ftredge/models/__init__.py
 src/ipulse_shared_core_ftredge/models/base_api_response.py
-src/ipulse_shared_core_ftredge/models/base_data_model.py
+src/ipulse_shared_core_ftredge/models/base_nosql_model.py
 src/ipulse_shared_core_ftredge/models/credit_api_response.py
 src/ipulse_shared_core_ftredge/models/custom_json_response.py
+src/ipulse_shared_core_ftredge/models/time_series_packaged_dataset_model.py
 src/ipulse_shared_core_ftredge/models/catalog/__init__.py
 src/ipulse_shared_core_ftredge/models/catalog/subscriptionplan.py
 src/ipulse_shared_core_ftredge/models/catalog/usertype.py
@@ -41,6 +42,7 @@ src/ipulse_shared_core_ftredge/services/user_charging_service.py
 src/ipulse_shared_core_ftredge/services/base/__init__.py
 src/ipulse_shared_core_ftredge/services/base/base_firestore_service.py
 src/ipulse_shared_core_ftredge/services/base/cache_aware_firestore_service.py
+src/ipulse_shared_core_ftredge/services/base/multi_collection_cache_aware_firestore_service.py
 src/ipulse_shared_core_ftredge/services/catalog/__init__.py
 src/ipulse_shared_core_ftredge/services/catalog/catalog_subscriptionplan_service.py
 src/ipulse_shared_core_ftredge/services/catalog/catalog_usertype_service.py
@@ -54,7 +56,5 @@ src/ipulse_shared_core_ftredge/services/user/userauth_operations.py
 src/ipulse_shared_core_ftredge/services/user/userprofile_operations.py
 src/ipulse_shared_core_ftredge/services/user/userstatus_operations.py
 src/ipulse_shared_core_ftredge/utils/__init__.py
-src/ipulse_shared_core_ftredge/utils/authz_credit_extraction.py
 src/ipulse_shared_core_ftredge/utils/custom_json_encoder.py
-src/ipulse_shared_core_ftredge/utils/json_encoder.py
-tests/test_shared_cache.py
+src/ipulse_shared_core_ftredge/utils/json_encoder.py

{ipulse_shared_core_ftredge-27.1.1 → ipulse_shared_core_ftredge-27.6.2}/src/ipulse_shared_core_ftredge.egg-info/requires.txt

@@ -1,4 +1,4 @@
 pydantic[email]~=2.5
 python-dateutil~=2.8
 fastapi~=0.115.8
-ipulse_shared_base_ftredge==11.1.1
+ipulse_shared_base_ftredge~=12.6.0

ipulse_shared_core_ftredge-27.1.1/tests/test_shared_cache.py

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