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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 16.0.1
+Version: 19.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-19.0.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+python_classes = ["Test*", "!TestModel"]
+addopts = [
+    "-v",
+    "--tb=short",
+    "--strict-markers",
+    "--disable-warnings"
+]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_functions = ["test_*"]

{ipulse_shared_core_ftredge-16.0.1 → ipulse_shared_core_ftredge-19.0.1}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='ipulse_shared_core_ftredge',
-    version='16.0.1',
+    version='19.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-19.0.1/src/ipulse_shared_core_ftredge/__init__.py

@@ -0,0 +1 @@
+# pylint: disable=missing-module-docstring

{ipulse_shared_core_ftredge-16.0.1 → ipulse_shared_core_ftredge-19.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-19.0.1/src/ipulse_shared_core_ftredge/exceptions/__init__.py

@@ -0,0 +1,47 @@
+"""
+Exception module for ipulse_shared_core_ftredge
+
+This module centralizes all exceptions to prevent circular import dependencies.
+All services import exceptions from here instead of from each other.
+"""
+
+# Import all exceptions from submodules
+from .base_exceptions import (
+    BaseServiceException,
+    ServiceError,
+    ValidationError,
+    ResourceNotFoundError,
+    AuthorizationError
+)
+
+from .user_exceptions import (
+    UserCoreError,
+    UserCreationError,
+    UserDeletionError,
+    UserValidationError,
+    UserProfileError,
+    UserStatusError,
+    UserAuthError,
+    SubscriptionError,
+    IAMPermissionError
+)
+
+__all__ = [
+    # Base exceptions
+    'BaseServiceException',
+    'ServiceError',
+    'ValidationError',
+    'ResourceNotFoundError',
+    'AuthorizationError',
+
+    # User-specific exceptions
+    'UserCoreError',
+    'UserCreationError',
+    'UserDeletionError',
+    'UserValidationError',
+    'UserProfileError',
+    'UserStatusError',
+    'UserAuthError',
+    'SubscriptionError',
+    'IAMPermissionError'
+]

ipulse_shared_core_ftredge-19.0.1/src/ipulse_shared_core_ftredge/exceptions/user_exceptions.py

@@ -0,0 +1,219 @@
+"""Custom exceptions for UserCoreService operations"""
+from typing import Optional, Dict, Any
+from .base_exceptions import BaseServiceException
+
+
+class UserCoreError(BaseServiceException):
+    """Base exception for UserCore operations"""
+    def __init__(
+        self,
+        detail: str,
+        user_uid: Optional[str] = None,
+        operation: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        super().__init__(
+            status_code=500,
+            detail=detail,
+            resource_type="UserCore",
+            resource_id=user_uid,
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.operation = operation
+
+
+class UserProfileError(UserCoreError):
+    """Exception for UserProfile operations"""
+    def __init__(
+        self,
+        detail: str,
+        user_uid: Optional[str] = None,
+        operation: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        super().__init__(
+            detail=detail,
+            user_uid=user_uid,
+            operation=operation,
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.resource_type = "UserProfile"
+
+
+class UserStatusError(UserCoreError):
+    """Exception for UserStatus operations"""
+    def __init__(
+        self,
+        detail: str,
+        user_uid: Optional[str] = None,
+        operation: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        super().__init__(
+            detail=detail,
+            user_uid=user_uid,
+            operation=operation,
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.resource_type = "UserStatus"
+
+
+class UserAuthError(UserCoreError):
+    """Exception for Firebase Auth operations"""
+    def __init__(
+        self,
+        detail: str,
+        user_uid: Optional[str] = None,
+        operation: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        super().__init__(
+            detail=detail,
+            user_uid=user_uid,
+            operation=operation,
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.resource_type = "UserAuth"
+
+
+class SubscriptionError(UserCoreError):
+    """Exception for subscription operations"""
+    def __init__(
+        self,
+        detail: str,
+        user_uid: Optional[str] = None,
+        plan_id: Optional[str] = None,
+        operation: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        additional_info = additional_info or {}
+        if plan_id:
+            additional_info['plan_id'] = plan_id
+
+        super().__init__(
+            detail=detail,
+            user_uid=user_uid,
+            operation=operation,
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.resource_type = "Subscription"
+        self.plan_id = plan_id
+
+
+class IAMPermissionError(UserCoreError):
+    """Exception for IAM permission operations"""
+    def __init__(
+        self,
+        detail: str,
+        user_uid: Optional[str] = None,
+        domain: Optional[str] = None,
+        permission: Optional[str] = None,
+        operation: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        additional_info = additional_info or {}
+        if domain:
+            additional_info['domain'] = domain
+        if permission:
+            additional_info['permission'] = permission
+
+        super().__init__(
+            detail=detail,
+            user_uid=user_uid,
+            operation=operation,
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.resource_type = "IAMPermission"
+        self.domain = domain
+        self.permission = permission
+
+
+class UserCreationError(UserCoreError):
+    """Exception for user creation operations"""
+    def __init__(
+        self,
+        detail: str,
+        email: Optional[str] = None,
+        user_uid: Optional[str] = None,
+        failed_component: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        additional_info = additional_info or {}
+        if email:
+            additional_info['email'] = email
+        if failed_component:
+            additional_info['failed_component'] = failed_component
+
+        super().__init__(
+            detail=detail,
+            user_uid=user_uid,
+            operation="create_user",
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.resource_type = "UserCreation"
+        self.email = email
+        self.failed_component = failed_component
+
+
+class UserDeletionError(UserCoreError):
+    """Exception for user deletion operations"""
+    def __init__(
+        self,
+        detail: str,
+        user_uid: Optional[str] = None,
+        deletion_target: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        additional_info = additional_info or {}
+        if deletion_target:
+            additional_info['deletion_target'] = deletion_target
+
+        super().__init__(
+            detail=detail,
+            user_uid=user_uid,
+            operation="delete_user",
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.resource_type = "UserDeletion"
+        self.deletion_target = deletion_target
+
+
+class UserValidationError(UserCoreError):
+    """Exception for user data validation"""
+    def __init__(
+        self,
+        detail: str,
+        user_uid: Optional[str] = None,
+        validation_field: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        additional_info = additional_info or {}
+        if validation_field:
+            additional_info['validation_field'] = validation_field
+
+        super().__init__(
+            detail=detail,
+            user_uid=user_uid,
+            operation="validate_user_core_data",
+            additional_info=additional_info,
+            original_error=original_error
+        )
+        self.resource_type = "UserValidation"
+        self.validation_field = validation_field

{ipulse_shared_core_ftredge-16.0.1 → ipulse_shared_core_ftredge-19.0.1}/src/ipulse_shared_core_ftredge/models/__init__.py

@@ -1,10 +1,8 @@
 from .user_profile import UserProfile
 from .subscription import Subscription
 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-16.0.1 → ipulse_shared_core_ftredge-19.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-16.0.1 → ipulse_shared_core_ftredge-19.0.1}/src/ipulse_shared_core_ftredge/models/base_data_model.py

@@ -1,12 +1,13 @@
 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
 
 class BaseDataModel(BaseModel):
     """Base model with common fields and configuration"""
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=False, extra="forbid")
 
     # Required class variables that must be defined in subclasses
     VERSION: ClassVar[float]
@@ -17,13 +18,13 @@ class BaseDataModel(BaseModel):
     schema_version: float = Field(
         ...,  # Make this required
         description="Version of this Class == version of DB Schema",
-        frozen=True
+        frozen=True  # Keep schema version frozen for data integrity
     )
 
-    # Audit fields
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), frozen=True)
-    created_by: str = Field(..., frozen=True)
-    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), frozen=True)
+    # Audit fields - now mutable for updates
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    created_by: str = Field(...)
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     updated_by: str = Field(...)
 
     @classmethod

ipulse_shared_core_ftredge-19.0.1/src/ipulse_shared_core_ftredge/models/user_auth.py

@@ -0,0 +1,64 @@
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+from pydantic import BaseModel, Field, EmailStr, ConfigDict, field_validator
+
+class UserAuth(BaseModel):
+    """Comprehensive authentication model for user credentials and auth operations"""
+    model_config = ConfigDict(extra="forbid")
+
+    # Core authentication fields
+    email: EmailStr = Field(..., description="User's email address")
+    password: Optional[str] = Field(None, min_length=6, description="User's password (for creation/update only)")
+
+    # Firebase Auth specific fields
+    firebase_uid: Optional[str] = Field(None, description="Firebase Auth UID")
+    provider_id: str = Field(default="password", description="Authentication provider ID")
+    email_verified: bool = Field(default=False, description="Whether email is verified")
+    disabled: bool = Field(default=False, description="Whether user account is disabled")
+
+    # Multi-factor authentication
+    mfa_enabled: bool = Field(default=False, description="Whether MFA is enabled")
+    phone_number: Optional[str] = Field(None, description="Phone number for SMS MFA")
+
+    # Custom claims and metadata
+    custom_claims: Dict[str, Any] = Field(default_factory=dict, description="Firebase custom claims")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional authentication metadata")
+
+    # Provider data
+    provider_data: List[Dict[str, Any]] = Field(default_factory=list, description="Provider-specific data")
+
+    # Account management
+    created_at: Optional[datetime] = Field(None, description="Account creation timestamp")
+    last_sign_in: Optional[datetime] = Field(None, description="Last sign-in timestamp")
+    last_refresh: Optional[datetime] = Field(None, description="Last token refresh timestamp")
+
+    # Password management
+    password_hash: Optional[str] = Field(None, description="Password hash (internal use only)")
+    password_salt: Optional[str] = Field(None, description="Password salt (internal use only)")
+    valid_since: Optional[datetime] = Field(None, description="Timestamp since when tokens are valid")
+
+    @field_validator('phone_number')
+    @classmethod
+    def validate_phone_number(cls, v: Optional[str]) -> Optional[str]:
+        """Validate phone number format if provided"""
+        if v is None:
+            return v
+        # Basic E.164 format validation
+        if not v.startswith('+') or not v[1:].isdigit() or len(v) < 8 or len(v) > 16:
+            raise ValueError('Phone number must be in E.164 format (+1234567890)')
+        return v
+
+    @field_validator('custom_claims')
+    @classmethod
+    def validate_custom_claims(cls, v: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate custom claims don't contain reserved Firebase claims"""
+        reserved_claims = {
+            'iss', 'aud', 'auth_time', 'user_id', 'sub', 'iat', 'exp', 'email',
+            'email_verified', 'phone_number', 'name', 'picture', 'firebase'
+        }
+
+        for claim in v.keys():
+            if claim in reserved_claims:
+                raise ValueError(f'Custom claim "{claim}" is reserved by Firebase')
+
+        return v

{ipulse_shared_core_ftredge-16.0.1 → ipulse_shared_core_ftredge-19.0.1}/src/ipulse_shared_core_ftredge/models/user_profile.py

@@ -4,6 +4,7 @@ from typing import Set, Optional, ClassVar, Dict, Any, List
 from pydantic import EmailStr, Field, ConfigDict, field_validator, model_validator, computed_field
 from ipulse_shared_base_ftredge import Layer, Module, list_as_lower_strings, Subject
 from .base_data_model import BaseDataModel
+import re  # Add re import
 
 # ORIGINAL AUTHOR ="Russlan Ramdowar;russlan@ftredge.com"
 # CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
@@ -27,7 +28,7 @@ class UserProfile(BaseDataModel):
     )
 
     id: str = Field(
-        ...,  # Required, but will be auto-generated if not provided
+        default="",  # Will be auto-generated from user_uid if not provided
         description=f"User Profile ID, format: {OBJ_REF}_user_uid"
     )
 
@@ -42,7 +43,7 @@ class UserProfile(BaseDataModel):
         description="Primary user type (e.g., customer, internal, admin, superadmin)"
     )
 
-    # Renamed user_types to secondary_usertypes
+    # Renamed usertypes to secondary_usertypes
     secondary_usertypes: List[str] = Field(
         default_factory=list,
         description="List of secondary user types"
@@ -71,11 +72,11 @@ class UserProfile(BaseDataModel):
     )
 
     # User-editable fields
-    username: Optional[str] = Field(
-        default=None,
-        max_length=50,
-        pattern="^[a-zA-Z0-9_-]+$",
-        description="Username (public display name)"
+    username: str = Field(
+        default="",  # Made optional with empty default - will be auto-generated
+        max_length=12,  # Updated to 12 characters
+        pattern="^[a-zA-Z0-9_]+$",  # Allow underscore
+        description="Username (public display name), max 12 chars, alphanumeric and underscore. Auto-generated from email if not provided."
     )
     dob: Optional[date] = Field(
         default=None,
@@ -122,4 +123,37 @@ class UserProfile(BaseDataModel):
         if 'user_uid' in data and data['user_uid']:
             data['id'] = f"{cls.OBJ_REF}_{data['user_uid']}"
 
+        return data
+
+    @model_validator(mode='before')
+    @classmethod
+    def populate_username(cls, data: Any) -> Any:
+        """
+        Generates or sanitizes the username.
+        If username is provided and non-empty, it's sanitized and truncated to 10 chars.
+        If not provided or empty, it's generated from the email (part before '@'),
+        sanitized, and truncated to 10 chars.
+        If no email is available, generates a default username.
+        """
+        if not isinstance(data, dict):
+            # Not a dict, perhaps an instance already, skip
+            return data
+
+        email = data.get('email')
+        username = data.get('username')
+
+        # Check if username is provided and non-empty
+        if username and isinstance(username, str) and username.strip():
+            # Sanitize and truncate provided username
+            sanitized_username = re.sub(r'[^a-zA-Z0-9_]', '', username)
+            data['username'] = sanitized_username[:12] if sanitized_username else "user"
+        elif email and isinstance(email, str):
+            # Generate from email
+            email_prefix = email.split('@')[0]
+            sanitized_prefix = re.sub(r'[^a-zA-Z0-9_]', '', email_prefix)
+            data['username'] = sanitized_prefix[:12] if sanitized_prefix else "user"
+        else:
+            # Fallback if no email or username provided
+            data['username'] = "user"
+
         return data