ipulse-shared-core-ftredge 11.1.1__tar.gz → 13.0.1__tar.gz

{ipulse_shared_core_ftredge-11.1.1/src/ipulse_shared_core_ftredge.egg-info → ipulse_shared_core_ftredge-13.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipulse_shared_core_ftredge
-Version: 11.1.1
+Version: 13.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.4.1
+Requires-Dist: ipulse_shared_base_ftredge==6.5.1
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page

{ipulse_shared_core_ftredge-11.1.1 → ipulse_shared_core_ftredge-13.0.1}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='ipulse_shared_core_ftredge',
-    version='11.1.1',
+    version='13.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.4.1',
+        'ipulse_shared_base_ftredge==6.5.1',
     ],
     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-11.1.1 → ipulse_shared_core_ftredge-13.0.1}/src/ipulse_shared_core_ftredge/__init__.py

@@ -7,6 +7,6 @@ from .models import ( UserAuth, UserProfile,Subscription,
 
 
 from .services import (BaseFirestoreService,BaseServiceException, ResourceNotFoundError, AuthorizationError,
-                            ValidationError)
+                            ValidationError, ServiceError)
 
 from .utils import (EnsureJSONEncoderCompatibility)

ipulse_shared_core_ftredge-13.0.1/src/ipulse_shared_core_ftredge/cache/__init__.py

@@ -0,0 +1,4 @@
+"""Cache utilities for shared core."""
+from ipulse_shared_core_ftredge.cache.shared_cache import SharedCache
+
+__all__ = ['SharedCache']

ipulse_shared_core_ftredge-13.0.1/src/ipulse_shared_core_ftredge/cache/shared_cache.py

