ipulse-shared-core-ftredge 3.2.3__tar.gz → 5.1.1__tar.gz

{ipulse_shared_core_ftredge-3.2.3/src/ipulse_shared_core_ftredge.egg-info → ipulse_shared_core_ftredge-5.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ipulse_shared_core_ftredge
-Version: 3.2.3
+Version: 5.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

{ipulse_shared_core_ftredge-3.2.3 → ipulse_shared_core_ftredge-5.1.1}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='ipulse_shared_core_ftredge',
-    version='3.2.3',
+    version='5.1.1',
     package_dir={'': 'src'},  # Specify the source directory
     packages=find_packages(where='src'),  # Look for packages in 'src'
     install_requires=[

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/__init__.py

@@ -0,0 +1,9 @@
+# pylint: disable=missing-module-docstring
+from .models import ( UserAuth, UserProfile,Subscription,
+                     UserStatus, UserProfileUpdate,
+                     Organisation, StandardResponse )
+
+
+
+from .services import (BaseFirestoreService,BaseServiceException, ResourceNotFoundError, AuthorizationError,
+                            ValidationError)

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/dependencies/__init__.py

@@ -0,0 +1 @@
+from .token_validation import verify_firebase_token

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/dependencies/auth_router.py

@@ -0,0 +1,58 @@
+from typing import Callable, Optional, List
+from fastapi import APIRouter, Depends
+from .token_validation import verify_firebase_token
+
+def create_protected_router(
+    *,
+    prefix: str = "",
+    tags: Optional[List[str]] = None,
+    public_paths: Optional[List[str]] = None
+) -> APIRouter:
+    """
+    Creates an APIRouter with authentication enabled by default.
+    
+    Args:
+        prefix: Router prefix
+        tags: OpenAPI tags
+        public_paths: List of paths that should be public (no auth required)
+        
+    Example:
+        router = create_protected_router(
+            prefix="/api/v1",
+            tags=["users"],
+            public_paths=["/health", "/docs"]
+        )
+    """
+    public_paths = public_paths or []
+    router = APIRouter(prefix=prefix, tags=tags)
+    
+    # Store the original route registration method
+    original_add_api_route = router.add_api_route
+    
+    def add_api_route_with_auth(
+        path: str,
+        endpoint: Callable,
+        *args,
+        dependencies: List = None,
+        **kwargs
+    ):
+        # If path is not in public_paths, add authentication dependency
+        if path not in public_paths:
+            dependencies = dependencies or []
+            # Fix: Check if verify_firebase_token is already in dependencies
+            if not any(getattr(dep.dependency, '__name__', None) == 'verify_firebase_token' 
+                      for dep in dependencies):
+                dependencies.append(Depends(verify_firebase_token))
+        
+        return original_add_api_route(
+            path,
+            endpoint,
+            *args,
+            dependencies=dependencies,
+            **kwargs
+        )
+    
+    # Replace the route registration method with our custom one
+    router.add_api_route = add_api_route_with_auth  # type: ignore
+    
+    return router

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/dependencies/authorization_api.py

@@ -0,0 +1,260 @@
+import os
+import logging
+from typing import Optional, Iterable, Dict, Any, List
+from datetime import datetime, timedelta, timezone
+import httpx
+from fastapi import HTTPException, Request
+from google.cloud import firestore
+from ipulse_shared_core_ftredge.services.exceptions import ServiceError, AuthorizationError, ResourceNotFoundError
+
+# Constants
+USERS_STATUS_COLLECTION_NAME = "user-statuses"
+USERS_STATUS_DOC_REF = "userusrsttus_"
+CACHE_TTL = 60 # 60 seconds
+class UserStatusCache:
+    """Manages user status caching with dynamic invalidation"""
+    def __init__(self):
+        self._cache: Dict[str, Dict[str, Any]] = {}
+        self._timestamps: Dict[str, datetime] = {}
+        
+    def get(self, user_uid: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieves user status from cache if available and valid.
+
+        Args:
+            user_uid (str): The user ID.
+            
+        """
+        if user_uid in self._cache:
+            status_data = self._cache[user_uid]
+            # Force refresh for credit-consuming or sensitive operations
+            # Check TTL for normal operations
+            if datetime.now() - self._timestamps[user_uid] < timedelta(seconds=CACHE_TTL):
+                return status_data
+            self.invalidate(user_uid)
+        return None
+    
+    def set(self, user_uid: str, data: Dict[str, Any]) -> None:
+        """
+        Sets user status data in the cache.
+
+        Args:
+            user_uid (str): The user ID.
+            data (Dict[str, Any]): The user status data to cache.
+        """
+        self._cache[user_uid] = data
+        self._timestamps[user_uid] = datetime.now()
+    
+    def invalidate(self, user_uid: str) -> None:
+        """
+        Invalidates (removes) user status from the cache.
+
+        Args:
+            user_uid (str): The user ID to invalidate.
+        """
+        self._cache.pop(user_uid, None)
+        self._timestamps.pop(user_uid, None)
+
+# Global cache instance
+user_status_cache = UserStatusCache()
+
+# Replace the logger dependency with a standard logger
+logger = logging.getLogger(__name__)
+
+async def get_user_status(
+    user_uid: str, 
+    db: firestore.Client,  # Note: This expects the actual client, not a Depends
+    force_fresh: bool = False
+) -> tuple[Dict[str, Any], bool]:
+    """
+    Fetch user status with intelligent caching
+    """
+    cache_used = False
+    if not force_fresh:
+        cached_status = user_status_cache.get(user_uid)
+        if cached_status:
+            cache_used = True
+            return cached_status, cache_used
+
+    try:
+        # Get reference to the document
+        user_status_id = USERS_STATUS_DOC_REF + user_uid
+        user_ref = db.collection(USERS_STATUS_COLLECTION_NAME).document(user_status_id)
+        
+        # Get the document
+        snapshot = user_ref.get()
+        if not snapshot.exists:
+            raise ResourceNotFoundError(
+                resource_type="user_status",
+                resource_id=user_status_id,
+                additional_info={"user_uid": user_uid}
+            )
+        
+        status_data = snapshot.to_dict()
+        
+        # Only cache if not forced fresh
+        if not force_fresh:
+            user_status_cache.set(user_uid, status_data)
+        return status_data, cache_used
+        
+    except ResourceNotFoundError:
+        raise
+    except Exception as e:
+        raise ServiceError(
+            operation=f"fetching user status",
+            error=e,
+            resource_type="user_status",
+            resource_id=user_uid,
+            additional_info={
+                "force_fresh": force_fresh,
+                "collection": USERS_STATUS_COLLECTION_NAME
+            }
+        ) from e
+
+def _validate_resource_fields(fields: Dict[str, Any]) -> List[str]:
+    """
+    Filter out invalid fields similar to BaseFirestoreService validation.
+    Returns only fields that have actual values to update.
+    """
+    valid_fields = {
+        k: v for k, v in fields.items()
+        if v is not None and not (isinstance(v, (list, dict, set)) and len(v) == 0)
+    }
+    return list(valid_fields.keys())
+
+async def extract_request_fields(request: Request) -> Optional[List[str]]:
+    """
+    Extract fields from request body for both PATCH and POST methods.
+    """
+    try:
+        body = await request.json()
+        if isinstance(body, dict):
+            if request.method == "PATCH":
+                return _validate_resource_fields(body)
+            elif request.method == "POST":
+                # For POST, we want to include all fields being set
+                return list(body.keys())
+        elif hasattr(body, 'model_dump'):
+            data = body.model_dump(exclude_unset=True)
+            if request.method == "PATCH":
+                return _validate_resource_fields(data)
+            elif request.method == "POST":
+                return list(data.keys())
+        
+        return None
+            
+    except Exception as e:
+        logger.error(f"Error extracting fields from request body: {str(e)}")
+        return None
+
+async def authorizeAPIRequest(
+    request: Request,
+    db: firestore.Client,  # Changed: Now expects actual client instance
+    request_resource_fields: Optional[Iterable[str]] = None,
+) -> Dict[str, Any]:
+    """
+    Authorize API request based on user status and OPA policies.
+    Note: This expects an actual Firestore client instance, not a dependency.
+    """
+    try:
+        # Extract fields for both PATCH and POST if not provided
+        if not request_resource_fields:
+            request_resource_fields = await extract_request_fields(request)
+
+        # Extract request context
+        user_uid = request.state.user.get('uid')
+        if not user_uid:
+            raise AuthorizationError(
+                action="access API",
+                additional_info={"path": str(request.url)}
+            )
+
+
+        # Determine if we need fresh status
+        force_fresh = _should_force_fresh_status(request)
+        user_status, cache_used = await get_user_status(user_uid, db, force_fresh=force_fresh)
+        
+        # Prepare authorization input
+        auth_input = {
+            "api_url": request.url.path,
+            "requestor": {
+                "uid": user_uid,
+                "usertypes": request.state.user.get("usertypes"),
+                "email_verified": request.state.user.get("email_verified"),
+                "iam_groups": user_status.get("iam_groups"),
+                "active_sbscrptn_plan": user_status.get("active_sbscrptn_plan"),
+                "active_sbscrptn_status": user_status.get("sbscrptn_status"),
+                "sbscrptn_insight_credits": user_status.get("sbscrptn_insight_credits"),
+            },
+            "method": request.method.lower(),
+            "request_resource_fields": request_resource_fields
+        }
+
+        # Query OPA
+        opa_url = f"{os.getenv('OPA_SERVER_URL', 'http://localhost:8181')}{os.getenv('OPA_DECISION_PATH', '/v1/data/http/authz/ingress/decision')}"
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                opa_url,
+                json={"input": auth_input},
+                timeout=5.0  # 5 seconds timeout
+            )
+            
+            if response.status_code != 200:
+                logger.error(f"OPA authorization failed: {response.text}")
+                raise HTTPException(
+                    status_code=500,
+                    detail="Authorization service error"
+                )
+
+            result = response.json()
+            if not result.get("result", {}).get("allow", False):
+                raise AuthorizationError(
+                    action=f"{request.method} {request.url.path}",
+                    additional_info={
+                        "user_uid": user_uid,
+                        "resource_fields": request_resource_fields
+                    }
+                )
+
+        # More descriptive metadata about the data freshness
+        return {
+            "used_cached_status": cache_used,
+            "required_fresh_status": force_fresh,
+            "status_retrieved_at": datetime.now(timezone.utc).isoformat()
+        }
+
+    except (AuthorizationError, ResourceNotFoundError):
+        raise
+    except Exception as e:
+        raise ServiceError(
+            operation="API authorization",
+            error=e,
+            resource_type="authorization",
+            additional_info={
+                "path": str(request.url),
+                "method": request.method,
+                "user_uid": request.state.user.get('uid'),
+                "resource_fields": request_resource_fields
+            }
+        )
+
+def _should_force_fresh_status(request: Request) -> bool:
+    """
+    Determine if we should force a fresh status check based on the request path patterns
+    and HTTP methods
+    """
+    # Path patterns that indicate credit-sensitive operations
+    credit_sensitive_patterns = [
+        'prediction',
+        'user-statuses',
+    ]
+    # Methods that require fresh status
+    sensitive_methods = {'post', 'patch', 'put', 'delete'}
+    
+    path = request.url.path.lower()
+    method = request.method.lower()
+    
+    return (
+        any(pattern in path for pattern in credit_sensitive_patterns) or
+        method in sensitive_methods
+    )

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/dependencies/database.py

@@ -0,0 +1,19 @@
+from typing import Annotated
+from fastapi import Depends
+from google.cloud import firestore
+from functools import lru_cache
+import logging
+
+logger = logging.getLogger(__name__)
+
+@lru_cache()
+def get_db() -> firestore.Client:
+    """
+    Dependency function to inject the Firestore client.
+    Each service implementing this should override this function with their own Firebase initialization.
+    """
+    logger.info("Base get_db dependency called - this should be overridden by the implementing service")
+    return firestore.Client()
+
+# Base type for dependency injection that services will implement
+FirestoreDB = Annotated[firestore.Client, Depends(get_db)]

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/dependencies/token_validation.py

@@ -0,0 +1,59 @@
+from typing import Optional, Annotated
+from fastapi import Request, HTTPException, Depends, Header
+from firebase_admin import auth
+
+class AuthenticatedUser:
+    """
+    Represents an authenticated user with necessary attributes.
+    """
+    def __init__(self, uid: str, email: str, email_verified: bool, usertypes: list[str]):
+        self.uid = uid
+        self.email = email
+        self.email_verified = email_verified
+        self.usertypes = usertypes
+
+async def verify_firebase_token(
+    request: Request,
+    x_forwarded_authorization: Optional[str] = Header(None),
+    authorization: Optional[str] = Header(None)
+) -> AuthenticatedUser:
+    """
+    Represents an authenticated user with necessary attributes.
+    """
+    # Get token from either x-forwarded-authorization or authorization header
+    token = x_forwarded_authorization or authorization
+    
+    if not token:
+        raise HTTPException(
+            status_code=401,
+            detail="Authorization token is missing"
+        )
+
+    try:
+        # Remove 'Bearer ' prefix if present
+        token = token.replace("Bearer ", "")
+        # Verify the token
+        decoded_token = auth.verify_id_token(token)
+        
+        # Create AuthenticatedUser instance
+        user = AuthenticatedUser(
+            uid=decoded_token.get('uid'),
+            email=decoded_token.get('email'),
+            email_verified=decoded_token.get('email_verified', False),
+            usertypes=decoded_token.get('usertypes', [])
+        )
+        
+        # Store user in request state for use in other parts of the application
+        request.state.user = decoded_token
+        
+        return user
+
+    except Exception as e:
+        raise HTTPException(
+            status_code=401,
+            detail=f"Invalid token: {str(e)}"
+        )
+
+# Type alias for dependency injection
+AuthUser = Annotated[AuthenticatedUser, Depends(verify_firebase_token)]
+

{ipulse_shared_core_ftredge-3.2.3 → ipulse_shared_core_ftredge-5.1.1}/src/ipulse_shared_core_ftredge/models/__init__.py

@@ -1,8 +1,10 @@
 from .user_profile import UserProfile
+from .subscription import Subscription
 from .user_status import UserStatus
 from .user_profile_update import UserProfileUpdate
 from .user_auth import UserAuth
 from .organisation import Organisation
+from .api_response import StandardResponse
 
 
 

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/models/api_response.py

@@ -0,0 +1,37 @@
+from typing import Generic, TypeVar, Optional, Any, Dict, List
+from pydantic import BaseModel, ConfigDict
+import datetime as dt
+from fastapi.responses import JSONResponse
+from ipulse_shared_core_ftredge.utils.json_encoder import CustomJSONEncoder
+import json
+
+
+T = TypeVar('T')
+
+class StandardResponse(BaseModel, Generic[T]):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    success: bool
+    data: Optional[T] = None
+    message: Optional[str] = None
+    error: Optional[str] = None
+
+    metadata: Dict[str, Any] = {
+        "timestamp": dt.datetime.now(dt.timezone.utc).isoformat()
+    }
+
+class PaginatedResponse(StandardResponse, Generic[T]):
+    total_count: int
+    page: int
+    page_size: int
+    items: List[T]
+
+class CustomJSONResponse(JSONResponse):
+    def render(self, content) -> bytes:
+        return json.dumps(
+            content,
+            ensure_ascii=False,
+            allow_nan=False,
+            indent=None,
+            separators=(",", ":"),
+            default=CustomJSONEncoder().default
+        ).encode("utf-8")

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/models/subscription.py

@@ -0,0 +1,34 @@
+from datetime import datetime, timezone
+from dateutil.relativedelta import relativedelta
+from typing import Set, Optional, Dict, List, ClassVar
+from pydantic import BaseModel, Field, ConfigDict
+from ipulse_shared_base_ftredge import Layer, Module, list_as_lower_strings
+# ORIGINAL AUTHOR ="Russlan Ramdowar;russlan@ftredge.com"
+# CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
+
+
+DEFAULT_SUBSCRIPTION_PLAN="subscription_free"
+DEFAULT_SUBSCRIPTION_STATUS="active"
+
+############################################ !!!!! ALWAYS UPDATE SCHEMA VERSION , IF SCHEMA IS BEING MODIFIED !!! ############################################
+class Subscription(BaseModel):
+    """
+    Represents a single subscription cycle.
+    """
+    plan_name: str = Field(
+        default=DEFAULT_SUBSCRIPTION_PLAN,
+        description="Subscription Plan Name"
+    )
+
+    cycle_start_date: datetime = Field(
+        default=datetime.now(timezone.utc),
+        description="Subscription Cycle Start Date"
+    )
+    cycle_end_date: datetime = Field(
+        default=lambda: datetime.now(timezone.utc) + relativedelta(years=1),
+        description="Subscription Cycle End Date"
+    )
+    status: str = Field(
+        default=DEFAULT_SUBSCRIPTION_STATUS,
+        description="Subscription Status (active, inactive, etc.)"
+    )

{ipulse_shared_core_ftredge-3.2.3 → ipulse_shared_core_ftredge-5.1.1}/src/ipulse_shared_core_ftredge/models/user_profile.py

@@ -1,7 +1,11 @@
 from datetime import datetime, date
 from typing import Set, Optional, ClassVar
 from pydantic import BaseModel, EmailStr, Field, ConfigDict
+from ipulse_shared_base_ftredge import Layer, Module, list_as_lower_strings
 
+# # Revision history (as model metadata)
+# CLASS_ORIGIN_AUTHOR: ClassVar[str] = "Russlan Ramdowar;russlan@ftredge.com"
+# CLASS_ORGIN_DATE: ClassVar[datetime] = datetime(2024, 1, 16, 20, 5)
 class UserProfile(BaseModel):
     """
     User Profile model representing user information and metadata.
@@ -11,12 +15,11 @@ class UserProfile(BaseModel):
 
     # Metadata as class variables
     VERSION: ClassVar[float] = 3.01
-    DOMAIN: ClassVar[str] = "user"
-    OBJ_REF: ClassVar[str] = "usprfl"
+    DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name))
     
     # System-managed fields (read-only)
     schema_version: float = Field(
-        default=3.01,
+        default=VERSION,
         description="Version of this Class == version of DB Schema",
         frozen=True
     )
@@ -66,11 +69,4 @@ class UserProfile(BaseModel):
         default=None,
         pattern=r"^\+?[1-9]\d{1,14}$",  # Added 'r' prefix for raw string
         description="E.164 format phone number"
-    )
-
-    # Revision history (as model metadata)
-    CLASS_ORIGIN_AUTHOR: ClassVar[str] = "Russlan Ramdowar;russlan@ftredge.com"
-    CLASS_ORGIN_DATE: ClassVar[datetime] = datetime(2024, 1, 16, 20, 5)
-    CLASS_REVISION_AUTHOR: ClassVar[str] = "Russlan Ramdowar;russlan@ftredge.com"
-    CLASS_REVISION_DATE: ClassVar[datetime] = datetime(2024, 2, 13, 20, 15)
-    LAST_MODIFICATION: ClassVar[str] = "Updated to Pydantic v2 with improved validation"
+    )

