ipulse-shared-core-ftredge 4.1.1__tar.gz → 5.2.1__tar.gz

{ipulse_shared_core_ftredge-4.1.1/src/ipulse_shared_core_ftredge.egg-info → ipulse_shared_core_ftredge-5.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ipulse_shared_core_ftredge
-Version: 4.1.1
+Version: 5.2.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-4.1.1 → ipulse_shared_core_ftredge-5.2.1}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='ipulse_shared_core_ftredge',
-    version='4.1.1',
+    version='5.2.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.2.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.2.1/src/ipulse_shared_core_ftredge/dependencies/__init__.py

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

ipulse_shared_core_ftredge-5.2.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.2.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.2.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.2.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-4.1.1 → ipulse_shared_core_ftredge-5.2.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-4.1.1 → ipulse_shared_core_ftredge-5.2.1}/src/ipulse_shared_core_ftredge/models/api_response.py

@@ -1,6 +1,10 @@
 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')
 
@@ -20,3 +24,14 @@ class PaginatedResponse(StandardResponse, Generic[T]):
     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-4.1.1 → ipulse_shared_core_ftredge-5.2.1}/src/ipulse_shared_core_ftredge/models/organisation.py

@@ -13,7 +13,11 @@ import uuid
 import dateutil.parser
 from ipulse_shared_base_ftredge import (
     OrganizationRelation,
-    OrganizationIndustry
+    OrganizationIndustry,
+    Layer,
+    Module,
+    list_as_lower_strings,
+    Sector
 )
 
 class Organisation(BaseModel):
@@ -24,15 +28,27 @@ class Organisation(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
     
     # Class constants
-    VERSION: ClassVar[float] = 1.0
-    MODULE: ClassVar[str] = "core"
-    CLASS_REF: ClassVar[str] = "orgn"
+    VERSION: ClassVar[float] = 4.1
+    MODULE: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Sector.USERCORE.name))
+    OBJ_REF: ClassVar[str] = "orgprofile"
 
