braintrust 0.3.14__py3-none-any.whl → 0.4.0__py3-none-any.whl

braintrust/merge_row_batch.py

@@ -1,10 +1,11 @@
-from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple
+from collections.abc import Mapping, Sequence
+from typing import Any, Optional
 
 from .db_fields import IS_MERGE_FIELD, PARENT_ID_FIELD
 from .graph_util import UndirectedGraph, topological_sort, undirected_connected_components
 from .util import merge_dicts
 
-_MergedRowKey = Tuple[Optional[Any], ...]
+_MergedRowKey = tuple[Optional[Any], ...]
 
 
 def _generate_merged_row_key(row: Mapping[str, Any], use_parent_id_for_id: bool = False) -> _MergedRowKey:
@@ -33,7 +34,7 @@ MERGE_ROW_SKIP_FIELDS = [
 ]
 
 
-def _pop_merge_row_skip_fields(row: Dict[str, Any]) -> Dict[str, Any]:
+def _pop_merge_row_skip_fields(row: dict[str, Any]) -> dict[str, Any]:
     popped = {}
     for field in MERGE_ROW_SKIP_FIELDS:
         if field in row:
@@ -41,14 +42,14 @@ def _pop_merge_row_skip_fields(row: Dict[str, Any]) -> Dict[str, Any]:
     return popped
 
 
-def _restore_merge_row_skip_fields(row: Dict[str, Any], skip_fields: Dict[str, Any]):
+def _restore_merge_row_skip_fields(row: dict[str, Any], skip_fields: dict[str, Any]):
     for field in MERGE_ROW_SKIP_FIELDS:
         row.pop(field, None)
         if field in skip_fields:
             row[field] = skip_fields[field]
 
 