{ipulse_shared_core_ftredge-3.2.3 → ipulse_shared_core_ftredge-5.1.1}/src/ipulse_shared_core_ftredge/models/user_status.py

@@ -1,22 +1,13 @@
-from datetime import datetime
+from datetime import datetime, timezone
 from dateutil.relativedelta import relativedelta
 from typing import Set, Optional, Dict, List, ClassVar
 from pydantic import BaseModel, Field, ConfigDict
-
+from .subscription import Subscription
+from ipulse_shared_base_ftredge import Layer, Module, list_as_lower_strings
 # ORIGINAL AUTHOR ="Russlan Ramdowar;russlan@ftredge.com"
-CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
-
-SCHEMA_VERSION = 2.3
-CLASS_REVISION_AUTHOR="Russlan Ramdowar;russlan@ftredge.com"
-CLASS_REVISION_DATE=datetime(2024, 2, 13, 20, 15)
-LAST_MODIFICATION="Changed default IAM_GROUPS"
-
-DOMAIN="user"
-OBJ_REF = "usrsttus"
+# CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
 
 DEFAULT_IAM_GROUPS={"pulseroot":["full_open_read"]}
-DEFAULT_SUBSCRIPTION_PLAN="subscription_free"
-DEFAULT_SUBSCRIPTION_STATUS="active"
 DEFAULT_SUBSCRIPTION_INSIGHT_CREDITS=10
 DEFAULT_EXTRA_INSIGHT_CREDITS=0
 
