quapp-common 0.0.11.dev1__tar.gz → 0.0.11.dev2__tar.gz

{quapp_common-0.0.11.dev1/quapp_common.egg-info → quapp_common-0.0.11.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.11.dev1
+Version: 0.0.11.dev2
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -32,10 +32,25 @@ Requires-Dist: pip-tools; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Dynamic: license-file
 
-# qapp-common
+# quapp-common
 
-# changes
-- Add pennylane in enum sdk
-- Change function in `device.py` to protected to override in pennylane sdk
+Quapp common library supporting Quapp Platform for Quantum Computing.
 
+## Overview
 
+`quapp-common` is a Python library designed to support the Quapp Platform for Quantum Computing by
+providing common utilities, configurations, and abstractions for working with quantum providers and
+devices.
+
+## Features
+
+- Provider and device factory for quantum computing platforms.
+- Logging and configuration utilities.
+- Support for AWS Braket, OQC Cloud, Qiskit, PennyLane, DWave Ocean and Quapp quantum simulators.
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install quapp-common

quapp_common-0.0.11.dev2/README.md

@@ -0,0 +1,22 @@
+# quapp-common
+
+Quapp common library supporting Quapp Platform for Quantum Computing.
+
+## Overview
+
+`quapp-common` is a Python library designed to support the Quapp Platform for Quantum Computing by
+providing common utilities, configurations, and abstractions for working with quantum providers and
+devices.
+
+## Features
+
+- Provider and device factory for quantum computing platforms.
+- Logging and configuration utilities.
+- Support for AWS Braket, OQC Cloud, Qiskit, PennyLane, DWave Ocean and Quapp quantum simulators.
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install quapp-common

{quapp_common-0.0.11.dev1 → quapp_common-0.0.11.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.11.dev1"
+version = "0.0.11.dev2"
 description = "Quapp common library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]

{quapp_common-0.0.11.dev1/qapp_common → quapp_common-0.0.11.dev2/quapp_common}/async_tasks/export_circuit_task.py

@@ -6,13 +6,15 @@ from io import BytesIO
 import requests
 
 from .async_task import AsyncTask
+from ..config.logging_config import logger
 from ..data.async_task.circuit_export.backend_holder import BackendDataHolder
 from ..data.async_task.circuit_export.circuit_holder import CircuitDataHolder
-from ..config.logging_config import logger
 from ..enum.media_type import MediaType
 from ..util.file_utils import FileUtils
 from ..util.http_utils import HttpUtils
 
+logger = logger.bind(context='CircuitExportTask')
+
 
 class CircuitExportTask(AsyncTask):
     MAX_CIRCUIT_IMAGE_SIZE = 5 * (1024 ** 2)
@@ -28,7 +30,7 @@ class CircuitExportTask(AsyncTask):
         """
           Export circuit to svg file then send to QuaO server for saving
         """
-        logger.debug("[Circuit export] Start")
+        logger.debug("Start")
 
         circuit_export_url = self.circuit_data_holder.export_url
 
@@ -47,11 +49,11 @@ class CircuitExportTask(AsyncTask):
 
         @return:
         """
-        logger.debug("[Circuit export] Preparing circuit figure...")
+        logger.debug("Preparing circuit figure...")
         transpiled_circuit = self._transpile_circuit()
         circuit_figure = transpiled_circuit.draw(output='mpl', fold=-1)
 
-        logger.debug("[Circuit export] Converting circuit figure to svg file...")
+        logger.debug("Converting circuit figure to svg file...")
         figure_buffer = BytesIO()
         circuit_figure.savefig(figure_buffer, format='svg', bbox_inches='tight')
 
@@ -67,11 +69,11 @@ class CircuitExportTask(AsyncTask):
         buffer_value = figure_buffer.getvalue()
         content_type = MediaType.SVG_XML
 
-        logger.debug("[Circuit export] Checking max file size")
+        logger.debug("Checking max file size")
         estimated_file_size = len(buffer_value)
 
         if estimated_file_size > CircuitExportTask.MAX_CIRCUIT_IMAGE_SIZE:
-            logger.debug("[Circuit export] Zip file")
+            logger.debug("Zip file")
             zip_file_buffer = FileUtils.zip(io_buffer_value=buffer_value,
                                             file_name="circuit_image.svg")
 
@@ -89,7 +91,7 @@ class CircuitExportTask(AsyncTask):
         url = self.circuit_data_holder.export_url
 
         logger.debug(
-            "[Circuit export] Sending circuit svg image to [{0}] with POST method ...".format(
+            "Sending circuit svg image to [{0}] with POST method ...".format(
                 url))
 
         payload = {'circuit': (
@@ -105,10 +107,10 @@ class CircuitExportTask(AsyncTask):
         if response.ok:
             logger.debug("Sending request to QuaO backend successfully!")
         else:
-            logger.debug("Sending request to QuaO backend failed with status {0}!".format(
+            logger.error("Sending request to QuaO backend failed with status {0}!".format(
                 response.status_code))
 
-        logger.debug("[Circuit export] Finish")
+        logger.debug("Finish")
 
     def _transpile_circuit(self):
         """

{quapp_common-0.0.11.dev1/qapp_common → quapp_common-0.0.11.dev2/quapp_common}/async_tasks/post_processing_task.py

@@ -11,6 +11,8 @@ from ..enum.status.job_status import JobStatus
 from ..enum.status.status_code import StatusCode
 from ..util.json_parser_utils import JsonParserUtils
 
+logger = logger.bind(context='PostProcessingTask')
+
 
 class PostProcessingTask(AsyncTask):
     def __init__(self,

{quapp_common-0.0.11.dev1/qapp_common → quapp_common-0.0.11.dev2/quapp_common}/component/backend/invocation.py

@@ -1,7 +1,7 @@
 """
     QApp Platform Project backend.py Copyright © CITYNOW Co. Ltd. All rights reserved.
 """
-from abc import abstractmethod, ABC
+from abc import ABC, abstractmethod
 
 from ..callback.update_job_metadata import update_job_metadata
 from ...component.device.device_selection import DeviceSelection
@@ -22,6 +22,8 @@ from ...model.provider.provider import Provider
 
 EXPORT_CIRCUIT_SDK = {Sdk.QISKIT, Sdk.BRAKET}
 
+logger = logger.bind(context='Invocation')
+
 
 class Invocation(ABC):
     def __init__(self, request_data: InvocationRequest):
@@ -54,7 +56,7 @@ class Invocation(ABC):
         @param circuit_preparation_fn: Circuit-preparation function
         @return: Job result
         """
-        logger.debug("[Invocation] Invoke job")
+        logger.debug("Invoke job")
 
         circuit = self.__pre_execute(circuit_preparation_fn)
 
@@ -105,7 +107,7 @@ class Invocation(ABC):
         @return: Job response
         """
 
-        logger.debug("[Invocation] Execute job")
+        logger.debug("Execute job")
 
         try:
             if self.backend_information is None:
@@ -116,7 +118,7 @@ class Invocation(ABC):
             backend_authentication = self.backend_information.authentication
 
             logger.debug(
-                "[Invocation] Execute job with provider tag: {0}".format(
+                "Execute job with provider tag: {0}".format(
                     provider_tag.value
                 )
             )
@@ -124,7 +126,7 @@ class Invocation(ABC):
             provider = self._create_provider()
 
             logger.debug(
-                "[Invocation] Execute job with device name: {0}".format(device_name)
+                "Execute job with device name: {0}".format(device_name)
             )
             device = self._create_device(provider)
 
@@ -159,7 +161,7 @@ class Invocation(ABC):
         @param circuit_preparation_fn: Circuit preparation function
         @return: circuit
         """
-        logger.debug("[Invocation] Prepare circuit")
+        logger.debug("Prepare circuit")
 
         job_response = JobResponse(
             status_code=StatusCode.DONE,
@@ -215,11 +217,9 @@ class Invocation(ABC):
         )
 
         self.backend_information = device_selection.select()
-        logger.info("before")
-        logger.info(self.backend_information.authentication)
+        logger.debug(f"Updating backend authentication")
         self.backend_information.authentication = self.invoke_authentication
-        logger.info("after")
-        logger.info(self.backend_information.authentication)
+        logger.debug(f"Backend authentication updated")
 
     @abstractmethod
     def _export_circuit(self, circuit):
@@ -228,7 +228,7 @@ class Invocation(ABC):
         @param circuit: Circuit was exported
         """
 
-        raise NotImplemented('[Invocation] _export_circuit() method must be implemented')
+        raise NotImplemented('_export_circuit() method must be implemented')
 
     @abstractmethod
     def _create_provider(self, ):
@@ -236,7 +236,7 @@ class Invocation(ABC):
         Create provider with ProviderFactory
         """
 
-        raise NotImplemented('[Invocation] _create_provider() method must be implemented')
+        raise NotImplemented('_create_provider() method must be implemented')
 
     @abstractmethod
     def _create_device(self, provider: Provider):
@@ -244,7 +244,7 @@ class Invocation(ABC):
         Create device with DeviceFactory
         """
 
-        raise NotImplemented('[Invocation] _create_device() method must be implemented')
+        raise NotImplemented('_create_device() method must be implemented')
 
     @abstractmethod
     def _get_qubit_amount(self, circuit):
@@ -252,4 +252,4 @@ class Invocation(ABC):
         Get number qubit of circuit
         """
 
-        raise NotImplemented('[Invocation] _get_qubit_amount() method must be implemented')
+        raise NotImplemented('_get_qubit_amount() method must be implemented')

quapp_common-0.0.11.dev2/quapp_common/component/backend/job_fetcher.py

@@ -0,0 +1,231 @@
+"""
+    QApp Platform Project job_fetching.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from abc import ABC, abstractmethod
+from typing import Dict
+
+from ..callback.update_job_metadata import update_job_metadata
+from ...async_tasks.post_processing_task import PostProcessingTask
+from ...config.logging_config import logger
+from ...config.thread_config import circuit_running_pool
+from ...data.callback.callback_url import CallbackUrl
+from ...data.promise.post_processing_promise import PostProcessingPromise
+from ...data.request.job_fetching_request import JobFetchingRequest
+from ...data.response.authentication import Authentication
+from ...data.response.job_response import JobResponse
+from ...data.response.project_header import ProjectHeader
+from ...enum.invocation_step import InvocationStep
+from ...enum.media_type import MediaType
+from ...enum.status.job_status import JobStatus
+from ...enum.status.status_code import StatusCode
+from ...util.json_parser_utils import JsonParserUtils
+from ...util.response_utils import ResponseUtils
+
+logger = logger.bind(context='JobFetcher')
+
+
+class JobFetcher(ABC):
+    """
+       Abstract base class for fetching job results from different providers.
+       """
+
+    def __init__(self, request_data: JobFetchingRequest):
+        """Initializes the JobFetcher with request data."""
+        self.provider_authentication: Dict = request_data.provider_authentication
+        self.provider_job_id: str = request_data.provider_job_id
+        self.backend_authentication: Authentication = request_data.authentication
+        self.project_header: ProjectHeader = request_data.project_header
+        self.callback_urls: Dict[InvocationStep, CallbackUrl] = {
+            InvocationStep.EXECUTION: request_data.execution,
+            InvocationStep.ANALYSIS: request_data.analysis,
+            InvocationStep.FINALIZATION: request_data.finalization
+        }
+
+        logger.debug(f"[{self.provider_job_id}] Initialized JobFetcher")
+
+    @abstractmethod
+    def _collect_provider(self):
+        """Abstract method to create and return the provider client."""
+        raise NotImplementedError('[JobFetcher] _collect_provider() method must be implemented')
+
+    @abstractmethod
+    def _retrieve_job(self, provider):
+        """Abstract method to retrieve the job object from the provider."""
+        raise NotImplementedError('[JobFetcher] _retrieve_job() method must be implemented')
+
+    @abstractmethod
+    def _get_job_status(self, job):
+        """Abstract method to extract the job status from the provider's job object."""
+        raise NotImplementedError('[JobFetcher] _get_job_status() method must be implemented')
+
+    @abstractmethod
+    def _get_job_result(self, job):
+        """Abstract method to extract the raw job result from the provider's job object."""
+        raise NotImplementedError('[JobFetcher] _get_job_result() method must be implemented')
+
+    @abstractmethod
+    def _produce_histogram_data(self, job_result) -> dict | None:
+        """Abstract method to produce histogram data from the raw job result."""
+        raise NotImplementedError(
+            '[JobFetcher] _produce_histogram_data() method must be implemented')
+
+    @abstractmethod
+    def _get_execution_time(self, job_result):
+        """Abstract method to extract the execution time from the raw job result."""
+        raise NotImplementedError('[JobFetcher] _get_execution_time() method must be implemented')
+
+    @abstractmethod
+    def _get_shots(self, job_result):
+        """Abstract method to extract the number of shots from the raw job result."""
+        raise NotImplementedError('[JobFetcher] _get_shots() method must be implemented')
+
+    def fetch(self, post_processing_fn):
+        """Fetches the job, handles different job statuses, and initiates post-processing."""
+        logger.debug(f'[{self.provider_job_id}] Fetch job')
+        job_response = JobResponse(
+            provider_job_id=self.provider_job_id,
+            authentication=self.backend_authentication,
+            project_header=self.project_header,
+            status_code=StatusCode.DONE
+        )
+
+        try:
+            logger.debug(f'[{self.provider_job_id}] Collecting provider')
+            provider = self._collect_provider()
+
+            logger.debug(
+                f'[{self.provider_job_id}] Retrieving job from provider')
+            job = self._retrieve_job(provider)
+
+            logger.debug(f'[{self.provider_job_id}] Getting job status')
+            job_status = self._get_job_status(job)
+
+            logger.debug(
+                f'[{self.provider_job_id}] Getting original job result')
+            original_job_result = self._get_job_result(job)
+
+            logger.info(f'[{self.provider_job_id}] Job status: {job_status}')
+            job_response.job_status = job_status
+
+            if job_status == JobStatus.DONE.value:
+                self._handle_successful_job(original_job_result, job_response, post_processing_fn)
+                update_job_metadata(job_response=job_response, callback_url=self.callback_urls[
+                    InvocationStep.EXECUTION].on_done)
+            elif job_status == JobStatus.ERROR.value:
+                self._handle_failed_job(original_job_result, job_response)
+                update_job_metadata(job_response=job_response, callback_url=self.callback_urls[
+                    InvocationStep.EXECUTION].on_error)
+            else:
+                logger.info(
+                    f'[{self.provider_job_id}] Job is in {job_status}, setting status to POLLING')
+                job_response.status_code = StatusCode.POLLING
+
+        except Exception as e:
+            self._handle_fetch_exception(job_response, e)
+            update_job_metadata(job_response=job_response,
+                                callback_url=self.callback_urls[InvocationStep.EXECUTION].on_error)
+
+        logger.debug(f'[{self.provider_job_id}] Returning response')
+        return ResponseUtils.generate_response(job_response)
+
+    def _handle_successful_job(self, original_job_result, job_response: JobResponse,
+                               post_processing_fn):
+        """Handles the job result when the job is successfully completed."""
+        logger.debug(
+            f'[{self.provider_job_id}] Handling successful job')
+        circuit_running_pool.submit(
+            self._process_job_result,
+            original_job_result,
+            job_response,
+            self.callback_urls,
+            post_processing_fn
+        )
+
+    def _handle_failed_job(self, original_job_result, job_response: JobResponse):
+        """Handles the job result when the job has encountered an error."""
+        logger.error(f'[{self.provider_job_id}] Handling failed job')
+        job_response.job_result = JsonParserUtils.parse(original_job_result)
+
+    def _handle_fetch_exception(self, job_response: JobResponse, exception: Exception):
+        """Handles exceptions that occur during the job fetching process."""
+        logger.error(
+            f'[{self.provider_job_id}] Exception when fetching job: {exception}')
+        job_response.job_result = {
+            'error': f'Exception when fetching job: {exception}',
+            'exception': str(exception),
+        }
+        job_response.status_code = StatusCode.ERROR
+        job_response.job_status = JobStatus.ERROR.value
+
+    def _process_job_result(self, original_job_result, job_response: JobResponse,
+                            callback_urls: Dict[InvocationStep, CallbackUrl], post_processing_fn):
+        """Processes the job result through analysis and finalization steps."""
+        logger.debug(
+            f'[{self.provider_job_id}] Processing job result')
+
+        job_response = self._on_analysis(
+            callback_url=callback_urls[InvocationStep.ANALYSIS],
+            job_response=job_response,
+            original_job_result=original_job_result
+        )
+
+        if job_response:
+            self._on_finalization(
+                post_processing_fn=post_processing_fn,
+                callback_url=callback_urls[InvocationStep.FINALIZATION],
+                original_job_result=original_job_result
+            )
+
+    def _on_analysis(self, callback_url: CallbackUrl, job_response: JobResponse,
+                     original_job_result) -> JobResponse | None:
+        """Handles the analysis step of the job result."""
+        logger.debug(f'[{self.provider_job_id}] On analysis')
+        update_job_metadata(job_response=job_response, callback_url=callback_url.on_start)
+        logger.debug(
+            f'[{self.provider_job_id}] Calling update_job_metadata on_start')
+
+        try:
+            job_response.content_type = MediaType.APPLICATION_JSON
+
+            logger.debug(f'[{self.provider_job_id}] Producing histogram data')
+            job_response.job_histogram = self._produce_histogram_data(original_job_result)
+
+            logger.debug(f'[{self.provider_job_id}] Getting execution time')
+            job_response.execution_time = self._get_execution_time(original_job_result)
+
+            logger.debug(f'[{self.provider_job_id}] Getting shots')
+            job_response.shots = self._get_shots(original_job_result)
+
+            update_job_metadata(job_response=job_response, callback_url=callback_url.on_done)
+            logger.debug(
+                f'[{self.provider_job_id}] Calling update_job_metadata on_done')
+
+            return job_response
+
+        except Exception as e:
+            logger.error(
+                f'[{self.provider_job_id}] Exception during analysis: {e}')
+            job_response.status_code = StatusCode.ERROR
+            job_response.job_status = JobStatus.ERROR.value
+            job_response.job_result = {
+                "error": f'Exception during analysis: {e}',
+                "exception": str(e),
+            }
+
+            update_job_metadata(job_response=job_response, callback_url=callback_url.on_error)
+            logger.debug(
+                f'[{self.provider_job_id}] Calling update_job_metadata on_error')
+            return None
+
+    def _on_finalization(self, post_processing_fn, callback_url: CallbackUrl, original_job_result):
+        """Handles the finalization step of the job result."""
+        logger.debug(f'[{self.provider_job_id}] On finalization')
+        promise = PostProcessingPromise(
+            callback_url=callback_url,
+            authentication=self.backend_authentication,
+            job_result=original_job_result,
+            project_header=self.project_header
+        )
+
+        logger.debug(f'[{self.provider_job_id}]Creating PostProcessingTask')
+        PostProcessingTask(post_processing_fn=post_processing_fn, promise=promise).do()

{quapp_common-0.0.11.dev1/qapp_common → quapp_common-0.0.11.dev2/quapp_common}/component/backend/job_fetching.py

@@ -6,6 +6,7 @@ from typing import Any
 
 from ..callback.update_job_metadata import update_job_metadata
 from ...async_tasks.post_processing_task import PostProcessingTask
+from ...config.logging_config import logger
 from ...config.thread_config import circuit_running_pool
 from ...data.callback.callback_url import CallbackUrl
 from ...data.promise.post_processing_promise import PostProcessingPromise
@@ -14,13 +15,14 @@ from ...data.response.authentication import Authentication
 from ...data.response.job_response import JobResponse
 from ...data.response.project_header import ProjectHeader
 from ...enum.invocation_step import InvocationStep
-from ...config.logging_config import logger
 from ...enum.media_type import MediaType
 from ...enum.status.job_status import JobStatus
 from ...enum.status.status_code import StatusCode
 from ...util.json_parser_utils import JsonParserUtils
 from ...util.response_utils import ResponseUtils
 
+logger = logger.bind(context='JobFetching')
+
 
 class JobFetching(ABC):
     def __init__(self, request_data: JobFetchingRequest):
@@ -40,7 +42,7 @@ class JobFetching(ABC):
         @param post_processing_fn:
         @return:
         """
-        logger.debug("[Fetching] Fetch job")
+        logger.debug("Fetch job")
 
         job_response = JobResponse(
             provider_job_id=self.provider_job_id,
@@ -130,7 +132,7 @@ class JobFetching(ABC):
         @param original_job_result:
         @return:
         """
-        logger.debug("[Fetching] On analysis")
+        logger.debug("On analysis")
 
         update_job_metadata(job_response=job_response,
                             callback_url=callback_url.on_start)
@@ -141,7 +143,7 @@ class JobFetching(ABC):
             job_response.job_histogram = self.__produce_histogram_data(original_job_result)
 
             job_result_parse = JsonParserUtils.parse(original_job_result.result())
-            
+
             job_response.execution_time = self.__get_execution_time(original_job_result)
 
             update_job_metadata(
@@ -178,7 +180,7 @@ class JobFetching(ABC):
         @param callback_url:
         @param original_job_result:
         """
-        logger.debug("[Fetching] On finalization")
+        logger.debug("On finalization")
 
         promise = PostProcessingPromise(callback_url=callback_url,
                                         authentication=self.backend_authentication,
@@ -195,7 +197,7 @@ class JobFetching(ABC):
         @param job_result:
         @return:
         """
-        logger.debug("[Fetching] Produce histogram")
+        logger.debug("Produce histogram")
 
         try:
             histogram_data = job_result.result()[0].data.meas.get_counts()
@@ -214,6 +216,7 @@ class JobFetching(ABC):
         @return:
         """
         return job_result.usage()
+
     @abstractmethod
     def _collect_provider(self, ):
         """

{quapp_common-0.0.11.dev1/qapp_common → quapp_common-0.0.11.dev2/quapp_common}/component/callback/update_job_metadata.py

@@ -9,6 +9,7 @@ from ...util.http_utils import HttpUtils
 from ...util.response_utils import ResponseUtils
 from ...config.logging_config import logger
 
+logger = logger.bind(context='UpdateJobMetadata')
 
 def update_job_metadata(
         job_response: JobResponse,

{quapp_common-0.0.11.dev1/qapp_common → quapp_common-0.0.11.dev2/quapp_common}/component/device/device_selection.py

@@ -1,6 +1,6 @@
-"""
-    QApp Platform Project device_selection.py Copyright © CITYNOW Co. Ltd. All rights reserved.
-"""
+#  Quapp Platform Project
+#  device_selection.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
 
 from json import JSONDecodeError
 
@@ -11,6 +11,8 @@ from ...data.backend.backend_information import BackendInformation
 from ...enum.provider_tag import ProviderTag
 from ...util.http_utils import HttpUtils
 
+logger = logger.bind(context='DeviceSelection')
+
 
 class DeviceSelection:
     def __init__(self,
@@ -66,7 +68,7 @@ class DeviceSelection:
             logger.error('Select device fail with status code: {0} and content: {1}'.format(
                 response.status_code, response.content))
 
-            return None
+            raise ValueError(f"Select device failed: {response.content}")
 
         try:
             response_dict = response.json().get("data")

quapp_common-0.0.11.dev2/quapp_common/config/logging_config.py

@@ -0,0 +1,34 @@
+"""
+    QApp Platform Project logging_config.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+import sys
+
+from loguru import logger
+
+# Define colors for each log level
+level_colors = {
+    "DEBUG": "blue",
+    "INFO": "white",
+    "WARNING": "yellow",
+    "ERROR": "red",
+    "CRITICAL": "bold red"
+}
+
+
+def __custom_format(record):
+    # Safely get context, default to "QuappLibs" if missing
+    context = record["extra"].get("context", "QuappLibs")
+
+    # Get the color for the current level, default to white if level is unknown
+    level_color = level_colors.get(record["level"].name, "white")
+    return (
+        f"<{level_color}>{{level}}</{level_color}> : <green>{{time: %Y-%m-%d %H:%M:%S}}</green> : <yellow>[{context}]</yellow> <{level_color}>{{message}}</{level_color}> : <magenta>{{process}}</magenta>\n"
+    )
+
+
+logger.add(
+    sink=sys.stderr,
+    format=__custom_format,  # Use custom format function
+    level="DEBUG",
+    colorize=True  # Enable colors (supported by sys.stderr)
+)