ipulse-shared-core-ftredge 20.0.1__py3-none-any.whl → 22.1.1__py3-none-any.whl

ipulse_shared_core_ftredge/services/user/userprofile_operations.py

@@ -0,0 +1,166 @@
+"""
+User Profile Operations - CRUD operations for UserProfile
+"""
+import os
+import logging
+from typing import Dict, Any, Optional
+from google.cloud import firestore
+from pydantic import ValidationError as PydanticValidationError
+
+from ...models import UserProfile
+from ...exceptions import ResourceNotFoundError, UserProfileError
+from ..base import BaseFirestoreService
+
+
+class UserprofileOperations:
+    """
+    Handles CRUD operations for UserProfile documents
+    """
+
+    def __init__(
+        self,
+        firestore_client: firestore.Client,
+        logger: Optional[logging.Logger] = None,
+        timeout: float = 10.0,
+        profile_collection: Optional[str] = None,
+    ):
+        collection_name = profile_collection or UserProfile.get_collection_name()
+        self.db_service = BaseFirestoreService[UserProfile](
+            db=firestore_client,
+            collection_name=collection_name,
+            resource_type="UserProfile",
+            model_class=UserProfile,
+            logger=logger,
+            timeout=timeout
+        )
+        self.logger = logger or logging.getLogger(__name__)
+        self.profile_collection_name = collection_name
+
+        # Archival configuration
+        self.archive_profile_on_delete = os.getenv('ARCHIVE_PROFILE_ON_DELETE', 'true').lower() == 'true'
+        self.archive_profile_collection_name = os.getenv(
+            'ARCHIVE_PROFILE_COLLECTION_NAME',
+            f"~archive_{self.profile_collection_name}"
+        )
+
+    async def get_userprofile(self, user_uid: str) -> Optional[UserProfile]:
+        """Fetches a user profile from Firestore."""
+        self.logger.info(f"Fetching user profile for UID: {user_uid}")
+        try:
+            profile_data = await self.db_service.get_document(f"{UserProfile.OBJ_REF}_{user_uid}", convert_to_model=True)
+            if profile_data and isinstance(profile_data, UserProfile):
+                return profile_data
+            return None
+        except ResourceNotFoundError:
+            self.logger.warning(f"UserProfile not found for UID: {user_uid}")
+            return None
+        except Exception as e:
+            self.logger.error("Error fetching user profile for %s: %s", user_uid, e, exc_info=True)
+            raise UserProfileError(
+                detail=f"Failed to fetch user profile: {str(e)}",
+                user_uid=user_uid,
+                operation="get_userprofile",
+                original_error=e
+            ) from e
+
+    async def create_userprofile(self, userprofile: UserProfile, creator_uid: Optional[str] = None) -> UserProfile:
+        """Creates a new user profile in Firestore."""
+        self.logger.info(f"Creating user profile for UID: {userprofile.user_uid}")
+        try:
+            doc_id = f"{UserProfile.OBJ_REF}_{userprofile.user_uid}"
+            effective_creator_uid = creator_uid or userprofile.user_uid
+            await self.db_service.create_document(doc_id, userprofile.model_dump(exclude_none=True), creator_uid=effective_creator_uid)
+            self.logger.info(f"Successfully created user profile for UID: {userprofile.user_uid}")
+            return userprofile
+        except Exception as e:
+            self.logger.error(f"Error creating user profile for {userprofile.user_uid}: {e}", exc_info=True)
+            raise UserProfileError(
+                detail=f"Failed to create user profile: {str(e)}",
+                user_uid=userprofile.user_uid,
+                operation="create_userprofile",
+                original_error=e
+            )
+
+    async def update_userprofile(self, user_uid: str, profile_data: Dict[str, Any], updater_uid: str) -> UserProfile:
+        """Updates an existing user profile in Firestore."""
+        self.logger.info(f"Updating user profile for UID: {user_uid}")
+        try:
+            doc_id = f"{UserProfile.OBJ_REF}_{user_uid}"
+            await self.db_service.update_document(doc_id, profile_data, updater_uid)
+            updated_profile = await self.get_userprofile(user_uid)
+            if not updated_profile:
+                raise ResourceNotFoundError(
+                    resource_type="UserProfile",
+                    resource_id=doc_id
+                )
+            self.logger.info(f"Successfully updated user profile for UID: {user_uid}")
+            return updated_profile
+        except ResourceNotFoundError as e:
+            self.logger.error(f"Cannot update non-existent user profile for {user_uid}")
+            raise e
+        except Exception as e:
+            self.logger.error(f"Error updating user profile for {user_uid}: {e}", exc_info=True)
+            raise UserProfileError(
+                detail=f"Failed to update user profile: {str(e)}",
+                user_uid=user_uid,
+                operation="update_userprofile",
+                original_error=e
+            )
+
+    async def delete_userprofile(self, user_uid: str, updater_uid: str = "system_deletion", archive: bool = True) -> bool:
+        """Delete (archive and delete) user profile"""
+        profile_doc_id = f"{UserProfile.OBJ_REF}_{user_uid}"
+        should_archive = archive if archive is not None else self.archive_profile_on_delete
+
+        try:
+            # Get profile data for archival
+            profile_data = await self.db_service.get_document(profile_doc_id, convert_to_model=False)
+
+            if profile_data:
+                # Ensure we have a dict for archival
+                profile_dict = profile_data if isinstance(profile_data, dict) else profile_data.__dict__
+
+                # Archive if enabled
+                if should_archive:
+                    await self.db_service.archive_document(
+                        document_data=profile_dict,
+                        doc_id=profile_doc_id,
+                        archive_collection=self.archive_profile_collection_name,
+                        archived_by=updater_uid
+                    )
+
+                # Delete the original document
+                await self.db_service.delete_document(profile_doc_id)
+                self.logger.info(f"Successfully deleted user profile: {profile_doc_id}")
+                return True
+            else:
+                self.logger.warning(f"User profile {profile_doc_id} not found for deletion")
+                return True  # Consider non-existent as successfully deleted
+
+        except Exception as e:
+            self.logger.error(f"Failed to delete user profile {profile_doc_id}: {e}", exc_info=True)
+            raise UserProfileError(
+                detail=f"Failed to delete user profile: {str(e)}",
+                user_uid=user_uid,
+                operation="delete_userprofile",
+                original_error=e
+            )
+
+
+
+    async def userprofile_exists(self, user_uid: str) -> bool:
+        """Check if a user profile exists."""
+        return await self.db_service.document_exists(f"{UserProfile.OBJ_REF}_{user_uid}")
+
+    async def validate_userprofile_data(
+        self,
+        profile_data: Optional[Dict[str, Any]] = None,
+    ) -> tuple[bool, list[str]]:
+        """Validate user profile data without creating documents"""
+        errors = []
+        if profile_data:
+            try:
+                UserProfile(**profile_data)
+            except PydanticValidationError as e:
+                errors.append(f"Profile validation error: {str(e)}")
+        return len(errors) == 0, errors