@@ -0,0 +1,249 @@
+"""Module for shared caching functionality that can be used across microservices."""
+import os
+import time
+import logging
+import traceback
+import inspect
+import asyncio
+from typing import Dict, Any, Optional, TypeVar, Generic, Callable, Tuple, List, Awaitable
+
+T = TypeVar('T')
+
+class SharedCache(Generic[T]):
+    """
+    Generic shared cache implementation that can be used across services.
+
+    Attributes:
+        name: The name of the cache for logging and identification.
+        ttl: Time-to-live in seconds for cached items.
+        enabled: Whether the cache is enabled.
+        logger: Logger for cache operations.
+        _cache: Dictionary holding cached values.
+        _timestamps: Dictionary holding timestamps for each cached item.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        ttl: float,
+        enabled: bool = True,
+        logger: Optional[logging.Logger] = None
+    ):
+        """Initialize the cache with name, TTL and enabled state."""
+        self.name = name
+        self.ttl = ttl
+        self.enabled = enabled
+        self.logger = logger or logging.getLogger(__name__)
+        self._cache: Dict[str, T] = {}
+        self._timestamps: Dict[str, float] = {}
+
+        self.logger.info(f"{name} cache initialized. Enabled: {enabled}, TTL: {ttl} seconds")
+
+    def get(self, key: str) -> Optional[T]:
+        """
+        Get a value from the cache if it exists and hasn't expired.
+
+        Args:
+            key: The cache key to retrieve.
+
+        Returns:
+            The cached value if found and valid, None otherwise.
+        """
+        if not self.enabled:
+            return None
+
+        try:
+            if key in self._cache:
+                timestamp = self._timestamps.get(key, 0)
+                if time.time() - timestamp < self.ttl:
+                    self.logger.debug(f"Cache hit for {key} in {self.name}")
+                    return self._cache[key]
+                else:
+                    # Expired item, remove it
+                    self.invalidate(key)
+                    self.logger.debug(f"Cache expired for {key} in {self.name}")
+        except Exception as e:
+            self.logger.error(f"Error getting item from {self.name} cache with key {key}: {str(e)}")
+            self.logger.error(traceback.format_exc())
+
+        return None
+
+    def set(self, key: str, value: T) -> None:
+        """
+        Set a value in the cache.
+
+        Args:
+            key: The cache key to set.
+            value: The value to cache.
+        """
+        if not self.enabled:
+            return
+
+        try:
+            self._cache[key] = value
+            self._timestamps[key] = time.time()
+            self.logger.debug(f"Cached item {key} in {self.name}")
+        except Exception as e:
+            self.logger.error(f"Error setting item in {self.name} cache with key {key}: {str(e)}")
+            self.logger.error(traceback.format_exc())
+
+    def invalidate(self, key: str) -> None:
+        """
+        Remove a specific key from the cache.
+
+        Args:
+            key: The cache key to invalidate.
+        """
+        try:
+            self._cache.pop(key, None)
+            self._timestamps.pop(key, None)
+            self.logger.debug(f"Invalidated cache for {key} in {self.name}")
+        except Exception as e:
+            self.logger.error(f"Error invalidating cache in {self.name} for key {key}: {str(e)}")
+            self.logger.error(traceback.format_exc())
+
+    def invalidate_all(self) -> None:
+        """Clear all cached items."""
+        try:
+            cache_size = len(self._cache)
+            self._cache.clear()
+            self._timestamps.clear()
+            self.logger.info(f"Invalidated all {cache_size} entries in {self.name} cache")
+        except Exception as e:
+            self.logger.error(f"Error invalidating all cache entries in {self.name}: {str(e)}")
+            self.logger.error(traceback.format_exc())
+
+    def get_or_set(
+        self,
+        key: str,
+        data_loader: Callable[[], T]
+    ) -> Tuple[T, bool]:
+        """
+        Get a value from cache or set it using the data_loader if missing or expired.
+
+        Args:
+            key: The cache key.
+            data_loader: Function to load data if not in cache.
+
+        Returns:
+            Tuple of (data, was_cached) where was_cached indicates if from cache.
+        """
+        try:
+            cached_data = self.get(key)
+            if cached_data is not None:
+                return cached_data, True
+
+            # Not in cache or expired, load the data
+            self.logger.debug(f"Cache miss for {key} in {self.name}, loading data...")
+
+            # Check if the data_loader is a coroutine function
+            if inspect.iscoroutinefunction(data_loader):
+                self.logger.error(
+                    f"Error in get_or_set for {key} in {self.name}: "
+                    f"data_loader is a coroutine function which is not supported. "
+                    f"Use a regular function that returns a value, not a coroutine."
+                )
+                # Fall back to running the coroutine in the event loop if possible
+                try:
+                    loop = asyncio.get_event_loop()
+                    fresh_data = loop.run_until_complete(data_loader())
+                except Exception as coro_err:
+                    self.logger.error(f"Failed to execute coroutine data_loader: {str(coro_err)}")
+                    raise RuntimeError(f"Cannot use coroutine data_loader in cache: {str(coro_err)}")
+            else:
+                # Regular function, just call it
+                fresh_data = data_loader()
+
+            if fresh_data is not None:  # Only cache if we got valid data
+                self.set(key, fresh_data)
+
+            if fresh_data is None:
+                raise ValueError(f"Data loader returned None for key {key} in {self.name}")
+            return fresh_data, False
+        except Exception as e:
+            self.logger.error(f"Error in get_or_set for {key} in {self.name}: {str(e)}")
+            self.logger.error(traceback.format_exc())
+
+            # Since this is a critical function, re-raise the exception
+            # after logging it, but add context about the cache
+            raise RuntimeError(f"Cache error in {self.name} for key {key}: {str(e)}") from e
+
+    async def async_get_or_set(
+        self,
+        key: str,
+        async_data_loader: Callable[[], Awaitable[T]]
+    ) -> Tuple[T, bool]:
+        """
+        Async version of get_or_set for use with async data loaders.
+
+        Args:
+            key: The cache key.
+            async_data_loader: Async function to load data if not in cache.
+
+        Returns:
+            Tuple of (data, was_cached) where was_cached indicates if from cache.
+        """
+        try:
+            cached_data = self.get(key)
+            if cached_data is not None:
+                return cached_data, True
+
+            # Not in cache or expired, load the data asynchronously
+            self.logger.debug(f"Cache miss for {key} in {self.name}, loading data asynchronously...")
+
+            # Execute the async data loader
+            fresh_data = await async_data_loader()
+
+            if fresh_data is not None:  # Only cache if we got valid data
+                self.set(key, fresh_data)
+
+            return fresh_data, False
+        except Exception as e:
+            self.logger.error(f"Error in async_get_or_set for {key} in {self.name}: {str(e)}")
+            self.logger.error(traceback.format_exc())
+            raise RuntimeError(f"Cache error in {self.name} for key {key}: {str(e)}") from e
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about the current cache state."""
+        try:
+            return {
+                "name": self.name,
+                "enabled": self.enabled,
+                "ttl_seconds": self.ttl,
+                "item_count": len(self._cache),
+                "keys": list(self._cache.keys())[:20],  # Limit to first 20 keys
+                "has_more_keys": len(self._cache.keys()) > 20,
+                "memory_usage_estimate_bytes": sum(
+                    len(str(k)) + self._estimate_size(v)
+                    for k, v in self._cache.items()
+                )
+            }
+        except Exception as e:
+            self.logger.error(f"Error getting stats for {self.name} cache: {str(e)}")
+            self.logger.error(traceback.format_exc())
+            return {
+                "name": self.name,
+                "enabled": self.enabled,
+                "error": str(e),
+                "ttl_seconds": self.ttl,
+                "item_count": len(self._cache) if self._cache else 0
+            }
+
+    def _estimate_size(self, obj: Any) -> int:
+        """Estimate the memory size of an object in bytes."""
+        try:
+            if obj is None:
+                return 0
+            if isinstance(obj, (str, bytes, bytearray)):
+                return len(obj)
+            if isinstance(obj, (int, float, bool)):
+                return 8
+            if isinstance(obj, dict):
+                return sum(len(str(k)) + self._estimate_size(v) for k, v in obj.items())
+            if isinstance(obj, (list, tuple, set)):
+                return sum(self._estimate_size(i) for i in obj)
+            # For other objects, use a rough approximation
+            return len(str(obj))
+        except Exception:
+            # If we can't estimate, return a reasonable default
+            return 100

