ipulse-shared-core-ftredge 18.0.1__py3-none-any.whl → 19.0.1__py3-none-any.whl

ipulse_shared_core_ftredge/services/base_firestore_service.py

@@ -1,249 +0,0 @@
-""" Base class for Firestore services with common CRUD operations """
-from typing import Dict, Any, List, TypeVar, Generic, Optional
-import logging
-import time
-from datetime import datetime, timezone
-from pydantic import BaseModel
-from google.cloud import firestore
-from .base_service_exceptions import ResourceNotFoundError, ValidationError, ServiceError
-
-T = TypeVar('T', bound=BaseModel)
-
-class BaseFirestoreService(Generic[T]):
-    """Base class for Firestore services with common CRUD operations"""
-
-    def __init__(
-        self,
-        db: firestore.Client,
-        collection_name: str,
-        resource_type: str,
-        logger: logging.Logger,
-        timeout: float = 15.0  # Default to 15 seconds, but allow override
-    ):
-        self.db = db
-        self.collection_name = collection_name
-        self.resource_type = resource_type
-        self.logger = logger
-        self.timeout = timeout  # Store the timeout as an instance attribute
-        self.logger.info(f"Initialized {self.resource_type} service with timeout={timeout}s")
-
-    async def create_document(self, doc_id: str, data: T, creator_uid: str) -> Dict[str, Any]:
-        """Standard create method with audit fields"""
-        try:
-            current_time = datetime.now(timezone.utc)
-            doc_data = data.model_dump(mode='json')
-
-            # Add audit fields
-            doc_data.update({
-                'created_at': current_time.isoformat(),
-                'created_by': creator_uid,
-                'updated_at': current_time.isoformat(),
-                'updated_by': creator_uid
-            })
-
-            doc_ref = self.db.collection(self.collection_name).document(doc_id)
-            # Apply timeout to the set operation
-            doc_ref.set(doc_data, timeout=self.timeout)
-
-            self.logger.info(f"Created {self.resource_type}: {doc_id}")
-            return doc_data
-
-        except Exception as e:
-            self.logger.error(f"Error creating {self.resource_type}: {e}", exc_info=True)
-            raise ServiceError(
-                operation=f"creating {self.resource_type}",
-                error=e,
-                resource_type=self.resource_type,
-                resource_id=doc_id
-            ) from e
-
-    async def create_batch_documents(self, documents: List[T], creator_uid: str) -> List[Dict[str, Any]]:
-        """Standard batch create method"""
-        try:
-            batch = self.db.batch()
-            current_time = datetime.now(timezone.utc)
-            created_docs = []
-
-            for doc in documents:
-                doc_data = doc.model_dump(mode='json')
-                doc_data.update({
-                    'created_at': current_time.isoformat(),
-                    'created_by': creator_uid,
-                    'updated_at': current_time.isoformat(),
-                    'updated_by': creator_uid
-                })
-
-                doc_ref = self.db.collection(self.collection_name).document(doc_data.get('id'))
-                batch.set(doc_ref, doc_data)
-                created_docs.append(doc_data)
-
-            # Apply timeout to the commit operation
-            batch.commit(timeout=self.timeout)
-            self.logger.info(f"Created {len(documents)} {self.resource_type}s in batch")
-            return created_docs
-
-        except Exception as e:
-            self.logger.error(f"Error batch creating {self.resource_type}s: {e}", exc_info=True)
-            raise ServiceError(
-                operation=f"batch creating {self.resource_type}s",
-                error=e,
-                resource_type=self.resource_type,
-                resource_id=doc_data.get('id')
-            ) from e
-
-    async def get_document(self, doc_id: str) -> Dict[str, Any]:
-        """Get a document by ID with standardized error handling"""
-        self.logger.debug(f"Getting {self.resource_type} document: {doc_id} with timeout={self.timeout}s")
-        start_time = time.time()
-
-        try:
-            doc_ref = self.db.collection(self.collection_name).document(doc_id)
-
-            # Apply timeout to the get operation
-            doc = doc_ref.get(timeout=self.timeout)
-
-            elapsed = (time.time() - start_time) * 1000
-            self.logger.debug(f"Firestore get for {doc_id} completed in {elapsed:.2f}ms")
-
-            if not doc.exists:
-                self.logger.warning(f"Document {doc_id} not found in {self.collection_name}")
-                raise ResourceNotFoundError(
-                    resource_type=self.resource_type,
-                    resource_id=doc_id,
-                    additional_info={"collection": self.collection_name}
-                )
-
-            return doc.to_dict()
-
-        except ResourceNotFoundError:
-            raise
-        except Exception as e:
-            elapsed = (time.time() - start_time) * 1000
-            self.logger.error(f"Error getting document {doc_id} after {elapsed:.2f}ms: {str(e)}", exc_info=True)
-            raise ServiceError(
-                operation=f"retrieving {self.resource_type}",
-                error=e,
-                resource_type=self.resource_type,
-                resource_id=doc_id,
-                additional_info={"collection": self.collection_name, "timeout": self.timeout}
-            ) from e
-
-    async def update_document(self, doc_id: str, update_data: Dict[str, Any], updater_uid: str) -> Dict[str, Any]:
-        """Standard update method with validation and audit fields"""
-        try:
-            doc_ref = self.db.collection(self.collection_name).document(doc_id)
-
-            # Apply timeout to the get operation
-            if not doc_ref.get(timeout=self.timeout).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({
-                'updated_at': datetime.now(timezone.utc).isoformat(),
-                'updated_by': updater_uid
-            })
-
-            # Apply timeout to the update operation
-            doc_ref.update(valid_fields, timeout=self.timeout)
-            # Apply timeout to the get operation
-            return doc_ref.get(timeout=self.timeout).to_dict()
-
-        except (ResourceNotFoundError, ValidationError):
-            raise
-        except Exception as e:
-            self.logger.error(f"Error updating {self.resource_type}: {e}", exc_info=True)
-            raise ServiceError(
-                operation=f"updating {self.resource_type}",
-                error=e,
-                resource_type=self.resource_type,
-                resource_id=doc_id
-            ) from e
-
-    async def delete_document(self, doc_id: str) -> None:
-        """Standard delete method"""
-        try:
-            doc_ref = self.db.collection(self.collection_name).document(doc_id)
-            # Apply timeout to the get operation
-            if not doc_ref.get(timeout=self.timeout).exists:
-                raise ResourceNotFoundError(
-                    resource_type=self.resource_type,
-                    resource_id=doc_id
-                )
-
-            # Apply timeout to the delete operation
-            doc_ref.delete(timeout=self.timeout)
-            self.logger.info(f"Deleted {self.resource_type}: {doc_id}")
-
-        except ResourceNotFoundError:
-            raise
-        except Exception as e:
-            self.logger.error(f"Error deleting {self.resource_type}: {e}", exc_info=True)
-            raise ServiceError(
-                operation=f"deleting {self.resource_type}",
-                error=e,
-                resource_type=self.resource_type,
-                resource_id=doc_id
-            ) from e
-
-    # Add query method with timeout
-    async def query_documents(
-        self,
-        filters: Optional[List[tuple]] = None,
-        limit: Optional[int] = None,
-        order_by: Optional[tuple] = None
-    ) -> List[Dict[str, Any]]:
-        """Query documents with filters, limit, and ordering"""
-        try:
-            # Start with the collection reference
-            query = self.db.collection(self.collection_name)
-
-            # Apply filters if provided
-            if filters:
-                for field, op, value in filters:
-                    query = query.where(field=field, op_string=op, value=value)
-
-            # Apply ordering if provided
-            if order_by:
-                field, direction = order_by
-                query = query.order_by(field, direction=direction)
-
-            # Apply limit if provided
-            if limit:
-                query = query.limit(limit)
-
-            # Execute query with timeout
-            docs = query.stream(timeout=self.timeout)
-            return [doc.to_dict() for doc in docs]
-
-        except Exception as e:
-            self.logger.error(f"Error querying {self.resource_type}: {e}", exc_info=True)
-            raise ServiceError(
-                operation=f"querying {self.resource_type}",
-                error=e,
-                resource_type=self.resource_type
-            ) from e
-
-    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