ipulse_shared_core_ftredge/services/user/userstatus_operations.py

@@ -0,0 +1,212 @@
+"""
+Userstatus Operations - CRUD operations for Userstatus
+"""
+import os
+import logging
+from typing import Dict, Any, Optional
+
+from google.cloud import firestore
+from pydantic import ValidationError as PydanticValidationError
+
+from ...models import UserStatus
+from ...exceptions import ResourceNotFoundError, UserStatusError
+from ..base import BaseFirestoreService
+
+
+class UserstatusOperations:
+    """
+    Handles CRUD operations for Userstatus documents
+    """
+
+    def __init__(
+        self,
+        firestore_client: firestore.Client,
+        logger: Optional[logging.Logger] = None,
+        timeout: float = 10.0,
+        status_collection: Optional[str] = None
+    ):
+        self.db = firestore_client
+        self.logger = logger or logging.getLogger(__name__)
+        self.timeout = timeout
+
+        self.status_collection_name = status_collection or UserStatus.get_collection_name()
+
+        # Archival configuration
+        self.archive_userstatus_on_delete = os.getenv('ARCHIVE_USERSTATUS_ON_DELETE', 'true').lower() == 'true'
+        self.archive_userstatus_collection_name = os.getenv(
+            'ARCHIVE_USERSTATUS_COLLECTION_NAME',
+            "~archive_core_user_userstatuss"
+        )
+
+        # Initialize DB service
+        self._status_db_service = BaseFirestoreService[UserStatus](
+            db=self.db,
+            collection_name=self.status_collection_name,
+            resource_type=UserStatus.OBJ_REF,
+            model_class=UserStatus,
+            logger=self.logger,
+            timeout=self.timeout
+        )
+
+    async def get_userstatus(self, user_uid: str, convert_to_model: bool = True) -> Optional[UserStatus]:
+        """Retrieve a user status by UID"""
+        userstatus_id = f"{UserStatus.OBJ_REF}_{user_uid}"
+
+        try:
+            userstatus = await self._status_db_service.get_document(
+                userstatus_id,
+                convert_to_model=convert_to_model
+            )
+            if userstatus:
+                self.logger.debug("Successfully retrieved user status for %s", user_uid)
+                # Always return a UserStatus model to match the return type
+                if isinstance(userstatus, dict):
+                    return UserStatus(**userstatus)
+                return userstatus
+            else:
+                self.logger.debug("User status not found for %s", user_uid)
+                return None
+
+        except ResourceNotFoundError:
+            self.logger.debug("User status not found for %s", user_uid)
+            return None
+        except Exception as e:
+            self.logger.error("Failed to fetch user status for %s: %s", user_uid, str(e), exc_info=True)
+            raise UserStatusError(
+                detail=f"Failed to fetch user status: {str(e)}",
+                user_uid=user_uid,
+                operation="get_userstatus",
+                original_error=e
+            ) from e
+
+    async def create_userstatus(self, userstatus: UserStatus, creator_uid: Optional[str] = None) -> UserStatus:
+        """Create a new user status"""
+        self.logger.info(f"Creating user status for UID: {userstatus.user_uid}")
+        try:
+            doc_id = f"{UserStatus.OBJ_REF}_{userstatus.user_uid}"
+            effective_creator_uid = creator_uid or userstatus.user_uid
+            await self._status_db_service.create_document(doc_id, userstatus, effective_creator_uid)
+            self.logger.info("Successfully created user status for UID: %s", userstatus.user_uid)
+            return userstatus
+        except Exception as e:
+            self.logger.error("Error creating user status for %s: %s", userstatus.user_uid, e, exc_info=True)
+            raise UserStatusError(
+                detail=f"Failed to create user status: {str(e)}",
+                user_uid=userstatus.user_uid,
+                operation="create_userstatus",
+                original_error=e
+            ) from e
+
+    async def update_userstatus(self, user_uid: str, status_data: Dict[str, Any], updater_uid: str) -> UserStatus:
+        """Update a user status"""
+        userstatus_id = f"{UserStatus.OBJ_REF}_{user_uid}"
+
+        # Remove system fields that shouldn't be updated
+        update_data = status_data.copy()
+        update_data.pop('user_uid', None)
+        update_data.pop('id', None)
+        update_data.pop('created_at', None)
+        update_data.pop('created_by', None)
+
+        try:
+            updated_doc_dict = await self._status_db_service.update_document(
+                userstatus_id,
+                update_data,
+                updater_uid=updater_uid
+            )
+            self.logger.info("Userstatus for %s updated successfully by %s", user_uid, updater_uid)
+            return UserStatus(**updated_doc_dict)
+        except ResourceNotFoundError as exc:
+            raise UserStatusError(
+                detail="User status not found",
+                user_uid=user_uid,
+                operation="update_userstatus"
+            ) from exc
+        except Exception as e:
+            self.logger.error("Error updating Userstatus for %s: %s", user_uid, str(e), exc_info=True)
+            raise UserStatusError(
+                detail=f"Failed to update user status: {str(e)}",
+                user_uid=user_uid,
+                operation="update_userstatus",
+                original_error=e
+            ) from e
+
+    async def delete_userstatus(self, user_uid: str, updater_uid: str = "system_deletion", archive: Optional[bool] = True) -> bool:
+        """Delete (archive and delete) user status"""
+        status_doc_id = f"{UserStatus.OBJ_REF}_{user_uid}"
+        should_archive = archive if archive is not None else self.archive_userstatus_on_delete
+
+        try:
+            # Get status data for archival
+            status_data = await self._status_db_service.get_document(status_doc_id, convert_to_model=False)
+
+            if status_data:
+                # Ensure we have a dict for archival
+                status_dict = status_data if isinstance(status_data, dict) else status_data.__dict__
+
+                # Archive if enabled
+                if should_archive:
+                    await self._status_db_service.archive_document(
+                        document_data=status_dict,
+                        doc_id=status_doc_id,
+                        archive_collection=self.archive_userstatus_collection_name,
+                        archived_by=updater_uid
+                    )
+
+                # Delete the original document
+                await self._status_db_service.delete_document(status_doc_id)
+                self.logger.info("Successfully deleted user status: %s", status_doc_id)
+                return True
+            else:
+                self.logger.warning("User status %s not found for deletion", status_doc_id)
+                return True  # Consider non-existent as successfully deleted
+
+        except ResourceNotFoundError:
+            self.logger.debug("User status %s not found for deletion (idempotent)", status_doc_id)
+            return True  # Idempotent - already "deleted"
+        except Exception as e:
+            self.logger.error("Failed to delete user status %s: %s", status_doc_id, str(e), exc_info=True)
+            raise UserStatusError(
+                detail=f"Failed to delete user status: {str(e)}",
+                user_uid=user_uid,
+                operation="delete_userstatus",
+                original_error=e
+            ) from e
+
+    async def validate_userstatus_data(
+        self,
+        status_data: Optional[Dict[str, Any]] = None
+    ) -> tuple[bool, list[str]]:
+        """Validate user status data without creating documents"""
+        errors = []
+        if status_data:
+            try:
+                UserStatus(**status_data)
+            except PydanticValidationError as e:
+                errors.append(f"Status validation error: {str(e)}")
+        return len(errors) == 0, errors
+
+    async def validate_and_cleanup_user_permissions(
+        self, user_uid: str, updater_uid: str, delete_expired: bool = True
+    ) -> int:
+        """Validate and clean up expired IAM permissions for a user."""
+        userstatus = await self.get_userstatus(user_uid)
+        if not userstatus:
+            self.logger.warning("Userstatus not found for %s, cannot validate permissions.", user_uid)
+            return 0
+
+        removed_count = userstatus.cleanup_expired_permissions()
+
+        if removed_count > 0 and delete_expired:
+            await self.update_userstatus(
+                user_uid,
+                userstatus.model_dump(exclude_none=True),
+                updater_uid=updater_uid
+            )
+            self.logger.info("Removed %d expired permissions for user %s.", removed_count, user_uid)
+
+        return removed_count
+
+    async def userstatus_exists(self, user_uid: str) -> bool:
+        """Check if a user status exists."""
+        return await self._status_db_service.document_exists(f"{UserStatus.OBJ_REF}_{user_uid}")