-def merge_row_batch(rows: Sequence[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
+def merge_row_batch(rows: Sequence[dict[str, Any]]) -> list[list[dict[str, Any]]]:
     """Given a batch of rows, merges conflicting rows together to end up with a
     set of rows to insert. Returns a set of de-conflicted rows, as a list of
     lists, where separate lists contain "independent" rows which can be
@@ -98,7 +99,7 @@ def merge_row_batch(rows: Sequence[Dict[str, Any]]) -> List[List[Dict[str, Any]]
                 "Logged row is missing an id. This is an internal braintrust error. Please contact us at info@braintrust.dev for help"
             )
 
-    row_groups: Dict[_MergedRowKey, Dict[str, Any]] = {}
+    row_groups: dict[_MergedRowKey, dict[str, Any]] = {}
     for row in rows:
         key = _generate_merged_row_key(row)
         existing_row = row_groups.get(key)
@@ -138,7 +139,7 @@ def merge_row_batch(rows: Sequence[Dict[str, Any]]) -> List[List[Dict[str, Any]]
     # all groups of rows which each row in a group has a PARENT_ID_FIELD
     # relationship with at least one other row in the group.
     connected_components = undirected_connected_components(
-        UndirectedGraph(vertices=set(graph.keys()), edges=set((k, v) for k, vs in graph.items() for v in vs))
+        UndirectedGraph(vertices=set(graph.keys()), edges={(k, v) for k, vs in graph.items() for v in vs})
     )
 
     # For each connected row group, run topological sort over that subgraph to
@@ -148,8 +149,8 @@ def merge_row_batch(rows: Sequence[Dict[str, Any]]) -> List[List[Dict[str, Any]]
 
 
 def batch_items(
-    items: List[List[str]], batch_max_num_items: Optional[int] = None, batch_max_num_bytes: Optional[int] = None
-) -> List[List[List[str]]]:
+    items: list[list[str]], batch_max_num_items: int | None = None, batch_max_num_bytes: int | None = None
+) -> list[list[list[str]]]:
     """Repartition the given list of items into sets of batches which can be
     published in parallel or in sequence.
 

braintrust/oai.py

@@ -1,8 +1,11 @@
 import abc
+import base64
+import re
 import time
-from typing import Any, Callable, Dict, List, Optional
+from collections.abc import Callable
+from typing import Any
 
-from .logger import Span, start_span
+from .logger import Attachment, Span, start_span
 from .span_types import SpanTypeAttribute
 from .util import merge_dicts
 
@@ -68,8 +71,77 @@ def log_headers(response: Any, span: Span):
         )
 
 
+def _convert_data_url_to_attachment(data_url: str, filename: str | None = None) -> Attachment | str:
+    """Helper function to convert data URL to an Attachment."""
+    data_url_match = re.match(r"^data:([^;]+);base64,(.+)$", data_url)
+    if not data_url_match:
+        return data_url
+
+    mime_type, base64_data = data_url_match.groups()
+
+    try:
+        binary_data = base64.b64decode(base64_data)
+
+        if filename is None:
+            extension = mime_type.split("/")[1] if "/" in mime_type else "bin"
+            prefix = "image" if mime_type.startswith("image/") else "document"
+            filename = f"{prefix}.{extension}"
+
+        attachment = Attachment(data=binary_data, filename=filename, content_type=mime_type)
+
+        return attachment
+    except Exception:
+        return data_url
+
+
+def _process_attachments_in_input(input_data: Any) -> Any:
+    """Process input to convert data URL images and base64 documents to Attachment objects."""
+    if isinstance(input_data, list):
+        return [_process_attachments_in_input(item) for item in input_data]
+
+    if isinstance(input_data, dict):
+        # Check for OpenAI's image_url format with data URLs
+        if (
+            input_data.get("type") == "image_url"
+            and isinstance(input_data.get("image_url"), dict)
+            and isinstance(input_data["image_url"].get("url"), str)
+        ):
+            processed_url = _convert_data_url_to_attachment(input_data["image_url"]["url"])
+            return {
+                **input_data,
+                "image_url": {
+                    **input_data["image_url"],
+                    "url": processed_url,
+                },
+            }
+
+        # Check for OpenAI's file format with data URL (e.g., PDFs)
+        if (
+            input_data.get("type") == "file"
+            and isinstance(input_data.get("file"), dict)
+            and isinstance(input_data["file"].get("file_data"), str)
+        ):
+            file_filename = input_data["file"].get("filename")
+            processed_file_data = _convert_data_url_to_attachment(
+                input_data["file"]["file_data"],
+                filename=file_filename if isinstance(file_filename, str) else None,
+            )
+            return {
+                **input_data,
+                "file": {
+                    **input_data["file"],
+                    "file_data": processed_file_data,
+                },
+            }
+
+        # Recursively process nested objects
+        return {key: _process_attachments_in_input(value) for key, value in input_data.items()}
+
+    return input_data
+
+
 class ChatCompletionWrapper:
-    def __init__(self, create_fn: Optional[Callable[..., Any]], acreate_fn: Optional[Callable[..., Any]]):
+    def __init__(self, create_fn: Callable[..., Any] | None, acreate_fn: Callable[..., Any] | None):
         self.create_fn = create_fn
         self.acreate_fn = acreate_fn
 
@@ -183,28 +255,32 @@ class ChatCompletionWrapper:
                 span.end()
 
     @classmethod
-    def _parse_params(cls, params: Dict[str, Any]) -> Dict[str, Any]:
+    def _parse_params(cls, params: dict[str, Any]) -> dict[str, Any]:
         # First, destructively remove span_info
         ret = params.pop("span_info", {})
 
         # Then, copy the rest of the params
         params = prettify_params(params)
         messages = params.pop("messages", None)
+
+        # Process attachments in input (convert data URLs to Attachment objects)
+        processed_input = _process_attachments_in_input(messages)
+
         return merge_dicts(
             ret,
             {
-                "input": messages,
+                "input": processed_input,
                 "metadata": {**params, "provider": "openai"},
             },
         )
 
     @classmethod
-    def _postprocess_streaming_results(cls, all_results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    def _postprocess_streaming_results(cls, all_results: list[dict[str, Any]]) -> dict[str, Any]:
         role = None
         content = None
-        tool_calls: Optional[List[Any]] = None
+        tool_calls: list[Any] | None = None
         finish_reason = None
-        metrics: Dict[str, float] = {}
+        metrics: dict[str, float] = {}
         for result in all_results:
             usage = result.get("usage")
             if usage:
@@ -263,7 +339,7 @@ class ChatCompletionWrapper:
 
 
 class ResponseWrapper:
-    def __init__(self, create_fn: Optional[Callable[..., Any]], acreate_fn: Optional[Callable[..., Any]], name: str = "openai.responses.create"):
+    def __init__(self, create_fn: Callable[..., Any] | None, acreate_fn: Callable[..., Any] | None, name: str = "openai.responses.create"):
         self.create_fn = create_fn
         self.acreate_fn = acreate_fn
         self.name = name
@@ -372,23 +448,27 @@ class ResponseWrapper:
                 span.end()
 
     @classmethod
-    def _parse_params(cls, params: Dict[str, Any]) -> Dict[str, Any]:
+    def _parse_params(cls, params: dict[str, Any]) -> dict[str, Any]:
         # First, destructively remove span_info
         ret = params.pop("span_info", {})
 
         # Then, copy the rest of the params
         params = prettify_params(params)
         input_data = params.pop("input", None)
+
+        # Process attachments in input (convert data URLs to Attachment objects)
+        processed_input = _process_attachments_in_input(input_data)
+
         return merge_dicts(
             ret,
             {
-                "input": input_data,
+                "input": processed_input,
                 "metadata": {**params, "provider": "openai"},
             },
         )
 
     @classmethod
-    def _parse_event_from_result(cls, result: Dict[str, Any]) -> Dict[str, Any]:
+    def _parse_event_from_result(cls, result: dict[str, Any]) -> dict[str, Any]:
         """Parse event from response result"""
         data = {"metrics": {}}
 
@@ -408,7 +488,7 @@ class ResponseWrapper:
         return data
 
     @classmethod
-    def _postprocess_streaming_results(cls, all_results: List[Any]) -> Dict[str, Any]:
+    def _postprocess_streaming_results(cls, all_results: list[Any]) -> dict[str, Any]:
         """Process streaming results - minimal version focused on metrics extraction."""
         metrics = {}
         output = []
@@ -491,13 +571,13 @@ class ResponseWrapper:
 
 
 class BaseWrapper(abc.ABC):
-    def __init__(self, create_fn: Optional[Callable[..., Any]], acreate_fn: Optional[Callable[..., Any]], name: str):
+    def __init__(self, create_fn: Callable[..., Any] | None, acreate_fn: Callable[..., Any] | None, name: str):
         self._create_fn = create_fn
         self._acreate_fn = acreate_fn
         self._name = name
 
     @abc.abstractmethod
-    def process_output(self, response: Dict[str, Any], span: Span):
+    def process_output(self, response: dict[str, Any], span: Span):
         """Process the API response and log relevant information to the span."""
         pass
 
@@ -535,27 +615,30 @@ class BaseWrapper(abc.ABC):
             return raw_response
 
     @classmethod
-    def _parse_params(cls, params: Dict[str, Any]) -> Dict[str, Any]:
+    def _parse_params(cls, params: dict[str, Any]) -> dict[str, Any]:
         # First, destructively remove span_info
         ret = params.pop("span_info", {})
 
         params = prettify_params(params)
-        input = params.pop("input", None)
+        input_data = params.pop("input", None)
+
+        # Process attachments in input (convert data URLs to Attachment objects)
+        processed_input = _process_attachments_in_input(input_data)
 
         return merge_dicts(
             ret,
             {
-                "input": input,
+                "input": processed_input,
                 "metadata": {**params, "provider": "openai"},
             },
         )
 
 
 class EmbeddingWrapper(BaseWrapper):
-    def __init__(self, create_fn: Optional[Callable[..., Any]], acreate_fn: Optional[Callable[..., Any]]):
+    def __init__(self, create_fn: Callable[..., Any] | None, acreate_fn: Callable[..., Any] | None):
         super().__init__(create_fn, acreate_fn, "Embedding")
 
-    def process_output(self, response: Dict[str, Any], span: Span):
+    def process_output(self, response: dict[str, Any], span: Span):
         usage = response.get("usage")
         metrics = _parse_metrics_from_usage(usage)
         span.log(
@@ -567,7 +650,7 @@ class EmbeddingWrapper(BaseWrapper):
 
 
 class ModerationWrapper(BaseWrapper):
-    def __init__(self, create_fn: Optional[Callable[..., Any]], acreate_fn: Optional[Callable[..., Any]]):
+    def __init__(self, create_fn: Callable[..., Any] | None, acreate_fn: Callable[..., Any] | None):
         super().__init__(create_fn, acreate_fn, "Moderation")
 
     def process_output(self, response: Any, span: Span):
@@ -814,7 +897,7 @@ TOKEN_PREFIX_MAP = {
 }
 
 
-def _parse_metrics_from_usage(usage: Any) -> Dict[str, Any]:
+def _parse_metrics_from_usage(usage: Any) -> dict[str, Any]:
     # For simplicity, this function handles all the different APIs
     metrics = {}
 
@@ -848,7 +931,7 @@ def _is_numeric(v):
     return isinstance(v, (int, float, complex)) and not isinstance(v, bool)
 
 
-def prettify_params(params: Dict[str, Any]) -> Dict[str, Any]:
+def prettify_params(params: dict[str, Any]) -> dict[str, Any]:
     # Filter out NOT_GIVEN parameters
     # https://linear.app/braintrustdata/issue/BRA-2467
     ret = {k: v for k, v in params.items() if not _is_not_given(v)}
@@ -858,7 +941,7 @@ def prettify_params(params: Dict[str, Any]) -> Dict[str, Any]:
     return ret
 
 
-def _try_to_dict(obj: Any) -> Dict[str, Any]:
+def _try_to_dict(obj: Any) -> dict[str, Any]:
     if isinstance(obj, dict):
         return obj
     # convert a pydantic object to a dict

braintrust/otel/__init__.py

@@ -1,7 +1,6 @@
 import logging
 import os
 import warnings
-from typing import Dict, Optional
 from urllib.parse import urljoin
 
 INSTALL_ERR_MSG = (
@@ -138,10 +137,10 @@ class OtelExporter(OTLPSpanExporter):
 
     def __init__(
         self,
-        url: Optional[str] = None,
-        api_key: Optional[str] = None,
-        parent: Optional[str] = None,
-        headers: Optional[Dict[str, str]] = None,
+        url: str | None = None,
+        api_key: str | None = None,
+        parent: str | None = None,
+        headers: dict[str, str] | None = None,
         **kwargs,
     ):
         """
@@ -189,13 +188,14 @@ class OtelExporter(OTLPSpanExporter):
         super().__init__(endpoint=endpoint, headers=exporter_headers, **kwargs)
 
 
-def add_braintrust_span_processor(tracer_provider,
-    api_key: Optional[str] = None,
-    parent: Optional[str] = None,
-    api_url: Optional[str] = None,
+def add_braintrust_span_processor(
+    tracer_provider,
+    api_key: str | None = None,
+    parent: str | None = None,
+    api_url: str | None = None,
     filter_ai_spans: bool = False,
     custom_filter=None,
-    headers: Optional[Dict[str, str]] = None,
+    headers: dict[str, str] | None = None,
 ):
     processor = BraintrustSpanProcessor(
         api_key=api_key,
@@ -225,13 +225,13 @@ class BraintrustSpanProcessor:
 
     def __init__(
         self,
-        api_key: Optional[str] = None,
-        parent: Optional[str] = None,
-        api_url: Optional[str] = None,
+        api_key: str | None = None,
+        parent: str | None = None,
+        api_url: str | None = None,
         filter_ai_spans: bool = False,
-        custom_filter = None,
-        headers: Optional[Dict[str, str]] = None,
-        SpanProcessor: Optional[type] = None,
+        custom_filter=None,
+        headers: dict[str, str] | None = None,
+        SpanProcessor: type | None = None,
     ):
         """
         Initialize the BraintrustSpanProcessor.
@@ -279,16 +279,17 @@ class BraintrustSpanProcessor:
 
             # Priority 1: Check if braintrust.parent is in current OTEL context
             from opentelemetry import baggage, context
+
             current_context = context.get_current()
-            parent_value = context.get_value('braintrust.parent', current_context)
+            parent_value = context.get_value("braintrust.parent", current_context)
 
             # Priority 2: Check OTEL baggage (propagates automatically across contexts)
             if not parent_value:
-                parent_value = baggage.get_baggage('braintrust.parent', context=current_context)
+                parent_value = baggage.get_baggage("braintrust.parent", context=current_context)
 
             # Priority 3: Check if parent_context has braintrust.parent (backup)
             if not parent_value and parent_context:
-                parent_value = context.get_value('braintrust.parent', parent_context)
+                parent_value = context.get_value("braintrust.parent", parent_context)
 
             # Priority 4: Check if parent OTEL span has braintrust.parent attribute
             if not parent_value and parent_context:
@@ -304,7 +305,6 @@ class BraintrustSpanProcessor:
 
         self._processor.on_start(span, parent_context)
 
-
     def _get_parent_otel_braintrust_parent(self, parent_context):
         """Get braintrust.parent attribute from parent OTEL span if it exists."""
         try:
@@ -313,7 +313,7 @@ class BraintrustSpanProcessor:
             # Get the current span from the parent context
             current_span = trace.get_current_span(parent_context)
 
-            if current_span and hasattr(current_span, 'attributes') and current_span.attributes:
+            if current_span and hasattr(current_span, "attributes") and current_span.attributes:
                 # Check if parent span has braintrust.parent attribute
                 attributes = dict(current_span.attributes)
                 return attributes.get("braintrust.parent")
@@ -346,11 +346,7 @@ class BraintrustSpanProcessor:
         return self._processor
 
 
-def _get_braintrust_parent(
-    object_type,
-    object_id: Optional[str] = None,
-    compute_args: Optional[Dict] = None
-) -> Optional[str]:
+def _get_braintrust_parent(object_type, object_id: str | None = None, compute_args: dict | None = None) -> str | None:
     """
     Construct a braintrust.parent identifier string from span components.
 
@@ -405,11 +401,10 @@ def context_from_span_export(export_str: str):
     if not OTEL_AVAILABLE:
         raise ImportError(INSTALL_ERR_MSG)
 
+    from braintrust.span_identifier_v4 import SpanComponentsV4
     from opentelemetry import baggage, trace
     from opentelemetry.trace import NonRecordingSpan, SpanContext, TraceFlags
 
-    from braintrust.span_identifier_v4 import SpanComponentsV4
-
     # Parse the export string (handles V3/V4 automatically)
     components = SpanComponentsV4.from_str(export_str)
 
@@ -417,7 +412,7 @@ def context_from_span_export(export_str: str):
     braintrust_parent = _get_braintrust_parent(
         object_type=components.object_type,
         object_id=components.object_id,
-        compute_args=components.compute_object_metadata_args
+        compute_args=components.compute_object_metadata_args,
     )
 
     # Convert hex strings to OTEL integers
@@ -429,7 +424,7 @@ def context_from_span_export(export_str: str):
         trace_id=trace_id_int,
         span_id=span_id_int,
         is_remote=True,  # Critical: mark as remote for distributed tracing
-        trace_flags=TraceFlags(TraceFlags.SAMPLED)
+        trace_flags=TraceFlags(TraceFlags.SAMPLED),
     )
 
     # Create NonRecordingSpan and set in context
@@ -438,7 +433,7 @@ def context_from_span_export(export_str: str):
 
     # Set braintrust.parent in OTEL baggage so it propagates automatically
     if braintrust_parent:
-        ctx = baggage.set_baggage('braintrust.parent', braintrust_parent, context=ctx)
+        ctx = baggage.set_baggage("braintrust.parent", braintrust_parent, context=ctx)
 
     return ctx
 
@@ -475,7 +470,7 @@ def add_parent_to_baggage(parent: str, ctx=None):
     from opentelemetry import baggage, context
 
     # Set in baggage so it propagates via inject()
-    new_ctx = baggage.set_baggage('braintrust.parent', parent, context=ctx)
+    new_ctx = baggage.set_baggage("braintrust.parent", parent, context=ctx)
     token = context.attach(new_ctx)
     return token
 
@@ -511,11 +506,11 @@ def add_span_parent_to_baggage(span, ctx=None):
         raise ImportError(INSTALL_ERR_MSG)
 
     # Get braintrust.parent from span attributes
-    if not span or not hasattr(span, 'attributes') or not span.attributes:
+    if not span or not hasattr(span, "attributes") or not span.attributes:
         logging.warning("add_span_parent_to_baggage: span has no attributes")
         return None
 
-    parent_value = span.attributes.get('braintrust.parent')
+    parent_value = span.attributes.get("braintrust.parent")
     if not parent_value:
         logging.warning(
             "add_span_parent_to_baggage: braintrust.parent attribute not found. "
@@ -527,7 +522,7 @@ def add_span_parent_to_baggage(span, ctx=None):
     return add_parent_to_baggage(parent_value, ctx=ctx)
 
 
-def parent_from_headers(headers: Dict[str, str]) -> Optional[str]:
+def parent_from_headers(headers: dict[str, str]) -> str | None:
     """
     Extract a Braintrust-compatible parent string from W3C Trace Context headers.
 
@@ -554,17 +549,16 @@ def parent_from_headers(headers: Dict[str, str]) -> Optional[str]:
     if not OTEL_AVAILABLE:
         raise ImportError(INSTALL_ERR_MSG)
 
+    from braintrust.span_identifier_v4 import SpanComponentsV4
     from opentelemetry import baggage, trace
     from opentelemetry.propagate import extract
 
-    from braintrust.span_identifier_v4 import SpanComponentsV4
-
     # Extract context from headers using W3C Trace Context propagator
     ctx = extract(headers)
 
     # Get span from context
     span = trace.get_current_span(ctx)
-    if not span or not hasattr(span, 'get_span_context'):
+    if not span or not hasattr(span, "get_span_context"):
         logging.error("parent_from_headers: No valid span found in headers")
         return None
 
@@ -574,19 +568,19 @@ def parent_from_headers(headers: Dict[str, str]) -> Optional[str]:
         return None
 
     # Convert OTEL IDs to hex strings
-    trace_id_hex = format(span_context.trace_id, '032x')
-    span_id_hex = format(span_context.span_id, '016x')
+    trace_id_hex = format(span_context.trace_id, "032x")
+    span_id_hex = format(span_context.span_id, "016x")
 
     # Validate trace_id and span_id are not all zeros
-    if trace_id_hex == '00000000000000000000000000000000':
+    if trace_id_hex == "00000000000000000000000000000000":
         logging.error("parent_from_headers: Invalid trace_id (all zeros)")
         return None
-    if span_id_hex == '0000000000000000':
+    if span_id_hex == "0000000000000000":
         logging.error("parent_from_headers: Invalid span_id (all zeros)")
         return None
 
     # Get braintrust.parent from baggage if present
-    braintrust_parent = baggage.get_baggage('braintrust.parent', context=ctx)
+    braintrust_parent = baggage.get_baggage("braintrust.parent", context=ctx)
 
     # Parse braintrust.parent to extract object_type and object_id
     object_type = None
@@ -607,22 +601,28 @@ def parent_from_headers(headers: Dict[str, str]) -> Optional[str]:
         # Parse braintrust.parent format: "project_id:abc", "project_name:xyz", or "experiment_id:123"
         if braintrust_parent.startswith("project_id:"):
             object_type = SpanObjectTypeV3.PROJECT_LOGS
-            object_id = braintrust_parent[len("project_id:"):]
+            object_id = braintrust_parent[len("project_id:") :]
             if not object_id:
-                logging.error(f"parent_from_headers: Invalid braintrust.parent format (empty project_id): {braintrust_parent}")
+                logging.error(
+                    f"parent_from_headers: Invalid braintrust.parent format (empty project_id): {braintrust_parent}"
+                )
                 return None
         elif braintrust_parent.startswith("project_name:"):
             object_type = SpanObjectTypeV3.PROJECT_LOGS
-            project_name = braintrust_parent[len("project_name:"):]
+            project_name = braintrust_parent[len("project_name:") :]
             if not project_name:
-                logging.error(f"parent_from_headers: Invalid braintrust.parent format (empty project_name): {braintrust_parent}")
+                logging.error(
+                    f"parent_from_headers: Invalid braintrust.parent format (empty project_name): {braintrust_parent}"
+                )
                 return None
             compute_args = {"project_name": project_name}
         elif braintrust_parent.startswith("experiment_id:"):
             object_type = SpanObjectTypeV3.EXPERIMENT
-            object_id = braintrust_parent[len("experiment_id:"):]
+            object_id = braintrust_parent[len("experiment_id:") :]
             if not object_id:
-                logging.error(f"parent_from_headers: Invalid braintrust.parent format (empty experiment_id): {braintrust_parent}")
+                logging.error(
+                    f"parent_from_headers: Invalid braintrust.parent format (empty experiment_id): {braintrust_parent}"
+                )
                 return None
         else:
             logging.error(