{ipulse_shared_core_ftredge-11.1.1 → ipulse_shared_core_ftredge-13.0.1}/src/ipulse_shared_core_ftredge/dependencies/authz_for_apis.py

@@ -1,5 +1,8 @@
 import os
 import logging
+import json
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
 from typing import Optional, Iterable, Dict, Any, List
 from datetime import datetime, timedelta, timezone
 import json
@@ -10,10 +13,10 @@ from ipulse_shared_core_ftredge.services import ServiceError, AuthorizationError
 from ipulse_shared_core_ftredge.models import UserStatus
 from ipulse_shared_core_ftredge.utils.json_encoder import convert_to_json_serializable
 
-# Constants
-USERS_STATUS_COLLECTION_NAME = UserStatus.get_collection_name()
-USERS_STATUS_DOC_REF = "userstatus_"
-CACHE_TTL = 60 # 60 seconds
+# Constants derived from UserStatus model
+USERS_STATUS_COLLECTION_NAME = UserStatus.COLLECTION_NAME
+USERS_STATUS_DOC_REF = f"{UserStatus.OBJ_REF}_" # Use OBJ_REF and append underscore
+USERSTATUS_CACHE_TTL = 60 # 60 seconds
 
 class UserStatusCache:
     """Manages user status caching with dynamic invalidation"""
@@ -33,7 +36,7 @@ class UserStatusCache:
             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):
+            if datetime.now() - self._timestamps[user_uid] < timedelta(seconds=USERSTATUS_CACHE_TTL):
                 return status_data
             self.invalidate(user_uid)
         return None
@@ -65,13 +68,59 @@ userstatus_cache = UserStatusCache()
 # Replace the logger dependency with a standard logger
 logger = logging.getLogger(__name__)
 