ipulse_shared_core_ftredge/services/fastapiservicemon.py

@@ -1,140 +0,0 @@
-""" FastAPI ServiceMon"""
-import logging
-import time
-from fastapi import Request
-from ipulse_shared_base_ftredge import DataResource, Action, ProgressStatus, LogLevel
-from starlette.middleware.base import BaseHTTPMiddleware
-from . import Servicemon
-
-
-class FastAPIServiceMon(Servicemon):
-    """
-    Extension of Servicemon designed specifically for FastAPI applications.
-    Adds integration with FastAPI request/response lifecycle.
-    """
-
-    @staticmethod
-    def get_fastapi_middleware():
-        """
-        Creates a FastAPI middleware class that uses ServiceMon for request logging.
-
-        Returns:
-            A middleware class that can be registered with FastAPI
-        """
-
-
-        class ServiceMonMiddleware(BaseHTTPMiddleware):
-            """
-            Middleware class for integrating ServiceMon into FastAPI request/response lifecycle.
-            """
-            async def dispatch(self, request: Request, call_next):
-                # Create ServiceMon instance
-                logger_name = f"{request.app.state.env_prefix}__dp_core_api_live__apilogger"
-                logger = logging.getLogger(logger_name)
-
-                path = request.url.path
-                method = request.method
-
-                # Skip monitoring for certain paths
-                skip_paths = ["/health", "/metrics", "/docs", "/redoc", "/openapi.json"]
-                if any(path.startswith(skip_p) for skip_p in skip_paths):
-                    return await call_next(request)
-
-                # Initialize ServiceMon
-                servicemon = Servicemon(
-                    logger=logger,
-                    base_context=f"API: {path}\nMethod: {method}",
-                    service_name=f"API_{method}_{path.replace('/', '_')}"
-                )
-
-                # Start monitoring
-                client_ip = request.client.host if request.client else "unknown"
-                user_agent = request.headers.get("user-agent", "unknown")
-                servicemon.start(f"API Request {method} {path}")
-
-
-                # Add request info
-                servicemon.log(
-                    level=LogLevel.INFO,
-                    description=f"Request received for {method} {path}. Client IP: {client_ip}. User Agent: {user_agent}",
-                    resource=DataResource.API_INTERNAL,
-                    action=Action.EXECUTE,
-                    progress_status=ProgressStatus.STARTED,
-                )
-
-                # Process the request and catch any errors
-                try:
-                    # Store ServiceMon in request state for handlers to access
-                    request.state.svcmon = servicemon
-
-                    # Process request
-                    start_time = time.time()
-                    response = await call_next(request)
-                    process_time = int((time.time() - start_time) * 1000)
-
-                    # Log response
-                    status_code = response.status_code
-                    progress_status = (
-                        ProgressStatus.DONE
-                        if 200 <= status_code < 300
-                        else ProgressStatus.FINISHED_WITH_ISSUES
-                    )
-
-                    log_level = (
-                        LogLevel.ERROR if status_code >= 500
-                        else LogLevel.WARNING if status_code >= 400
-                        else LogLevel.INFO
-                    )
-
-                    servicemon.log(
-                        level=log_level,
-                        description=f"Response sent: {status_code} in {process_time}ms for {method} {path}",
-                        resource=DataResource.API_INTERNAL,
-                        action=Action.EXECUTE,
-                        progress_status=progress_status
-
-                    )
-
-                    # Finalize monitoring
-                    servicemon.end(status=progress_status)
-                    return response
-
-                except Exception as exc:
-                    # Log error and re-raise
-                    servicemon.log(
-                        level=LogLevel.ERROR,
-                        description=f"Error processing request: {exc}",
-                        resource=DataResource.API_INTERNAL,
-                        action=Action.EXECUTE,
-                        progress_status=ProgressStatus.FAILED
-                    )
-
-                    servicemon.end(status=ProgressStatus.FAILED)
-                    raise
-
-        return ServiceMonMiddleware
-
-    # @staticmethod
-    # def setup_fastapi(app):
-    #     """
-    #     Configure a FastAPI application with ServiceMon integration.
-
-    #     Args:
-    #         app: The FastAPI application instance
-    #     """
-    #     from fastapi import FastAPI
-
-    #     if not isinstance(app, FastAPI):
-    #         raise TypeError("Expected FastAPI application instance")
-
-    #     # Register middleware
-    #     app.add_middleware(FastAPIServiceMon.get_fastapi_middleware())
-
-    #     # Add dependency for route handlers
-    #     from fastapi import Depends, Request
-
-    #     async def get_servicemon(request: Request):
-    #         """Dependency for accessing the current ServiceMon instance."""
-    #         return getattr(request.state, "svcmon", None)
-
-    #     app.dependency_overrides[FastAPIServiceMon] = get_servicemon

