arcane-flask 2.0.6__tar.gz → 2.2.0__tar.gz

arcane_flask-2.2.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: arcane-flask
+Version: 2.2.0
+Summary: Utility functions for flask apps.
+Author: Arcane
+Author-email: product@wearcane.com
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: arcane-core (>=1.6.0,<2.0.0)
+Requires-Dist: arcane-datastore (>=1.1.0,<2.0.0)
+Requires-Dist: arcane-pubsub (>=1.1.0,<2.0.0)
+Requires-Dist: backoff (>=1.10.0)
+Requires-Dist: firebase_admin (==5.2.0)
+Requires-Dist: flask (>=2.2.0,<3.0.0)
+Requires-Dist: flask_log_request_id (>=0.10.1,<0.11.0)
+Requires-Dist: pydash (>=8.0.3,<9.0.0)
+Requires-Dist: pytz (>=2024.2,<2025.0)
+Description-Content-Type: text/markdown
+
+# Arcane flask
+
+This package help us authenticate users
+
+## Get Started
+
+```sh
+pip install arcane-flask
+```
+
+## Example Usage
+
+```python
+from arcane.flask import check_access_rights
+from arcane.core import RightsLevelEnum, UserRightsEnum
+from arcane.datastore import Client as DatastoreClient
+from arcane.pubsub import Client as PubSubClient
+
+datastore_client = DatastoreClient()
+pubsub_client = PubSubClient()
+
+@check_access_rights(
+    service='my-service',
+    required_rights=RightsLevelEnum.VIEWER,
+    service_user_right=UserRightsEnum.MY_SERVICE,
+    datastore_client=datastore_client,
+    pubsub_client=pubsub_client,
+    receive_rights_per_client=True,
+    project='my-project',
+    timeout=30  # Timeout in seconds
+)
+def function(params):
+    pass
+```
+
+## Timeout Configuration
+
+The `check_access_rights` decorator includes a built-in `timeout` parameter that allows you to set a maximum execution time for the decorated function. If the function exceeds this timeout, the decorator will automatically return a timeout response.
+
+```python
+import time
+
+@check_access_rights(
+    service='my-service',
+    required_rights=RightsLevelEnum.VIEWER,
+    service_user_right=UserRightsEnum.MY_SERVICE,
+    datastore_client=datastore_client,
+    pubsub_client=pubsub_client,
+    project='my-project',
+    timeout=2  # 2 seconds timeout
+)
+def slow_function():
+    time.sleep(5)  # This will exceed the timeout
+    return {'result': 'success'}
+```
+
+If the function exceeds the timeout, the decorator will return:
+
+```python
+({'detail': 'Request Timeout'}, 504)
+```
+
+**Note:** Set the `timeout` parameter to a value a few seconds less than your Cloud Run or server timeout configuration to ensure proper error handling.
+
+## Structured logging labels
+
+The `arcane.flask.logs` module lets you add structured labels to every log
+entry in a request. This is useful for attaching metadata such as
+`component`, `module`, `function`, or IDs like `optimization_id`.
+
+First, set up logging once at application startup:
+
+```python
+from arcane.flask import logs
+
+logs.setup_logging(gcp_project="my-gcp-project-id")
+```
+
+Then, register a teardown handler to clear labels at the end of each request:
+
+```python
+from arcane.flask import logs
+
+@app.teardown_request
+def clear_logging_labels(exc):
+    logs.clear_labels()
+```
+
+Inside your handlers you can either attach labels imperatively:
+
+```python
+from arcane.flask import logs
+
+def validate_model_parallelism_post(optimization_id: str, job_prefix: str, ...):
+    logs.attach_labels(
+        component="feed-boost",
+        module="api",
+        function="validate_model_parallelism_post",
+        optimization_id=optimization_id,
+        job_prefix=job_prefix,
+    )
+    ...
+```
+
+or use the `with_log_labels` decorator for static labels and still add dynamic
+labels as needed:
+
+```python
+from arcane.flask import logs
+
+@logs.with_log_labels(
+    component="feed-boost",
+    module="api",
+    function="validate_model_parallelism_post",
+)
+def validate_model_parallelism_post(optimization_id: str, job_prefix: str, ...):
+    logs.attach_labels(
+        optimization_id=optimization_id,
+        job_prefix=job_prefix,
+    )
+    ...
+```
+
+All log records emitted during the request will then include a
+`logging.googleapis.com/labels` field with the JSON-encoded labels.
+