@@ -29,7 +20,7 @@ class UserStatus(BaseModel):
 
     # Class constants
     VERSION: ClassVar[float] = 2.3
-    DOMAIN: ClassVar[str] = "user"
+    DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name))
     OBJ_REF: ClassVar[str] = "usrsttus"
     
     # Default values as class variables
@@ -41,7 +32,7 @@ class UserStatus(BaseModel):
 
     # System-managed fields
     schema_version: float = Field(
-        default=2.3,
+        default=VERSION,
         description="Version of this Class == version of DB Schema"
     )
     
@@ -50,32 +41,20 @@ class UserStatus(BaseModel):
         default_factory=lambda: UserStatus.DEFAULT_IAM_GROUPS,
         description="User's Groups, with a default one for all authenticated Pulse users"
     )
-    sbscrptn_plan: str = Field(
-        default_factory=lambda: UserStatus.DEFAULT_SUBSCRIPTION_PLAN,
-        description="Subscription Plan"
-    )
-    sbscrptn_status: str = Field(
-        default_factory=lambda: UserStatus.DEFAULT_SUBSCRIPTION_STATUS,
-        description="Subscription Status"
-    )
     
-    # Subscription dates
-    sbscrptn_start_date: datetime = Field(
-        default_factory=datetime.utcnow,
-        description="Subscription Start Date"
-    )
-    sbscrptn_end_date: datetime = Field(
-        default_factory=lambda: datetime.utcnow() + relativedelta(years=1),
-        description="Subscription End Date"
+    # Subscription Management
+    subscriptions: Dict[str, Subscription] = Field(
+        default_factory=dict,
+        description="Dictionary of user's active and past subscriptions, keyed by plan name"
     )
-    
+
     # Credits management
-    sbscrptn_insight_credits: int = Field(
+    sbscrptn_allowance_insight_credits: int = Field(
         default_factory=lambda: UserStatus.DEFAULT_SUBSCRIPTION_INSIGHT_CREDITS,
         description="Subscription-based insight credits"
     )
-    sbscrptn_ins_crdts_updtd_since_datetime: datetime = Field(
-        default_factory=datetime.utcnow,
+    sbscrptn_allowance_insight_credits_updtd_on: datetime = Field(
+        default_factory=datetime.now,
         description="Last update timestamp for subscription credits"
     )
     extra_insight_credits: int = Field(

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/services/__init__.py

@@ -0,0 +1,4 @@
+from .base_firestore_service  import BaseFirestoreService
+
+from .exceptions import (BaseServiceException, ResourceNotFoundError, AuthorizationError,
+                            ValidationError )

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/services/base_firestore_service.py

@@ -0,0 +1,75 @@
+from typing import Dict, Any, Optional
+from datetime import datetime,timezone
+from fastapi import HTTPException
+from google.cloud import firestore
+from .exceptions import ResourceNotFoundError, ValidationError
+
+class BaseFirestoreService:
+    def __init__(self, db: firestore.Client, collection_name: str, resource_type: str):
+        self.db = db
+        self.collection_name = collection_name
+        self.resource_type = resource_type
+
+    def _validate_update_fields(self, update_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Centralized update fields validation"""
+        if not isinstance(update_data, dict):
+            update_data = update_data.model_dump(exclude_unset=True)
+            
+        valid_fields = {
+            k: v for k, v in update_data.items()
+            if v is not None and not (isinstance(v, (list, dict, set)) and len(v) == 0)
+        }
+        
+        if not valid_fields:
+            raise ValidationError(
+                resource_type=self.resource_type,
+                detail="No valid fields to update",
+                resource_id=None
+            )
+            
+        return valid_fields
+
+    async def get_document(self, doc_id: str) -> Dict[str, Any]:
+        """Get a document by ID with standardized error handling"""
+        doc_ref = self.db.collection(self.collection_name).document(doc_id)
+        doc = doc_ref.get()
+        
+        if not doc.exists:
+            raise ResourceNotFoundError(
+                resource_type=self.resource_type,
+                resource_id=doc_id,
+                additional_info={"collection": self.collection_name}
+            )
+            
+        return doc.to_dict()
+
+    async def update_document(self, doc_id: str, update_data: Dict[str, Any], user_uid: Optional[str] = None) -> Dict[str, Any]:
+        """Standard update method with validation and audit fields"""
+        try:
+            doc_ref = self.db.collection(self.collection_name).document(doc_id)
+            
+            if not doc_ref.get().exists:
+                raise ResourceNotFoundError(
+                    resource_type=self.resource_type,
+                    resource_id=doc_id,
+                    additional_info={"collection": self.collection_name}
+                )
+            
+            valid_fields = self._validate_update_fields(update_data)
+            
+            # Add audit fields
+            valid_fields.update({
+                'updt_date': datetime.now(timezone.utc).isoformat(),
+                'updt_by_user': user_uid if user_uid else None
+            })
+            
+            doc_ref.update(valid_fields)
+            return doc_ref.get().to_dict()
+            
+        except (ResourceNotFoundError, ValidationError):
+            raise
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to update {self.resource_type}: {str(e)}"
+            )

ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge/services/exceptions.py

@@ -0,0 +1,133 @@
+from fastapi import HTTPException
+from typing import Optional, Any, Dict
+import traceback
+import logging
+
+class BaseServiceException(HTTPException):
+    def __init__(
+        self,
+        status_code: int,
+        detail: str,
+        resource_type: str,
+        resource_id: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+        self.additional_info = additional_info or {}
+        self.original_error = original_error
+        
+        # Get full traceback if there's an original error
+        if original_error:
+            self.traceback = ''.join(traceback.format_exception(
+                type(original_error),
+                original_error,
+                original_error.__traceback__
+            ))
+        else:
+            self.traceback = ''.join(traceback.format_stack())
+        
+        # Build detailed message
+        detail_msg = f"{detail}"
+        if resource_type:
+            detail_msg += f" [Resource Type: {resource_type}]"
+        if resource_id:
+            detail_msg += f" [ID: {resource_id}]"
+        
+        super().__init__(status_code=status_code, detail=detail_msg)
+
+    def log_error(self, logger: logging.Logger):
+        """Log error with full context"""
+        error_context = {
+            "status_code": self.status_code,
+            "resource_type": self.resource_type,
+            "resource_id": self.resource_id,
+            "detail": self.detail,
+            **self.additional_info
+        }
+        
+        log_message = f"""
+            Service Error Occurred:
+            Status Code: {self.status_code}
+            Resource Type: {self.resource_type}
+            Resource ID: {self.resource_id}
+            Detail: {self.detail}
+            Additional Info: {self.additional_info}
+            {'Original Error: ' + str(self.original_error) if self.original_error else ''}
+            Traceback:
+            {self.traceback}
+                    """
+                    
+        logger.error(log_message, extra=error_context)
+
+
+class ServiceError(BaseServiceException):
+    """Generic service error with enhanced logging"""
+    def __init__(
+        self,
+        operation: str,
+        error: Exception,
+        resource_type: str,
+        resource_id: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(
+            status_code=500,
+            detail=f"Error during {operation}: {str(error)}",
+            resource_type=resource_type,
+            resource_id=resource_id,
+            additional_info=additional_info,
+            original_error=error
+        )
+
+
+class ResourceNotFoundError(BaseServiceException):
+    def __init__(
+        self,
+        resource_type: str,
+        resource_id: str,
+        additional_info: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(
+            status_code=404,
+            detail="Resource not found",
+            resource_type=resource_type,
+            resource_id=resource_id,
+            additional_info=additional_info
+        )
+
+class AuthorizationError(BaseServiceException):
+    def __init__(
+        self,
+        action: str,
+        resource_type: str = "authorization",
+        resource_id: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None,
+        original_error: Optional[Exception] = None
+    ):
+        super().__init__(
+            status_code=403,
+            detail=f"Not authorized to {action}",
+            resource_type=resource_type,
+            resource_id=resource_id,
+            additional_info=additional_info,
+            original_error=original_error
+        )
+
+class ValidationError(BaseServiceException):
+    def __init__(
+        self,
+        resource_type: str,
+        detail: str,
+        resource_id: Optional[str] = None,
+        additional_info: Optional[Dict[str, Any]] = None
+    ):
+        super().__init__(
+            status_code=422,
+            detail=detail,
+            resource_type=resource_type,
+            resource_id=resource_id,
+            additional_info=additional_info
+        )
+

{ipulse_shared_core_ftredge-3.2.3 → ipulse_shared_core_ftredge-5.1.1/src/ipulse_shared_core_ftredge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ipulse_shared_core_ftredge
-Version: 3.2.3
+Version: 5.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

{ipulse_shared_core_ftredge-3.2.3 → ipulse_shared_core_ftredge-5.1.1}/src/ipulse_shared_core_ftredge.egg-info/SOURCES.txt

@@ -8,11 +8,20 @@ src/ipulse_shared_core_ftredge.egg-info/SOURCES.txt
 src/ipulse_shared_core_ftredge.egg-info/dependency_links.txt
 src/ipulse_shared_core_ftredge.egg-info/requires.txt
 src/ipulse_shared_core_ftredge.egg-info/top_level.txt
+src/ipulse_shared_core_ftredge/dependencies/__init__.py
+src/ipulse_shared_core_ftredge/dependencies/auth_router.py
+src/ipulse_shared_core_ftredge/dependencies/authorization_api.py
+src/ipulse_shared_core_ftredge/dependencies/database.py
+src/ipulse_shared_core_ftredge/dependencies/token_validation.py
 src/ipulse_shared_core_ftredge/models/__init__.py
+src/ipulse_shared_core_ftredge/models/api_response.py
 src/ipulse_shared_core_ftredge/models/organisation.py
 src/ipulse_shared_core_ftredge/models/resource_catalog_item.py
+src/ipulse_shared_core_ftredge/models/subscription.py
 src/ipulse_shared_core_ftredge/models/user_auth.py
 src/ipulse_shared_core_ftredge/models/user_profile.py
 src/ipulse_shared_core_ftredge/models/user_profile_update.py
 src/ipulse_shared_core_ftredge/models/user_status.py
-tests/test_utils_gcp.py
+src/ipulse_shared_core_ftredge/services/__init__.py
+src/ipulse_shared_core_ftredge/services/base_firestore_service.py
+src/ipulse_shared_core_ftredge/services/exceptions.py

ipulse_shared_core_ftredge-3.2.3/src/ipulse_shared_core_ftredge/__init__.py

@@ -1,4 +0,0 @@
-# pylint: disable=missing-module-docstring
-from .models import ( UserAuth, UserProfile,
-                     UserStatus, UserProfileUpdate,
-                     Organisation)

ipulse_shared_core_ftredge-3.2.3/tests/test_utils_gcp.py

@@ -1,189 +0,0 @@
-# pylint: disable=missing-module-docstring
-# pylint: disable=import-error
-# pylint: disable=missing-module-docstring
-# pylint: disable=line-too-long
-# pylint: disable=missing-function-docstring
-
-import os
-import json
-from unittest.mock import MagicMock, patch
-import pytest
-from ipulse_shared_core_ftredge.utils_cloud_gcp import write_json_to_gcs
-
-
-# Mocking Google Cloud Storage components for testing using pytest-mock
-
-@pytest.fixture
-def mock_blob(mocker):
-    mock_blob_class = mocker.patch('google.cloud.storage.Blob', autospec=True)
-    mock_blob = mock_blob_class.return_value
-    mock_blob.exists.return_value = False
-    return mock_blob
-
-
-@pytest.fixture
-def mock_bucket(mocker, mock_blob):
-    mock_bucket_class = mocker.patch('google.cloud.storage.Bucket', autospec=True)
-    mock_bucket = mock_bucket_class.return_value
-    mock_bucket.list_blobs.return_value = []
-    mock_bucket.blob.return_value = mock_blob # this avoids creating a new blob for each test, which will confuse the test results
-    return mock_bucket
- 
-@pytest.fixture
-def mock_storage_client(mocker, mock_bucket):
-    mock_client_class = mocker.patch('google.cloud.storage.Client', autospec=True)
-    mock_client = mock_client_class.return_value
-    mock_client.bucket.return_value = mock_bucket
-    return mock_client
-
-
-
-# --- Test Cases ---
-
-def test_successful_gcs_upload(mock_storage_client):
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-
-    result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name, test_file_name)
-
-    assert result['gcs_path'] == f"gs://{test_bucket_name}/{test_file_name}"
-    assert result['local_path'] is None
-    assert result['gcs_file_already_exists'] is False
-    assert result['gcs_file_overwritten'] is False
-    assert result['gcs_file_saved_with_increment'] is False
-
-
-def test_invalid_data_type(mock_storage_client):
-    with pytest.raises(ValueError) as exc_info:
-        write_json_to_gcs(mock_storage_client, 12345, "test_bucket", "test_file.json")
-    assert str(exc_info.value) == "Unsupported data type. Data must be a list, dict, or str."
-
-
-def test_overwrite_if_exists(mock_storage_client, mock_blob):
-    mock_blob.exists.return_value = True  # Simulate existing file
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-
-    result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name, test_file_name, overwrite_if_exists=True)
-
-    assert result['gcs_file_overwritten'] is True
-
-
-def test_overwrite_with_substring(mock_storage_client, mock_bucket):
-    mock_bucket.list_blobs.return_value = [MagicMock(name='test_prefix_file1.json'), MagicMock(name='test_prefix_file2.json')]  
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-    test_prefix = 'test_prefix'
-
-    result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name, 
-                            test_file_name, overwrite_if_exists=True, 
-                            file_exists_if_starts_with_prefix=test_prefix)
-    assert result['gcs_file_overwritten'] is True
-    assert result['gcs_file_exists_checked_on_name'] == test_prefix
-
-
-def test_increment_if_exists(mock_storage_client, mock_blob):
-    mock_blob.exists.side_effect = [True, True, False]  # Simulate existing files 
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-    result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name, test_file_name, increment_if_exists=True)
-    assert result['gcs_path'] == f"gs://{test_bucket_name}/test_file_v2.json"
-    assert result['gcs_file_saved_with_increment'] is True
-
-
-def test_overwrite_and_increment_raise_value_error(mock_storage_client):
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-    with pytest.raises(ValueError) as exc_info:
-        write_json_to_gcs(mock_storage_client, test_data, test_bucket_name, 
-                        test_file_name, overwrite_if_exists=True,
-                        increment_if_exists=True)
-    assert str(exc_info.value) == "Both 'overwrite_if_exists' and 'increment_if_exists' cannot be True simultaneously."
-
-
-@patch('os.path.exists', return_value=False)  # Assume local file exists for simplicity
-@patch('builtins.open', new_callable=MagicMock)
-def test_local_save_after_gcs_failure(mock_open, mock_exists, mock_storage_client, mock_blob):
-    mock_blob.upload_from_string.side_effect = Exception("GCS Upload Failed")
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-
-    # Expecting an exception because GCS upload fails
-    with pytest.raises(Exception) as exc_info:
-        result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name, test_file_name, save_locally=True)
-
-    assert "GCS Upload Failed" in str(exc_info.value)
-    mock_open.assert_called_once_with(os.path.join("/tmp", test_file_name), 'w', encoding='utf-8')
-
-
-@patch('builtins.open', new_callable=MagicMock)
-def test_local_save_with_custom_path(mock_open, mock_storage_client):
-    local_path = "/my/custom/path"
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-
-    result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name,
-                                test_file_name, local_path=local_path)
-
-    assert result['local_path'] == os.path.join(local_path, test_file_name)
-    mock_open.assert_called_once()
-
-@patch('os.path.exists', side_effect=[True, True, False])
-@patch('builtins.open', new_callable=MagicMock)
-def test_local_save_with_increment(mock_open, mock_exists, mock_storage_client, mock_blob):
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-
-    result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name,
-                                test_file_name, save_locally=True, increment_if_exists=True)
-
-    assert f"/tmp/test_file_v1.json" == result['local_path']
-    mock_open.assert_called_once()
-
-
-@patch('builtins.open', new_callable=MagicMock)
-def test_local_save_overwrite(mock_open, mock_storage_client):
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-
-    # Execute function
-    result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name,
-                               test_file_name, save_locally=True, overwrite_if_exists=True)
-
-    # Check results
-    assert result['local_path'] == os.path.join("/tmp", test_file_name)
-    mock_open.assert_called_once_with(os.path.join("/tmp", test_file_name), 'w', encoding='utf-8')
-    file_handle = mock_open()
-
-
-@patch('os.path.exists', return_value=True)
-@patch('builtins.open', new_callable=MagicMock)
-def test_local_save_skip(mock_open, mock_exists, mock_storage_client):
-    test_data = {"key": "value"}
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-
-    result = write_json_to_gcs(mock_storage_client, test_data, test_bucket_name,
-                            test_file_name, save_locally=True, overwrite_if_exists=False)
-
-    assert result['local_path'] == os.path.join("/tmp", test_file_name)
-    mock_open.assert_not_called()
-
-
-def test_string_data_handling(mock_storage_client, mock_blob):
-    test_string_data = "This is a test string."
-    test_bucket_name = "test_bucket"
-    test_file_name = "test_file.json"
-
-    result = write_json_to_gcs(mock_storage_client, test_string_data, test_bucket_name, test_file_name)
-
-    assert result['gcs_path'] == f"gs://{test_bucket_name}/{test_file_name}"