-    # Required fields
-    puid: str = Field(
-        default_factory=lambda: f"{datetime.utcnow().strftime('%Y%m%d%H%M%S')}_{uuid.uuid4().hex[:8]}_{Organisation.MODULE}{Organisation.CLASS_REF}".lower(),
-        description="Unique identifier for the organisation"
+    schema_version: float = Field(
+        default=VERSION,
+        description="Version of this Class == version of DB Schema",
+        frozen=True
     )
+    
+    org_uid: str = Field(
+        default_factory=lambda: uuid.uuid4().hex,
+        description="Unique identifier for the organisation",
+        frozen=True
+    )
+
+    id: str = Field(
+        default=None,
+        description="Organisation ID, format: {OBJ_REF}_{org_uid}"
+    )
+
     name: str = Field(..., min_length=1, max_length=100)
     relations: Set[OrganizationRelation] = Field(..., description="Organisation relations/types")
 
@@ -48,6 +64,15 @@ class Organisation(BaseModel):
     website: Optional[str] = Field(None, max_length=200)
     org_admin_user_uids: Optional[Set[str]] = None
 
+    @field_validator('id', mode='before')
+    @classmethod
+    def generate_id(cls, v: Optional[str], info) -> str:
+        values = info.data
+        org_uid = values.get('org_uid')
+        if not org_uid:
+            raise ValueError("org_uid must be set before generating id")
+        return f"{cls.OBJ_REF}_{org_uid}"
+
     @field_validator('relations')
     @classmethod
     def validate_relations(cls, v: Set[OrganizationRelation]) -> Set[OrganizationRelation]:

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

@@ -0,0 +1,47 @@
+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, Sector, SubscriptionPlan
+# ORIGINAL AUTHOR ="Russlan Ramdowar;russlan@ftredge.com"
+# CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
+
+
+DEFAULT_SUBSCRIPTION_PLAN = SubscriptionPlan.FREE
+DEFAULT_SUBSCRIPTION_STATUS = "active"
+
+############################################ !!!!! ALWAYS UPDATE SCHEMA VERSION , IF SCHEMA IS BEING MODIFIED !!! ############################################
+class Subscription(BaseModel):
+    """
+    Represents a single subscription cycle.
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    VERSION: ClassVar[float] = 1.1
+    DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Sector.LOOKUP.name))
+    
+    # System-managed fields (read-only)
+    schema_version: float = Field(
+        default=VERSION,
+        description="Version of this Class == version of DB Schema",
+        frozen=True
+    )
+
+    plan_name: SubscriptionPlan = 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-4.1.1 → ipulse_shared_core_ftredge-5.2.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, Sector
 
+# # 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.
@@ -10,16 +14,27 @@ class UserProfile(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     # Metadata as class variables
-    VERSION: ClassVar[float] = 3.01
-    DOMAIN: ClassVar[str] = "user"
-    OBJ_REF: ClassVar[str] = "usprfl"
+    VERSION: ClassVar[float] = 4.1
+    DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Sector.USERCORE.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
     )
+    
+    id : str = Field(
+        ...,
+        description="User ID, propagated from Firebase Auth"
+    )
+
+    user_uid: str = Field(
+        ...,
+        description="User UID, propagated from Firebase Auth"
+    )
+
+
     email: EmailStr = Field(
         ...,
         description="Propagated from Firebase Auth",
@@ -27,8 +42,7 @@ class UserProfile(BaseModel):
     )
     organizations_uids: Set[str] = Field(
         default_factory=set,
-        description="Depends on Subscription Plan, Regularly Updated",
-        frozen=True
+        description="Depends on Subscription Plan, Regularly Updated"
     )
     
     # Timestamps and audit fields (read-only)
@@ -40,8 +54,7 @@ class UserProfile(BaseModel):
     # System identification (read-only)
     provider_id: str = Field(frozen=True)
     aliases: Optional[Set[str]] = Field(
-        default=None,
-        frozen=True
+        default=None
     )
     
     # User-editable fields
@@ -68,9 +81,8 @@ class UserProfile(BaseModel):
         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"
+    # Audit fields
+    creat_date: datetime = Field(default_factory=datetime.now)
+    creat_by_user: str = Field(frozen=True)
+    updt_date: datetime = Field(default_factory=datetime.now)
+    updt_by_user: str = Field(frozen=True)

{ipulse_shared_core_ftredge-4.1.1 → ipulse_shared_core_ftredge-5.2.1}/src/ipulse_shared_core_ftredge/models/user_profile_update.py

@@ -2,6 +2,10 @@ from typing import Optional, Set, ClassVar
 from pydantic import BaseModel, Field, EmailStr, ConfigDict
 from datetime import date, datetime
 
+# CLASS_ORGIN_DATE: ClassVar[datetime] = datetime(2024, 3, 15, 20, 15)
+# CLASS_REVISION_DATE: ClassVar[datetime] = datetime(2024, 3, 15, 20, 15)
+
+
 class UserProfileUpdate(BaseModel):
     """
     User Profile Update model for partial updates of user information.
@@ -12,11 +16,9 @@ class UserProfileUpdate(BaseModel):
     # Metadata as class variables
     VERSION: ClassVar[float] = 2.01
     CLASS_ORIGIN_AUTHOR: ClassVar[str] = "Russlan Ramdowar;russlan@ftredge.com"
-    CLASS_ORGIN_DATE: ClassVar[datetime] = datetime(2024, 3, 15, 20, 15)
-    CLASS_REVISION_DATE: ClassVar[datetime] = datetime(2024, 3, 15, 20, 15)
+ 
 
     # System fields
-    schema_version: Optional[float] = Field(None, description="Version of this Class == version of DB Schema")
     email: Optional[EmailStr] = Field(None, description="Propagated from Firebase Auth")
     organizations_uids: Optional[Set[str]] = Field(None, description="Organization memberships")
     
@@ -37,6 +39,10 @@ class UserProfileUpdate(BaseModel):
     last_name: Optional[str] = Field(None, max_length=100)
     mobile: Optional[str] = Field(None, pattern=r"^\+?[1-9]\d{1,14}$")
 
+
+    
+
+
     def model_dump(self, **kwargs):
         kwargs.setdefault('exclude_none', True)
         return super().model_dump(**kwargs)

{ipulse_shared_core_ftredge-4.1.1 → ipulse_shared_core_ftredge-5.2.1}/src/ipulse_shared_core_ftredge/models/user_status.py

@@ -1,24 +1,10 @@
 from datetime import datetime
-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, Sector
 # 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"
-
-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
+# CLASS_ORGIN_DATE=datetime(2024, 2, 12, 20, 5)
 
 ############################################ !!!!! ALWAYS UPDATE SCHEMA VERSION , IF SCHEMA IS BEING MODIFIED !!! ############################################
 class UserStatus(BaseModel):
@@ -28,9 +14,9 @@ class UserStatus(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     # Class constants
-    VERSION: ClassVar[float] = 2.3
-    DOMAIN: ClassVar[str] = "user"
-    OBJ_REF: ClassVar[str] = "usrsttus"
+    VERSION: ClassVar[float] = 4.1
+    DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Sector.USERCORE.name))
+    OBJ_REF: ClassVar[str] = "userstatus"
     
     # Default values as class variables
     DEFAULT_IAM_GROUPS: ClassVar[Dict[str, List[str]]] = {"pulseroot": ["full_open_read"]}