ipulse_shared_core_ftredge/services/servicemon.py

@@ -1,240 +0,0 @@
-"""
-ServiceMon - Lightweight monitoring for service functions and API endpoints
-"""
-import uuid
-import time
-from datetime import datetime, timezone
-from typing import Dict, Any, Optional
-from contextlib import contextmanager
-from ipulse_shared_base_ftredge import (LogLevel, AbstractResource,
-                                      ProgressStatus, Action, Resource,
-                                      Alert, StructLog)
-
-class Servicemon:
-    """
-    ServiceMon is a lightweight version of Pipelinemon designed specifically for monitoring
-    service functions like Cloud Functions and API endpoints.
-
-    It provides:
-    1. Structured logging with context tracking
-    2. Performance metrics capture
-    3. Service health monitoring
-    4. Integration with FastAPI request/response cycle
-    """
-
-    def __init__(self, logger,
-                 base_context: str,
-                 service_name: str):
-        """
-        Initialize ServiceMon with basic configuration.
-
-        Args:
-            logger: The logger instance to use for logging
-            base_context: Base context information for all logs
-            service_name: Name of the service being monitored
-        """
-        # Set up execution tracking details
-        self._start_time = None
-        self._service_name = service_name
-
-        timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M%S')
-        uuid_suffix = str(uuid.uuid4())[:8]  # Take first 8 chars of UUID
-        self._id = f"{timestamp}_{uuid_suffix}"
-
-        # Set up context handling
-        self._base_context = base_context
-        self._context_stack = []
-
-        # Configure logging
-        self._logger = logger
-
-        # Metrics tracking
-        self._metrics = {
-            "status": ProgressStatus.NOT_STARTED.name,
-            "errors": 0,
-            "warnings": 0,
-            "start_time": None,
-            "end_time": None,
-            "duration_ms": None,
-        }
-
-    @property
-    def id(self) -> str:
-        """Get the unique ID for this service execution."""
-        return self._id
-
-    @property
-    def base_context(self) -> str:
-        """Get the base context for this service execution."""
-        return self._base_context
-
-    @property
-    def service_name(self) -> str:
-        """Get the service name being monitored."""
-        return self._service_name
-
-    @property
-    def metrics(self) -> Dict[str, Any]:
-        """Get the current service metrics."""
-        return self._metrics.copy()
-
-    @property
-    def current_context(self) -> str:
-        """Get the current context stack as a string."""
-        return " >> ".join(self._context_stack) if self._context_stack else "root"
-
-    @contextmanager
-    def context(self, context_name: str):
-        """
-        Context manager for tracking execution context.
-
-        Args:
-            context_name: The name of the current execution context
-        """
-        self.push_context(context_name)
-        try:
-            yield
-        finally:
-            self.pop_context()
-
-    def push_context(self, context: str):
-        """Add a context level to the stack."""
-        self._context_stack.append(context)
-
-    def pop_context(self):
-        """Remove the most recent context from the stack."""
-        if self._context_stack:
-            return self._context_stack.pop()
-
-    def start(self, description: Optional[str] = None) -> None:
-        """
-        Start monitoring a service execution.
-
-        Args:
-            description: Optional description of what's being executed
-        """
-        self._start_time = time.time()
-        self._metrics["start_time"] = datetime.now(timezone.utc).isoformat()
-        self._metrics["status"] = ProgressStatus.IN_PROGRESS.name
-
-        # Log the start event
-        msg = description if description else f"Starting {self.service_name}"
-        self.log(level=LogLevel.INFO, description=msg, resource=AbstractResource.SERVICEMON, action=Action.EXECUTE,
-                 progress_status=ProgressStatus.IN_PROGRESS)
-
-    def end(self, status: ProgressStatus = ProgressStatus.DONE) -> Dict[str, Any]:
-        """
-        End monitoring and record final metrics.
-
-        Args:
-            status: The final status of the service execution
-
-        Returns:
-            Dict containing metrics summary
-        """
-        # Calculate duration
-        end_time = time.time()
-        if self._start_time:
-            duration_ms = int((end_time - self._start_time) * 1000)
-            self._metrics["duration_ms"] = duration_ms
-
-        # Update metrics
-        self._metrics["end_time"] = datetime.now(timezone.utc).isoformat()
-        self._metrics["status"] = status.name
-
-        # Determine log level based on metrics
-        if self._metrics["errors"] > 0:
-            level = LogLevel.ERROR
-            if status == ProgressStatus.DONE:
-                status = ProgressStatus.FINISHED_WITH_ISSUES
-        elif self._metrics["warnings"] > 0:
-            level = LogLevel.WARNING
-            if status == ProgressStatus.DONE:
-                status = ProgressStatus.DONE_WITH_WARNINGS
-        else:
-            level = LogLevel.INFO
-
-        # Prepare summary message
-        summary_msg = (
-            f"Service {self.service_name} completed with status {status.name}. "
-            f"Duration: {self._metrics['duration_ms']}ms. "
-            f"Errors: {self._metrics['errors']}, Warnings: {self._metrics['warnings']}"
-        )
-
-        # Log the completion
-        self.log(
-            level=level,
-            description=summary_msg,
-            resource=AbstractResource.SERVICEMON,
-            action=Action.EXECUTE,
-            progress_status=status,
-        )
-
-        return self._metrics
-
-    def log(self,
-           level: LogLevel,
-           description: str,
-           resource: Optional[Resource] = None,
-           source: Optional[str] = None,
-           destination: Optional[str] = None,
-           action: Optional[Action] = None,
-           progress_status: Optional[ProgressStatus] = None,
-           alert: Optional[Alert] = None,
-           e: Optional[Exception] = None,
-           systems_impacted: Optional[str] = None,
-           notes: Optional[str] = None,
-           **kwargs) -> None:
-        """
-        Log a message with structured context.
-
-        Args:
-            level: Log level
-            description: Log message
-            resource: Resource being accessed
-            action: Action being performed
-            progress_status: Current progress status
-            alert: Alert type if applicable
-            e: Exception if logging an error
-            **kwargs: Additional fields to include in the log
-        """
-        # Update metrics
-        if level in (LogLevel.ERROR, LogLevel.CRITICAL):
-            self._metrics["errors"] += 1
-        elif level == LogLevel.WARNING:
-            self._metrics["warnings"] += 1
-
-
-        formatted_notes = f"{notes} ;elapsed_ms: {int((time.time() - self._start_time) * 1000)} " + str(kwargs)
-        # Create structured log
-        log = StructLog(
-            level=level,
-            resource=resource,
-            action=action,
-            progress_status=progress_status,
-            alert=alert,
-            e=e,
-            source=source,
-            destination=destination,
-            description=description,
-            collector_id=self.id,
-            base_context=self.base_context,
-            context=self.current_context,
-            systems_impacted=systems_impacted,
-            note=formatted_notes,
-            **kwargs
-        )
-
-        # Add service-specific fields
-        log_dict = log.to_dict()
-
-        # Write to logger
-        if level.value >= LogLevel.ERROR.value:
-            self._logger.error(log_dict)
-        elif level.value >= LogLevel.WARNING.value:
-            self._logger.warning(log_dict)
-        elif level.value >= LogLevel.INFO.value:
-            self._logger.info(log_dict)
-        else:
-            self._logger.debug(log_dict)
-