ipulse_shared_core_ftredge/services/{charging_service.py → user_charging_service.py}

@@ -4,12 +4,12 @@ from typing import Dict, Any, Optional, Tuple
 from datetime import datetime, timezone
 from google.cloud import firestore
 from ipulse_shared_core_ftredge.exceptions import ServiceError, ResourceNotFoundError, ValidationError
-from ipulse_shared_core_ftredge.models.user_status import UserStatus
+from ipulse_shared_core_ftredge.models import UserStatus
 
 # Default Firestore timeout if not provided by the consuming application
 DEFAULT_FIRESTORE_TIMEOUT = 15.0
 
-class ChargingService:
+class UserChargingService:
     """
     Service class for charging operations.
     Designed to be project-agnostic and directly uses UserStatus model constants.
@@ -32,13 +32,13 @@ class ChargingService:
         self.db = db
         # Use UserStatus constants directly
         self.users_status_collection_name = UserStatus.COLLECTION_NAME
-        self.user_status_doc_prefix = f"{UserStatus.OBJ_REF}_" # Append underscore to OBJ_REF
+        self.userstatus_doc_prefix = f"{UserStatus.OBJ_REF}_" # Append underscore to OBJ_REF
         self.logger = logger or logging.getLogger(__name__)
         self.timeout = firestore_timeout
 
         self.logger.info(
             f"ChargingService initialized using UserStatus constants. Collection: {self.users_status_collection_name}, "
-            f"Doc Prefix: {self.user_status_doc_prefix}, Timeout: {self.timeout}s"
+            f"Doc Prefix: {self.userstatus_doc_prefix}, Timeout: {self.timeout}s"
         )
 
     async def verify_credits(
@@ -57,7 +57,7 @@ class ChargingService:
                                       (keys: 'sbscrptn_based_insight_credits', 'extra_insight_credits')
 
         Returns:
-            Tuple of (has_enough_credits, user_status_data) where user_status_data
+            Tuple of (has_enough_credits, userstatus_data) where userstatus_data
             will be a dict with keys 'sbscrptn_based_insight_credits' and 'extra_insight_credits'.
 
         Raises:
@@ -174,7 +174,7 @@ class ChargingService:
 
 
         try:
-            userstatus_id = f"{self.user_status_doc_prefix}{user_uid}"
+            userstatus_id = f"{self.userstatus_doc_prefix}{user_uid}"
             user_ref = self.db.collection(self.users_status_collection_name).document(userstatus_id)
 
             transaction = self.db.transaction()
@@ -277,7 +277,7 @@ class ChargingService:
     async def _get_userstatus(self, user_uid: str) -> Dict[str, Any]:
         """Get a user's status document."""
         try:
-            userstatus_id = f"{self.user_status_doc_prefix}{user_uid}"
+            userstatus_id = f"{self.userstatus_doc_prefix}{user_uid}"
             doc_ref = self.db.collection(self.users_status_collection_name).document(userstatus_id)
 
             # Using the timeout value set during initialization
@@ -285,7 +285,7 @@ class ChargingService:
 
             if not doc.exists:
                 raise ResourceNotFoundError(
-                    resource_type="user_status", # Generic resource type
+                    resource_type="userstatus", # Generic resource type
                     resource_id=userstatus_id,
                     additional_info={"collection": self.users_status_collection_name}
                 )
@@ -299,7 +299,7 @@ class ChargingService:
             raise ServiceError(
                 operation="getting user status",
                 error=e,
-                resource_type="user_status",
+                resource_type="userstatus",
                 resource_id=user_uid,
                 additional_info={"collection": self.users_status_collection_name}
             ) from e

{ipulse_shared_core_ftredge-20.0.1.dist-info → ipulse_shared_core_ftredge-22.1.1.dist-info}/METADATA

@@ -1,19 +1,18 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 20.0.1
+Version: 22.1.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
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.11
+Requires-Python: >=3.12
 License-File: LICENCE
 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==7.2.0
+Requires-Dist: ipulse_shared_base_ftredge==10.2.1
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page