arcane_flask-2.2.0/README.md

@@ -0,0 +1,125 @@
+# Arcane flask
+
+This package help us authenticate users
+
+## Get Started
+
+```sh
+pip install arcane-flask
+```
+
+## Example Usage
+
+```python
+from arcane.flask import check_access_rights
+from arcane.core import RightsLevelEnum, UserRightsEnum
+from arcane.datastore import Client as DatastoreClient
+from arcane.pubsub import Client as PubSubClient
+
+datastore_client = DatastoreClient()
+pubsub_client = PubSubClient()
+
+@check_access_rights(
+    service='my-service',
+    required_rights=RightsLevelEnum.VIEWER,
+    service_user_right=UserRightsEnum.MY_SERVICE,
+    datastore_client=datastore_client,
+    pubsub_client=pubsub_client,
+    receive_rights_per_client=True,
+    project='my-project',
+    timeout=30  # Timeout in seconds
+)
+def function(params):
+    pass
+```
+
+## Timeout Configuration
+
+The `check_access_rights` decorator includes a built-in `timeout` parameter that allows you to set a maximum execution time for the decorated function. If the function exceeds this timeout, the decorator will automatically return a timeout response.
+
+```python
+import time
+
+@check_access_rights(
+    service='my-service',
+    required_rights=RightsLevelEnum.VIEWER,
+    service_user_right=UserRightsEnum.MY_SERVICE,
+    datastore_client=datastore_client,
+    pubsub_client=pubsub_client,
+    project='my-project',
+    timeout=2  # 2 seconds timeout
+)
+def slow_function():
+    time.sleep(5)  # This will exceed the timeout
+    return {'result': 'success'}
+```
+
+If the function exceeds the timeout, the decorator will return:
+
+```python
+({'detail': 'Request Timeout'}, 504)
+```
+
+**Note:** Set the `timeout` parameter to a value a few seconds less than your Cloud Run or server timeout configuration to ensure proper error handling.
+
+## Structured logging labels
+
+The `arcane.flask.logs` module lets you add structured labels to every log
+entry in a request. This is useful for attaching metadata such as
+`component`, `module`, `function`, or IDs like `optimization_id`.
+
+First, set up logging once at application startup:
+
+```python
+from arcane.flask import logs
+
+logs.setup_logging(gcp_project="my-gcp-project-id")
+```
+
+Then, register a teardown handler to clear labels at the end of each request:
+
+```python
+from arcane.flask import logs
+
+@app.teardown_request
+def clear_logging_labels(exc):
+    logs.clear_labels()
+```
+
+Inside your handlers you can either attach labels imperatively:
+
+```python
+from arcane.flask import logs
+
+def validate_model_parallelism_post(optimization_id: str, job_prefix: str, ...):
+    logs.attach_labels(
+        component="feed-boost",
+        module="api",
+        function="validate_model_parallelism_post",
+        optimization_id=optimization_id,
+        job_prefix=job_prefix,
+    )
+    ...
+```
+
+or use the `with_log_labels` decorator for static labels and still add dynamic
+labels as needed:
+
+```python
+from arcane.flask import logs
+
+@logs.with_log_labels(
+    component="feed-boost",
+    module="api",
+    function="validate_model_parallelism_post",
+)
+def validate_model_parallelism_post(optimization_id: str, job_prefix: str, ...):
+    logs.attach_labels(
+        optimization_id=optimization_id,
+        job_prefix=job_prefix,
+    )
+    ...
+```
+
+All log records emitted during the request will then include a
+`logging.googleapis.com/labels` field with the JSON-encoded labels.

{arcane_flask-2.0.6 → arcane_flask-2.2.0}/arcane/flask/__init__.py