+# Create a custom FirestoreTimeoutError class that can be identified in middlewares
+class FirestoreTimeoutError(TimeoutError):
+    """Custom exception for Firestore timeout errors to make them more identifiable."""
+    pass
+
+
+# Define a function to get a Firestore document with a strict timeout
+async def get_with_strict_timeout(doc_ref, timeout_seconds: float):
+    """
+    Get a Firestore document with a strictly enforced timeout.
+
+    Args:
+        doc_ref: Firestore document reference
+        timeout_seconds: Maximum time to wait in seconds
+
+    Returns:
+        Document snapshot
+
+    Raises:
+        FirestoreTimeoutError: If the operation takes longer than timeout_seconds
+    """
+    loop = asyncio.get_running_loop()
+    with ThreadPoolExecutor() as executor:
+        try:
+            # Run the blocking Firestore get() operation in a thread and apply a strict timeout
+            logger.debug(f"Starting Firestore get with strict timeout of {timeout_seconds}s")
+            return await asyncio.wait_for(
+                loop.run_in_executor(executor, doc_ref.get),
+                timeout=timeout_seconds
+            )
+        except asyncio.TimeoutError:
+            error_message = f"User Status fetching for Authz timed out after {timeout_seconds} seconds, perhaps issue with Firestore Connectivity"
+            logger.error(error_message)
+            raise FirestoreTimeoutError(error_message)
+
+# Update get_userstatus to use our new strict timeout function
 async def get_userstatus(
     user_uid: str,
-    db: firestore.Client,  # Note: This expects the actual client, not a Depends
-    force_fresh: bool = False
+    db: firestore.Client,
+    force_fresh: bool = False,
+    timeout: float = 12.0  # Default timeout but allow override
 ) -> tuple[Dict[str, Any], bool]:
     """
-    Fetch user status with intelligent caching
+    Fetch user status with intelligent caching and configurable timeout
+
+    Args:
+        user_uid: User ID to fetch status for
+        db: Firestore client
+        force_fresh: Whether to bypass cache
+        timeout: Timeout for Firestore operations in seconds
+
+    Returns:
+        Tuple of (user status data, whether cache was used)
     """
     cache_used = False
     if not force_fresh:
@@ -85,8 +134,11 @@ async def get_userstatus(
         userstatus_id = USERS_STATUS_DOC_REF + user_uid
         user_ref = db.collection(USERS_STATUS_COLLECTION_NAME).document(userstatus_id)
 
-        # Get the document
-        snapshot = user_ref.get()
+        logger.debug(f"Fetching user status for {user_uid} with strict timeout {timeout}s")
+
+        # Use our strict timeout wrapper instead of the native timeout parameter
+        snapshot = await get_with_strict_timeout(user_ref, timeout)
+
         if not snapshot.exists:
             raise ResourceNotFoundError(
                 resource_type="authorization userstatus",
@@ -101,9 +153,23 @@ async def get_userstatus(
             userstatus_cache.set(user_uid, status_data)
         return status_data, cache_used
 
+    except TimeoutError as e:
+        logger.error(f"Timeout while fetching user status for {user_uid}: {str(e)}")
+        raise ServiceError(
+            operation="fetching user status for authz",
+            error=e,
+            resource_type="userstatus",
+            resource_id=user_uid,
+            additional_info={
+                "force_fresh": force_fresh,
+                "collection": USERS_STATUS_COLLECTION_NAME,
+                "timeout_seconds": timeout
+            }
+        )
     except ResourceNotFoundError:
         raise
     except Exception as e:
+        logger.error(f"Error fetching user status for {user_uid}: {str(e)}")
         raise ServiceError(
             operation=f"fetching user status",
             error=e,
@@ -156,15 +222,27 @@ async def extract_request_fields(request: Request) -> Optional[List[str]]:
         logger.warning(f"Could not extract fields from request body: {str(e)}")
         return None  # Return None instead of raising an error
 
+# Main authorization function with configurable timeout
 async def authorizeAPIRequest(
     request: Request,
-    db: firestore.Client,  # Changed: Now expects actual client instance
+    db: firestore.Client,
     request_resource_fields: Optional[Iterable[str]] = None,
+    firestore_timeout: float = 15.0  # Allow specifying timeout
 ) -> Dict[str, Any]:
     """
     Authorize API request based on user status and OPA policies.
     Enhanced with credit check information.
+
+    Args:
+        request: The incoming request
+        db: Firestore client
+        request_resource_fields: Fields being accessed/modified in the request
+        firestore_timeout: Timeout for Firestore operations in seconds
+
+    Returns:
+        Authorization result containing decision details
     """
+    opa_decision = None
     try:
         # Extract fields for both PATCH and POST if not provided
         if not request_resource_fields:
@@ -180,7 +258,12 @@ async def authorizeAPIRequest(
 
         # Determine if we need fresh status
         force_fresh = _should_force_fresh_status(request)
-        userstatus, cache_used = await get_userstatus(user_uid, db, force_fresh=force_fresh)
+        userstatus, cache_used = await get_userstatus(
+            user_uid,
+            db,
+            force_fresh=force_fresh,
+            timeout=firestore_timeout  # Pass the specified timeout
+        )
 
         # Prepare authorization input that matches OPA expectations
         # Extract required values from user status
@@ -214,7 +297,13 @@ async def authorizeAPIRequest(
         # Query OPA
         opa_url = f"{os.getenv('OPA_SERVER_URL', 'http://localhost:8181')}{os.getenv('OPA_DECISION_PATH', '/v1/data/http/authz/ingress/decision')}"
         logger.debug(f"Attempting to connect to OPA at: {opa_url}")
-        logger.debug(f"Authorization input: {authz_input}")
+
+        # Debug: Print raw JSON payload to identify any potential issues
+        try:
+            payload_json = json.dumps({"input": json_safe_authz_input})
+            logger.debug(f"OPA Request JSON payload: {payload_json}")
+        except Exception as json_err:
+            logger.error(f"Error serializing OPA request payload: {json_err}")
 
         async with httpx.AsyncClient() as client:
             try:
@@ -236,20 +325,35 @@ async def authorizeAPIRequest(
                 result = response.json()
                 logger.debug(f"Parsed OPA response: {result}")
 
-                if not result.get("result", {}).get("allow", False):
+                # Handle unusual OPA response formats
+                # Try to find "decision" field as an alternative
+                if "result" in result:
+                    opa_decision = result["result"]
+                else:
+                    # If we still don't have a result after all attempts, use default structure
+                    logger.warning(f"OPA response missing 'result' field, using default")
+                    raise HTTPException(
+                        status_code=500,
+                        detail="Authorization service error: OPA response format unexpected"
+                    )
+
+                # Extract key fields from result with better default handling
+                allow = opa_decision.get("allow", False)
+
+                # Handle authorization denial
+                if not allow:
                     logger.error(f"Authorization denied: {result}")
                     raise AuthorizationError(
                         action=f"{request.method} {request.url.path}",
                         additional_info={
                             "user_uid": user_uid,
                             "resource_fields": request_resource_fields,
-                            "opa_decision": result.get("result", {})
+                            "opa_decision": opa_decision,  # Include the full OPA decision result
+                            # Include the raw result if it's different from the processed decision
+                            "raw_opa_response": result if result != {"result": opa_decision} else None
                         }
                     )
 
-                # Extract credit check information from the OPA response
-                credit_check = result.get("result", {}).get("credit_check", {})
-
             except httpx.RequestError as e:
                 logger.error(f"Failed to connect to OPA: {str(e)}")
                 raise ServiceError(
@@ -267,9 +371,7 @@ async def authorizeAPIRequest(
             "used_cached_status": cache_used,
             "required_fresh_status": force_fresh,
             "status_retrieved_at": datetime.now(timezone.utc).isoformat(),
-            "credit_check": credit_check,
-            "allow_all_fields": result.get("result", {}).get("allow_all_fields", False),
-            "allowed_fields": result.get("result", {}).get("allowed_fields", [])
+            "opa_decision": opa_decision
         }
 
     except (AuthorizationError, ResourceNotFoundError):

ipulse_shared_core_ftredge-13.0.1/src/ipulse_shared_core_ftredge/models/base_data_model.py

@@ -0,0 +1,55 @@
+from datetime import datetime, timezone
+from typing import Any
+from typing import ClassVar
+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")
+
+    # Required class variables that must be defined in subclasses
+    VERSION: ClassVar[float]
+    DOMAIN: ClassVar[str]
+    OBJ_REF: ClassVar[str]
+
+    # Schema versioning
+    schema_version: float = Field(
+        ...,  # Make this required
+        description="Version of this Class == version of DB Schema",
+        frozen=True
+    )
+
+    # 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)
+    updated_by: str = Field(...)
+
+    @classmethod
+    def get_collection_name(cls) -> str:
+        """Generate standard collection name"""
+        return f"{cls.DOMAIN}_{cls.OBJ_REF}s"
+
+    @field_validator('created_at', 'updated_at', mode='before')
+    @classmethod
+    def parse_datetime(cls, v: Any) -> datetime:
+        if isinstance(v, datetime): # If Firestore already gave a datetime object
+            return v # Just use it, no parsing needed
+        if isinstance(v, str): # If it's a string (e.g. from an API request, not Firestore direct)
+            try:
+                return dateutil.parser.isoparse(v)
+            except (TypeError, ValueError) as e:
+                raise ValueError(f"Invalid datetime string format: {v} - {e}")
+        # Firestore might send google.api_core.datetime_helpers.DatetimeWithNanoseconds
+        # which is a subclass of datetime.datetime, so isinstance(v, datetime) should catch it.
+        # If for some reason it's a different type not caught by isinstance(v, datetime)
+        # but has isoformat(), perhaps try that, but it's unlikely with current Firestore client.
+        # For example, if v is some custom timestamp object from an older library:
+        if hasattr(v, 'isoformat'): # Fallback for unknown datetime-like objects
+             try:
+                 return dateutil.parser.isoparse(v.isoformat())
+             except Exception as e:
+                 raise ValueError(f"Could not parse datetime-like object: {v} - {e}")
+
+        raise ValueError(f"Unsupported type for datetime parsing: {type(v)} value: {v}")

{ipulse_shared_core_ftredge-11.1.1 → ipulse_shared_core_ftredge-13.0.1}/src/ipulse_shared_core_ftredge/models/user_status.py

@@ -51,6 +51,10 @@ class UserStatus(BaseDataModel):
     DOMAIN: ClassVar[str] = "_".join(list_as_lower_strings(Layer.PULSE_APP, Module.CORE.name, Subject.USER.name))
     OBJ_REF: ClassVar[str] = "userstatus"
 
+    # Centralized collection name and document ID prefix
+    COLLECTION_NAME: ClassVar[str] = "papp_core_user_userstatuss"
+
+
     # System-managed fields
     schema_version: float = Field(
         default=VERSION,

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

@@ -0,0 +1,14 @@
+"""Service utilities for shared core."""
+# Import existing components
+from ipulse_shared_core_ftredge.services.base_service_exceptions import (
+    BaseServiceException, ServiceError, ValidationError, ResourceNotFoundError, AuthorizationError
+)
+from ipulse_shared_core_ftredge.services.servicemon import Servicemon
+from ipulse_shared_core_ftredge.services.base_firestore_service import BaseFirestoreService
+from ipulse_shared_core_ftredge.services.cache_aware_firestore_service import CacheAwareFirestoreService
+
+__all__ = [
+   'AuthorizationError', 'BaseServiceException', 'ServiceError', 'ValidationError',
+    'ResourceNotFoundError',  'BaseFirestoreService',
+    'CacheAwareFirestoreService'
+]