ipulse_shared_core_ftredge-22.1.1.dist-info/RECORD

@@ -0,0 +1,51 @@
+ipulse_shared_core_ftredge/__init__.py,sha256=-KbdF_YW8pgf7pVv9qh_cA1xrNm_B9zigHYDo7ZA4eU,42
+ipulse_shared_core_ftredge/cache/__init__.py,sha256=i2fPojmZiBwAoY5ovnnnME9USl4bi8MRPYkAgEfACfI,136
+ipulse_shared_core_ftredge/cache/shared_cache.py,sha256=BDJtkTsdfmVjKaUkbBXOhJ2Oib7Li0UCsPjWX7FLIPU,12940
+ipulse_shared_core_ftredge/dependencies/__init__.py,sha256=HGsR8HUguKTfjz_BorCILS4izX8CAjG-apE0kIPE0Yo,68
+ipulse_shared_core_ftredge/dependencies/auth_firebase_token_validation.py,sha256=EFWyhoVOI0tGYOWqN5St4JNIy4cMwpxeBhKdjOwEfbg,1888
+ipulse_shared_core_ftredge/dependencies/auth_protected_router.py,sha256=em5D5tE7OkgZmuCtYCKuUAnIZCgRJhCF8Ye5QmtGWlk,1807
+ipulse_shared_core_ftredge/dependencies/authz_for_apis.py,sha256=TnJ2ubGUZRxRa6v-OLC2uCLzaoCuX1GkXSaFJMaYg0s,15793
+ipulse_shared_core_ftredge/dependencies/firestore_client.py,sha256=VbTb121nsc9EZPd1RDEsHBLW5pIiVw6Wdo2JFL4afMg,714
+ipulse_shared_core_ftredge/exceptions/__init__.py,sha256=Cb_RsIie4DbT_NLwFVwjw4riDKsNNRQEuAvHvYa-Zco,1038
+ipulse_shared_core_ftredge/exceptions/base_exceptions.py,sha256=RuihEpgXdUIR2XEXaP6aJnepePbvZ2RZYQwcKfatGPw,4981
+ipulse_shared_core_ftredge/exceptions/user_exceptions.py,sha256=I-nm21MKrUYEoybpRODeYNzc184HfgHvRZQm_xux4VY,6824
+ipulse_shared_core_ftredge/models/__init__.py,sha256=oaBL_BZWd7hIDu2K7yxtVKxtkOD9UF9r9_V2ZIPQ8Yk,350
+ipulse_shared_core_ftredge/models/base_api_response.py,sha256=OwuWI2PsMSLDkFt643u35ZhW5AHFEMMAGnGprmUO0fA,2380
+ipulse_shared_core_ftredge/models/base_data_model.py,sha256=GZ7KTT5FanHTgvmaHHTxawzAJtuixkbyb-SuL-mjWys,2193
+ipulse_shared_core_ftredge/models/catalog/__init__.py,sha256=9oKJ74_mTtmj-0iDnRBiPI8m8QJ2J9wvx4ZWaZw3zRk,208
+ipulse_shared_core_ftredge/models/catalog/subscriptionplan.py,sha256=5q1yUwy_755UNt7FZ4Ez-1njF0APSyzmiLbhGP1f2g0,9069
+ipulse_shared_core_ftredge/models/catalog/usertype.py,sha256=W42bis9l6_FL5Q3HY8pqxs1b0gkcIGgGYpLTOU6fYxE,6319
+ipulse_shared_core_ftredge/models/user/__init__.py,sha256=TheOLldY6v-OK9i-A5mQNIxjHhBFpuOJ43mi-swcN_o,196
+ipulse_shared_core_ftredge/models/user/user_permissions.py,sha256=CUWDBPLPmKN3o43BTZAt0zJvm_ekjJA46iV6rVNp-oc,2411
+ipulse_shared_core_ftredge/models/user/user_subscription.py,sha256=f0EFPtIQU_KKB3LO1MKZYraaxSdJp-FqeZDPKs2VP6E,8587
+ipulse_shared_core_ftredge/models/user/userauth.py,sha256=PbS-XSLxDl1feskI0iCziGvmMiLuF8o_ZTspAx1B0j0,3679
+ipulse_shared_core_ftredge/models/user/userprofile.py,sha256=7VbE4qiKpDxZsNTk-IJKA32QxW0JOo8KWPkj8h9J2-Y,6945
+ipulse_shared_core_ftredge/models/user/userstatus.py,sha256=NpSQWlbCnFRQ_Gnx7WLkyt3dKgRDf4-MRrJU5VYF7DA,16748
+ipulse_shared_core_ftredge/monitoring/__init__.py,sha256=gUoJjT0wj-cQYnMWheWbh1mmRHmaeojmnBZTj7KPNus,61
+ipulse_shared_core_ftredge/monitoring/tracemon.py,sha256=Trku0qrwWvEcvKsBWiYokd_G3fcH-5uP2wRVgcgIz_k,11596
+ipulse_shared_core_ftredge/services/__init__.py,sha256=9AkMLCHNswhuNbQuJZaEVz4zt4F84PxfJLyU_bYk4Js,565
+ipulse_shared_core_ftredge/services/charging_processors.py,sha256=9Re24dyXdjKYbqwx6uNLu3JBzIaw87TAV7Oe__M1QnA,16308
+ipulse_shared_core_ftredge/services/user_charging_service.py,sha256=C3wMfgBXOz4RM1RLc7up2_pIPAnZv8ZYu-lLrkofTmc,14625
+ipulse_shared_core_ftredge/services/base/__init__.py,sha256=zhyrHQMM0cLJr4spk2b6VsgJXuWBy7hUBzhrq_Seg9k,389
+ipulse_shared_core_ftredge/services/base/base_firestore_service.py,sha256=xXmPfDEgBa4trWMJz1UBJRDLPxi8TtG2jDFbo_B28pw,19313
+ipulse_shared_core_ftredge/services/base/cache_aware_firestore_service.py,sha256=ya5Asff9BQodYnJVAw6M_Pm8WtVRPpEK7izFlZ2MyjA,10016
+ipulse_shared_core_ftredge/services/catalog/__init__.py,sha256=ctc2nDGwsW_Ji4lk9pys3oyNwR_V-gHSbSHawym5fKQ,385
+ipulse_shared_core_ftredge/services/catalog/catalog_subscriptionplan_service.py,sha256=mbwCC1RnIZEav5i5sRGT15nxQJF0qMVA2LT8BAjmJuY,9264
+ipulse_shared_core_ftredge/services/catalog/catalog_usertype_service.py,sha256=pZdsRt9V96NcYTRremTf76fDL126lAiraxGs936i0aU,9959
+ipulse_shared_core_ftredge/services/user/__init__.py,sha256=jmkD5XzAmaD8QV2UsgB5xynGcfsXliWtRtN2pt6kzbA,884
+ipulse_shared_core_ftredge/services/user/firebase_auth_admin_helpers.py,sha256=7N-MWpCwzWCjIuIFXGv1sIjJJcU9M92nWOfRyMEuHbE,5430
+ipulse_shared_core_ftredge/services/user/user_core_service.py,sha256=9nhFgFVPp188JMiZYINLwyHGtUYqtbHZhIR6cQMhj00,23648
+ipulse_shared_core_ftredge/services/user/user_multistep_operations.py,sha256=hQ1-BygC2Cxin6AUsEVgEWfZg035v5yn__sAoPzy0Us,35543
+ipulse_shared_core_ftredge/services/user/user_permissions_operations.py,sha256=FByszIWo-qooLVXFTw0tGLWksIJEqHUPc_ZGwue0_pM,15753
+ipulse_shared_core_ftredge/services/user/user_subscription_operations.py,sha256=h5jz4jvnwocDIwHa5VUX3_u4Qzrkt5A1s06aL5Bafm0,21266
+ipulse_shared_core_ftredge/services/user/userauth_operations.py,sha256=9l2uBAcAxbUnilK8MZ7IlHzaGiaPuqx7nIC51mAyR9w,36120
+ipulse_shared_core_ftredge/services/user/userprofile_operations.py,sha256=_qyIEAQYCTV-subgP-5naMs_26apCpauomE6qmCCVWs,7333
+ipulse_shared_core_ftredge/services/user/userstatus_operations.py,sha256=Gz2P4toJNs3ZMpGBvmN0HfiFqonRv6G3jTKkDz7mjuA,8927
+ipulse_shared_core_ftredge/utils/__init__.py,sha256=JnxUb8I2MRjJC7rBPXSrpwBIQDEOku5O9JsiTi3oun8,56
+ipulse_shared_core_ftredge/utils/custom_json_encoder.py,sha256=DblQLD0KOSNDyQ58wQRogBrShIXzPIZUw_oGOBATnJY,1366
+ipulse_shared_core_ftredge/utils/json_encoder.py,sha256=QkcaFneVv3-q-s__Dz4OiUWYnM6jgHDJrDMdPv09RCA,2093
+ipulse_shared_core_ftredge-22.1.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
+ipulse_shared_core_ftredge-22.1.1.dist-info/METADATA,sha256=Q-CLpF1xpkRoIMZ5ab17rGskMnkPdA6M04e0qj8yqHI,782
+ipulse_shared_core_ftredge-22.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ipulse_shared_core_ftredge-22.1.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
+ipulse_shared_core_ftredge-22.1.1.dist-info/RECORD,,