@@ -39,43 +25,42 @@ class UserStatus(BaseModel):
     DEFAULT_SUBSCRIPTION_INSIGHT_CREDITS: ClassVar[int] = 10
     DEFAULT_EXTRA_INSIGHT_CREDITS: ClassVar[int] = 0
 
+
     # System-managed fields
     schema_version: float = Field(
-        default=2.3,
+        default=VERSION,
         description="Version of this Class == version of DB Schema"
     )
     
+    id : str = Field(
+        ...,
+        description="User ID, propagated from Firebase Auth"
+    )
+
+    user_uid: str = Field(
+        ...,
+        description="User UID, propagated from Firebase Auth"
+    )
+
     # IAM and subscription fields
     iam_groups: Dict[str, List[str]] = Field(
         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"
+    # Subscription Management
+    subscriptions: Dict[str, Subscription] = Field(
+        default_factory=dict,
+        description="Dictionary of user's active and past subscriptions, keyed by plan name"
     )
-    sbscrptn_end_date: datetime = Field(
-        default_factory=lambda: datetime.utcnow() + relativedelta(years=1),
-        description="Subscription End Date"
-    )
-    
+
     # 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(
@@ -86,8 +71,8 @@ class UserStatus(BaseModel):
     # Optional fields
     payment_refs_uids: Optional[Set[str]] = None
     
-    # Audit fields
-    creat_date: datetime
-    creat_by_user: str
-    updt_date: datetime
-    updt_by_user: str
+        # Audit fields
+    creat_date: datetime = Field(default_factory=datetime.now)
+    creat_by_user: str = Field(frozen=True)
+    updt_date: datetime = Field(default_factory=datetime.now)
+    updt_by_user: str = Field(frozen=True)

ipulse_shared_core_ftredge-5.2.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-4.1.1/src/ipulse_shared_core_ftredge/services/base_service.py → ipulse_shared_core_ftredge-5.2.1/src/ipulse_shared_core_ftredge/services/base_firestore_service.py

@@ -2,7 +2,7 @@ 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
+from .exceptions import ResourceNotFoundError, ValidationError
 
 class BaseFirestoreService:
     def __init__(self, db: firestore.Client, collection_name: str, resource_type: str):

ipulse_shared_core_ftredge-5.2.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-4.1.1 → ipulse_shared_core_ftredge-5.2.1/src/ipulse_shared_core_ftredge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ipulse_shared_core_ftredge
-Version: 4.1.1
+Version: 5.2.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-4.1.1 → ipulse_shared_core_ftredge-5.2.1}/src/ipulse_shared_core_ftredge.egg-info/SOURCES.txt

@@ -3,20 +3,25 @@ README.md
 pyproject.toml
 setup.py
 src/ipulse_shared_core_ftredge/__init__.py
-src/ipulse_shared_core_ftredge/exceptions.py
 src/ipulse_shared_core_ftredge.egg-info/PKG-INFO
 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
 src/ipulse_shared_core_ftredge/services/__init__.py
-src/ipulse_shared_core_ftredge/services/base_service.py
-tests/test_utils_gcp.py
+src/ipulse_shared_core_ftredge/services/base_firestore_service.py
+src/ipulse_shared_core_ftredge/services/exceptions.py

ipulse_shared_core_ftredge-4.1.1/src/ipulse_shared_core_ftredge/__init__.py

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

ipulse_shared_core_ftredge-4.1.1/src/ipulse_shared_core_ftredge/exceptions.py

@@ -1,71 +0,0 @@
-from fastapi import HTTPException
-from typing import Optional, Any, Dict
-
-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
-    ):
-        self.resource_type = resource_type
-        self.resource_id = resource_id
-        self.additional_info = additional_info or {}
-        
-        # 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)
-
-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,
-        resource_type: str,
-        action: str,
-        resource_id: Optional[str] = None,
-        additional_info: Optional[Dict[str, Any]] = None
-    ):
-        super().__init__(
-            status_code=403,
-            detail=f"Not authorized to {action}",
-            resource_type=resource_type,
-            resource_id=resource_id,
-            additional_info=additional_info
-        )
-
-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-4.1.1/src/ipulse_shared_core_ftredge/services/__init__.py

@@ -1 +0,0 @@
-from .base_service  import BaseFirestoreService

ipulse_shared_core_ftredge-4.1.1/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}"