@@ -5,3 +5,4 @@ from .exception_decorator import *
 from .log import *
 from .http_response import *
 from .types import *
+__version__ = "2.1.0"

{arcane_flask-2.0.6 → arcane_flask-2.2.0}/arcane/flask/authentication.py

@@ -14,7 +14,7 @@ from google.cloud.exceptions import ServiceUnavailable
 from arcane.core import CLIENTS_PARAM, ALL_CLIENTS_RIGHTS, RightsLevelEnum, GOOGLE_EXCEPTIONS_TO_RETRY, BadRequestError
 from arcane.datastore import Client as DatastoreClient
 from arcane.pubsub import Client as PubSubClient
-
+import concurrent.futures
 
 from .tracking import send_tracking_information
 
@@ -39,7 +39,8 @@ def check_access_rights(service: str,
                         kwargs_name_and_path_to_get: Dict[str, str] = {},
                         receive_rights_per_client: bool=False,
                         auth_enabled: bool=True,
-                        project: str = None
+                        project: str = None,
+                        timeout: Optional[int] = None,
                         ) -> Callable[[Callable], Callable]:
     """
     This functions checks the authorizations from the current HTTP call.
@@ -135,7 +136,15 @@ def check_access_rights(service: str,
                     authorized_clients = [client_entity.key.name for client_entity in clients_query.fetch()]
 
                 kwargs[CLIENTS_PARAM] = sorted(set(authorized_clients))
-            func_response = job_func(*args, **kwargs)
+            try:
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(job_func, *args, **kwargs)
+                    func_response = future.result(timeout=timeout)
+            except concurrent.futures.TimeoutError:
+                func_response = {'detail': 'Request Timeout'}, 504
+            except Exception as e:
+                func_response = {'detail': f'Server Error: {str(e)}'}, 500
+
             end = time.time()
 
             additionnal_info = {}

{arcane_flask-2.0.6 → arcane_flask-2.2.0}/arcane/flask/exception_decorator.py

@@ -1,4 +1,5 @@
 import functools
+import logging
 from typing import Callable
 import logging
 from flask import request
@@ -16,7 +17,7 @@ def catch_exceptions_service(service: str, auth_enabled=True) -> Callable:
             try:
                 return job_func(*args, **kwargs)
             except Exception as e:
-                message = f"Error while executing method {job_func.__name__} in service {service} "
+                message = f"Error while executing method {job_func.__name__!r} in service {service!r} "
                 try:
                     message += f' for user {get_user_email(auth_enabled=auth_enabled)} '
                 except ValueError:
@@ -31,7 +32,7 @@ def catch_exceptions_service(service: str, auth_enabled=True) -> Callable:
 
                 message += f"Args : {str(args)} / kwargs : {str(kwargs)} / headers : {request.environ.get('HTTP_ORIGIN')}"
 
-                logging.info(message)
+                logging.error(message, exc_info=True)
                 raise e
         return wrapper
     return catch_exceptions

arcane_flask-2.2.0/arcane/flask/log.py

@@ -0,0 +1,205 @@
+import json
+import logging
+import sys
+from functools import wraps
+from typing import Any, Callable, Literal, Optional
+
+from flask import g, has_request_context, request
+from flask_log_request_id import current_request_id
+
+STANDARD_FORMAT = '{"severity": "%(levelname)s", "logging.googleapis.com/trace": "%(cloud_trace)s", "logging.googleapis.com/spanId": "%(span_id)s", "component": "arbitrary", "message": "%(message)s", "logging.googleapis.com/labels": %(labels)s}'
+
+
+class LabelFilter(logging.Filter):
+    """
+    Logging filter that injects structured labels into each log record.
+
+    Labels are stored per-request on ``flask.g.logging_labels`` (a simple
+    dictionary) and JSON-encoded into the ``labels`` attribute of the
+    record. When there is no active request context, ``labels`` defaults
+    to the empty JSON object (``{}``).
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        if not hasattr(record, "labels"):
+            record.labels = "{}"
+        if has_request_context():
+            labels = getattr(g, "logging_labels", {})
+            record.labels = json.dumps(labels)
+        return True
+
+
+def attach_labels(**labels: Any) -> None:
+    """
+    Attach or update structured logging labels for the current request.
+
+    This stores key/value pairs on ``flask.g.logging_labels`` which are
+    then picked up by ``LabelFilter`` and emitted in every log record
+    for the remainder of the request.
+
+    Example
+    -------
+    >>> attach_labels(component="feed-boost", module="api")
+
+    Notes
+    -----
+    This function must be called inside an active Flask request (or
+    application) context; otherwise Flask will raise a
+    ``RuntimeError`` about working outside of the application context.
+    """
+    if not hasattr(g, "logging_labels"):
+        g.logging_labels = {}
+    g.logging_labels.update(labels)
+
+
+def clear_labels() -> None:
+    """
+    Clear all structured logging labels for the current request.
+
+    In a typical Flask application you should call this from a
+    ``teardown_request`` handler to ensure labels do not leak between
+    re-used contexts in tests or background processing:
+
+        @app.teardown_request
+        def _clear_labels(exc):
+            logs.clear_labels()
+    """
+    if hasattr(g, "logging_labels"):
+        g.logging_labels = {}
+
+
+def with_log_labels(**static_labels: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """
+    Decorator that automatically attaches static logging labels
+    at the beginning of a request handler.
+
+    This is a convenience wrapper around :func:`attach_labels` for
+    common, mostly-static metadata such as ``component``, ``module``
+    or ``function``.
+
+    Example
+    -------
+    >>> @with_log_labels(component="feed-boost", module="api", function="validate_model_parallelism_post")
+    ... def validate_model_parallelism_post(...):
+    ...     attach_labels(optimization_id=optimization_id, job_prefix=job_prefix)
+    ...     ...
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            # This will be a no-op outside a request context, but will
+            # raise the standard Flask RuntimeError if misused.
+            attach_labels(**static_labels)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def adscale_log(
+    service: str,  # should be ValueOf ServiceEnum
+    msg: str
+    ):
+    """Deprecated, should not be used anymore
+    """
+    request_id = None
+    try:
+        request_id = current_request_id()
+    except KeyError:
+        pass
+
+    logging.info("[%s][%s] %s", service, request_id, msg)
+
+
+class RequestFormatter(logging.Formatter):
+    """Logging Formatter to add request id and trace id to log records
+    """
+    def __init__(self,
+            fmt: Optional[str] = STANDARD_FORMAT,
+            datefmt: Optional[str] = None,
+            style: Literal["%", "{", "$"] = "%",
+            validate: bool = True,
+            gcp_project: Optional[str] = None,
+            span_id_header: str = "X-Span-Id"):
+
+        super().__init__(fmt, datefmt, style, validate)
+        self.gcp_project = gcp_project
+        self.span_id_header = span_id_header
+
+    def format(self, record):
+        if has_request_context():
+            trace_header: str = request.headers.get("X-Cloud-Trace-Context")
+            span_id : str = request.headers.get(self.span_id_header)
+            if trace_header:
+                trace = trace_header.split("/")
+                record.cloud_trace = f"projects/{self.gcp_project}/traces/{trace[0]}"
+            else:
+                record.cloud_trace = None
+
+            if span_id:
+                record.span_id = f"projects/{self.gcp_project}/spanId/{span_id}"
+            else:
+                record.span_id = None
+        else:
+            record.cloud_trace = None
+            record.span_id = None
+
+
+        # Handle exception information properly
+        if record.exc_info:
+            # Format the exception with stack trace as a single string
+            exc_text = self.formatException(record.exc_info)
+            # Combine the message with the exception info
+            full_message = f"{record.getMessage()}\n{exc_text}"
+        else:
+            full_message = record.getMessage()
+
+        # JSON encode the complete message to escape newlines and special characters
+        record.msg = json.dumps(full_message)
+        # Clear args to prevent double formatting
+        record.args = None
+
+        return super().format(record)
+
+def setup_logging(
+    fmt : Optional[str] = STANDARD_FORMAT,
+    datefmt: Optional[str] = None,
+    style   :  Literal["%", "{", "$"] = "%",
+    validate: bool = True,
+    gcp_project: Optional[str] = None,
+    level = logging.INFO,
+    span_id_header: str = "X-Span-Id",
+    filter: Optional[logging.Filter] = None
+):
+    """
+    Setup logging for the application
+    """
+    handler = logging.StreamHandler(
+        sys.stdout
+    )
+
+    handler.setFormatter(
+        RequestFormatter(
+            fmt,
+            datefmt,
+            style,
+            validate,
+            gcp_project,
+            span_id_header
+        )
+    )
+
+    logging.basicConfig(
+        level=level,
+        handlers=[handler]
+    )
+
+    root = logging.getLogger()
+
+    if not filter:
+        filter = LabelFilter()
+
+    root.addFilter(filter)
+    return root

arcane_flask-2.2.0/pyproject.toml

@@ -0,0 +1,57 @@
+[tool.poetry]
+name = "arcane-flask"
+
+version = "2.2.0"
+
+
+description = "Utility functions for flask apps."
+readme = "README.md"
+authors = ["Arcane <product@wearcane.com>"]
+packages = [
+    { include = "arcane" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+arcane-core = "^1.6.0"
+flask = "^2.2.0"
+flask_log_request_id = "^0.10.1"
+firebase_admin = "5.2.0"
+arcane-datastore = "^1.1.0"
+arcane-pubsub = "^1.1.0"
+pydash = "^8.0.3"
+backoff = ">=1.10.0"
+pytz = "^2024.2"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.4"
+pytest-mock = "^3.14.0"
+pytest-cov = "^4.1.0"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.report]
+# Regexes for lines to exclude from consideration
+exclude_also = [
+    # Don't complain about missing debug-only code:
+    "def __repr__",
+    "if self\\.debug",
+
+    # Don't complain if tests don't hit defensive assertion code:
+    "raise AssertionError",
+    "raise NotImplementedError",
+
+    # Don't complain if non-runnable code isn't run:
+    "if 0:",
+    "if __name__ == .__main__.:",
+
+    # Don't complain about abstract methods, they aren't run:
+    "@(abc\\.)?abstractmethod",
+    ]
+ignore_errors = true

arcane_flask-2.0.6/PKG-INFO

@@ -1,49 +0,0 @@
-Metadata-Version: 2.4
-Name: arcane-flask
-Version: 2.0.6
-Summary: Utility functions for flask apps.
-Author: Arcane
-Author-email: product@wearcane.com
-Requires-Python: >=3.8,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: arcane-core (>=1.6.0,<2.0.0)
-Requires-Dist: arcane-datastore (>=1.1.0,<2.0.0)
-Requires-Dist: arcane-pubsub (>=1.1.0,<2.0.0)
-Requires-Dist: backoff (>=1.10.0)
-Requires-Dist: firebase_admin (==5.2.0)
-Requires-Dist: flask (>=2.2.0,<3.0.0)
-Requires-Dist: flask_log_request_id (>=0.10.1,<0.11.0)
-Requires-Dist: pydash (>=8.0.3,<9.0.0)
-Requires-Dist: pytz (>=2024.2,<2025.0)
-Description-Content-Type: text/markdown
-
-# Arcane flask
-
-This package help us authenticate users
-
-## Get Started
-
-```sh
-pip install arcane-flask
-```
-
-## Example Usage
-
-```python
-from arcane import flask
-
-@check_access_rights(service='function', required_rights='Viewer',
-                     receive_rights_per_client=True, project=Config.Project, adscale_key=Config.Key)
-def function(params):
-    pass
-
-```
-
-

arcane_flask-2.0.6/README.md

@@ -1,22 +0,0 @@
-# Arcane flask
-
-This package help us authenticate users
-
-## Get Started
-
-```sh
-pip install arcane-flask
-```
-
-## Example Usage
-
-```python
-from arcane import flask
-
-@check_access_rights(service='function', required_rights='Viewer',
-                     receive_rights_per_client=True, project=Config.Project, adscale_key=Config.Key)
-def function(params):
-    pass
-
-```
-

arcane_flask-2.0.6/arcane/flask/log.py

@@ -1,96 +0,0 @@
-import json
-import logging
-from typing import Optional, Literal
-import sys
-
-from flask import has_request_context, request
-from flask_log_request_id import current_request_id
-
-STANDARD_FORMAT = '{"severity": "%(levelname)s", "logging.googleapis.com/trace": "%(cloud_trace)s", "component": "arbitrary", "message": %(message)s}'
-def adscale_log(
-    service: str,  # should be ValueOf ServiceEnum
-    msg: str
-    ):
-    """Deprecated, should not be used anymore
-    """
-    request_id = None
-    try:
-        request_id = current_request_id()
-    except KeyError:
-        pass
-
-    logging.info(f"[{service}][{request_id}] {msg}")
-
-
-class RequestFormatter(logging.Formatter):
-    """Logging Formatter to add request id and trace id to log records
-    """
-    def __init__(self,
-            fmt: Optional[str] = STANDARD_FORMAT,
-            datefmt: Optional[str] = None,
-            style: Literal["%", "{", "$"] = "%",
-            validate: bool = True,
-            gcp_project: Optional[str] = None):
-
-        super().__init__(fmt, datefmt, style, validate)
-        self.gcp_project = gcp_project
-
-    def format(self, record):
-        if has_request_context():
-            trace_header: str = request.headers.get("X-Cloud-Trace-Context")
-            if trace_header:
-                trace = trace_header.split("/")
-                record.cloud_trace = f"projects/{self.gcp_project}/traces/{trace[0]}"
-            else:
-                record.cloud_trace = None
-        else:
-            record.cloud_trace = None
-
-        # Handle exception information properly
-        if record.exc_info:
-            # Format the exception with stack trace as a single string
-            exc_text = self.formatException(record.exc_info)
-            # Combine the message with the exception info
-            full_message = f"{record.getMessage()}\n{exc_text}"
-        else:
-            full_message = record.getMessage()
-
-        # JSON encode the complete message to escape newlines and special characters
-        record.msg = json.dumps(full_message)
-        # Clear args to prevent double formatting
-        record.args = None
-
-        return super().format(record)
-
-def setup_logging(
-    fmt : Optional[str] = STANDARD_FORMAT,
-    datefmt: Optional[str] = None,
-    style   :  Literal["%", "{", "$"] = "%",
-    validate: bool = True,
-    gcp_project: Optional[str] = None,
-    level = logging.INFO
-):
-    """
-    Setup logging for the application
-    """
-    handler = logging.StreamHandler(
-        sys.stdout
-    )
-
-    handler.setFormatter(
-        RequestFormatter(
-            fmt,
-            datefmt,
-            style,
-            validate,
-            gcp_project
-        )
-    )
-
-    logging.basicConfig(
-        level=level,
-        handlers=[handler]
-    )
-
-    root = logging.getLogger()
-    return root

arcane_flask-2.0.6/pyproject.toml

@@ -1,30 +0,0 @@
-[tool.poetry]
-name = "arcane-flask"
-
-version = "2.0.6"
-
-
-description = "Utility functions for flask apps."
-readme = "README.md"
-authors = ["Arcane <product@wearcane.com>"]
-packages = [
-    { include = "arcane" }
-]
-
-[tool.poetry.dependencies]
-python = "^3.8"
-arcane-core = "^1.6.0"
-flask = "^2.2.0"
-flask_log_request_id = "^0.10.1"
-firebase_admin = "5.2.0"
-arcane-datastore = "^1.1.0"
-arcane-pubsub = "^1.1.0"
-pydash = "^8.0.3"
-backoff = ">=1.10.0"
-pytz = "^2024.2"
-
-[tool.poetry.group.dev.dependencies]
-
-[build-system]
-requires = ["poetry>=0.12"]
-build-backend = "poetry.masonry.api"