ipulse_shared_core_ftredge-18.0.1.dist-info/RECORD

@@ -1,33 +0,0 @@
-ipulse_shared_core_ftredge/__init__.py,sha256=b7hQEEfgIhLyLycNaM5vrCNVfiCrFoUkVdAGCP0nsbM,516
-ipulse_shared_core_ftredge/cache/__init__.py,sha256=i2fPojmZiBwAoY5ovnnnME9USl4bi8MRPYkAgEfACfI,136
-ipulse_shared_core_ftredge/cache/shared_cache.py,sha256=NMHSQyHjhn11IB3cQjw7ctV18CXBT1X6FC2UvURtBy8,12957
-ipulse_shared_core_ftredge/dependencies/__init__.py,sha256=HGsR8HUguKTfjz_BorCILS4izX8CAjG-apE0kIPE0Yo,68
-ipulse_shared_core_ftredge/dependencies/auth_firebase_token_validation.py,sha256=EFWyhoVOI0tGYOWqN5St4JNIy4cMwpxeBhKdjOwEfbg,1888
-ipulse_shared_core_ftredge/dependencies/auth_protected_router.py,sha256=em5D5tE7OkgZmuCtYCKuUAnIZCgRJhCF8Ye5QmtGWlk,1807
-ipulse_shared_core_ftredge/dependencies/authz_for_apis.py,sha256=6mJwk_xJILbnvPDfnxXyCebvP9TymvK0NaEDT8KBU-A,15826
-ipulse_shared_core_ftredge/dependencies/firestore_client.py,sha256=VbTb121nsc9EZPd1RDEsHBLW5pIiVw6Wdo2JFL4afMg,714
-ipulse_shared_core_ftredge/models/__init__.py,sha256=xGbDLElTRbUwcQaOTwz5Myxv5hAP2S3xSTMgO2hN-Ko,456
-ipulse_shared_core_ftredge/models/base_api_response.py,sha256=OwuWI2PsMSLDkFt643u35ZhW5AHFEMMAGnGprmUO0fA,2380
-ipulse_shared_core_ftredge/models/base_data_model.py,sha256=feG_K4i1xX_J_h9QrdxshmFvUsS1_hWR8BBoh0DRxoM,2543
-ipulse_shared_core_ftredge/models/organization_profile.py,sha256=OnjsSVcp_LSB65F9Tl9udwNgqMg7gjSpv38eArpVXPc,3668
-ipulse_shared_core_ftredge/models/subscription.py,sha256=bu6BtyDQ4jDkK3PLY97dZ_A3cmjzZahTkuaFOFybdxI,6892
-ipulse_shared_core_ftredge/models/user_auth.py,sha256=YgCeK0uJ-JOkPavwzogl4wGC3RpA8PVfl-5MPS4Kxhk,432
-ipulse_shared_core_ftredge/models/user_profile.py,sha256=5cTTZa7pMkgKCsLgTPpvz_aPn-ZyQcJ3xSEtu3jq3HE,4138
-ipulse_shared_core_ftredge/models/user_profile_update.py,sha256=3BqAAqnVKXPKhAcfV_aOERe8GyIkX0NU_LJcQa02aLw,1319
-ipulse_shared_core_ftredge/models/user_status.py,sha256=rAx8l5GrB8TN7RvZ1eIMskphRxdYqO1OZ8NnaIxUUW8,23660
-ipulse_shared_core_ftredge/services/__init__.py,sha256=tUUZxdAfth0oqF0bkTrj1FlRJQnZkMrF1r1ryNB-yU4,906
-ipulse_shared_core_ftredge/services/base_firestore_service.py,sha256=n1lymQEFcu6zHkdscNNCNIzTIVmja8cBtNy2yi5vfTE,9817
-ipulse_shared_core_ftredge/services/base_service_exceptions.py,sha256=Bi0neeMY0YncWDeqUavu5JUslkjJ6QcDVRU32Ipjc08,4294
-ipulse_shared_core_ftredge/services/cache_aware_firestore_service.py,sha256=rPaE2gZ05iAo5TKfIqc0yuyiVJqfbd7TQBFhWdUHJNc,7870
-ipulse_shared_core_ftredge/services/charging_processors.py,sha256=8bozatlie8egZFA-IUc2Vh1zjhyTdDqoe5nNgsL_ebM,16170
-ipulse_shared_core_ftredge/services/charging_service.py,sha256=buUR09TWLEmDeo1n3-DxRz9Vc8tLkYP4DTzlyVkHogM,14639
-ipulse_shared_core_ftredge/services/fastapiservicemon.py,sha256=27clTZXH32mbju8o-HLO_8VrmugmpXwHLuX-OOoIAew,5308
-ipulse_shared_core_ftredge/services/servicemon.py,sha256=wWhsLwU1_07emaEyCNziZA1bDQVLxcfvQj0OseTLSTI,7969
-ipulse_shared_core_ftredge/utils/__init__.py,sha256=JnxUb8I2MRjJC7rBPXSrpwBIQDEOku5O9JsiTi3oun8,56
-ipulse_shared_core_ftredge/utils/custom_json_encoder.py,sha256=DblQLD0KOSNDyQ58wQRogBrShIXzPIZUw_oGOBATnJY,1366
-ipulse_shared_core_ftredge/utils/json_encoder.py,sha256=QkcaFneVv3-q-s__Dz4OiUWYnM6jgHDJrDMdPv09RCA,2093
-ipulse_shared_core_ftredge-18.0.1.dist-info/licenses/LICENCE,sha256=YBtYAXNqCCOo9Mr2hfkbSPAM9CeAr2j1VZBSwQTrNwE,1060
-ipulse_shared_core_ftredge-18.0.1.dist-info/METADATA,sha256=SXCSNUI23dl8PQes6lO-5wItHJowquYaqJr4eiWebtM,803
-ipulse_shared_core_ftredge-18.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ipulse_shared_core_ftredge-18.0.1.dist-info/top_level.txt,sha256=8sgYrptpexkA_6_HyGvho26cVFH9kmtGvaK8tHbsGHk,27
-ipulse_shared_core_ftredge-18.0.1.dist-info/RECORD,,

ipulse_shared_core_ftredge/{services/base_service_exceptions.py → exceptions/base_exceptions.py}

@@ -99,6 +99,7 @@ class ResourceNotFoundError(BaseServiceException):
             additional_info=additional_info
         )
 
+
 class AuthorizationError(BaseServiceException):
     def __init__(
         self,
@@ -132,4 +133,3 @@ class ValidationError(BaseServiceException):
             resource_id=resource_id,
             additional_info=additional_info
         )
-