google-cloud-spanner 3.50.1__tar.gz → 3.52.0__tar.gz

{google_cloud_spanner-3.50.1/google_cloud_spanner.egg-info → google_cloud_spanner-3.52.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-cloud-spanner
-Version: 3.50.1
+Version: 3.52.0
 Summary: Google Cloud Spanner API client library
 Home-page: https://github.com/googleapis/python-spanner
 Author: Google LLC
@@ -34,6 +34,7 @@ Provides-Extra: tracing
 Requires-Dist: opentelemetry-api>=1.22.0; extra == "tracing"
 Requires-Dist: opentelemetry-sdk>=1.22.0; extra == "tracing"
 Requires-Dist: opentelemetry-semantic-conventions>=0.43b0; extra == "tracing"
+Requires-Dist: google-cloud-monitoring>=2.16.0; extra == "tracing"
 Provides-Extra: libcst
 Requires-Dist: libcst>=0.2.5; extra == "libcst"
 

{google_cloud_spanner-3.50.1 → google_cloud_spanner-3.52.0}/google/cloud/spanner_admin_database_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "3.50.1"  # {x-release-please-version}
+__version__ = "3.52.0"  # {x-release-please-version}

{google_cloud_spanner-3.50.1 → google_cloud_spanner-3.52.0}/google/cloud/spanner_admin_instance_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "3.50.1"  # {x-release-please-version}
+__version__ = "3.52.0"  # {x-release-please-version}

{google_cloud_spanner-3.50.1 → google_cloud_spanner-3.52.0}/google/cloud/spanner_dbapi/connection.py

@@ -89,9 +89,11 @@ class Connection:
         committed by other transactions since the start of the read-only transaction. Commit or rolling back
         the read-only transaction is semantically the same, and only indicates that the read-only transaction
         should end a that a new one should be started when the next statement is executed.
+
+    **kwargs: Initial value for connection variables.
     """
 
-    def __init__(self, instance, database=None, read_only=False):
+    def __init__(self, instance, database=None, read_only=False, **kwargs):
         self._instance = instance
         self._database = database
         self._ddl_statements = []
@@ -111,12 +113,13 @@ class Connection:
         self.request_priority = None
         self._transaction_begin_marked = False
         # whether transaction started at Spanner. This means that we had
-        # made atleast one call to Spanner.
+        # made at least one call to Spanner.
         self._spanner_transaction_started = False
         self._batch_mode = BatchMode.NONE
         self._batch_dml_executor: BatchDmlExecutor = None
         self._transaction_helper = TransactionRetryHelper(self)
         self._autocommit_dml_mode: AutocommitDmlMode = AutocommitDmlMode.TRANSACTIONAL
+        self._connection_variables = kwargs
 
     @property
     def spanner_client(self):
@@ -206,6 +209,10 @@ class Connection:
         """
         return (not self._autocommit) or self._transaction_begin_marked
 
+    @property
+    def _ignore_transaction_warnings(self):
+        return self._connection_variables.get("ignore_transaction_warnings", False)
+
     @property
     def instance(self):
         """Instance to which this connection relates.
@@ -232,7 +239,7 @@ class Connection:
         Args:
             value (bool): True for ReadOnly mode, False for ReadWrite.
         """
-        if self._spanner_transaction_started:
+        if self._read_only != value and self._spanner_transaction_started:
             raise ValueError(
                 "Connection read/write mode can't be changed while a transaction is in progress. "
                 "Commit or rollback the current transaction and try again."
@@ -254,6 +261,28 @@ class Connection:
         self.request_priority = None
         return req_opts
 
+    @property
+    def transaction_tag(self):
+        """The transaction tag that will be applied to the next read/write
+        transaction on this `Connection`. This property is automatically cleared
+        when a new transaction is started.
+
+        Returns:
+            str: The transaction tag that will be applied to the next read/write transaction.
+        """
+        return self._connection_variables.get("transaction_tag", None)
+
+    @transaction_tag.setter
+    def transaction_tag(self, value):
+        """Sets the transaction tag for the next read/write transaction on this
+        `Connection`. This property is automatically cleared when a new transaction
+        is started.
+
+        Args:
+            value (str): The transaction tag for the next read/write transaction.
+        """
+        self._connection_variables["transaction_tag"] = value
+
     @property
     def staleness(self):
         """Current read staleness option value of this `Connection`.
@@ -270,7 +299,7 @@ class Connection:
         Args:
             value (dict): Staleness type and value.
         """
-        if self._spanner_transaction_started:
+        if self._spanner_transaction_started and value != self._staleness:
             raise ValueError(
                 "`staleness` option can't be changed while a transaction is in progress. "
                 "Commit or rollback the current transaction and try again."
@@ -333,6 +362,8 @@ class Connection:
         if not self.read_only and self._client_transaction_started:
             if not self._spanner_transaction_started:
                 self._transaction = self._session_checkout().transaction()
+                self._transaction.transaction_tag = self.transaction_tag
+                self.transaction_tag = None
                 self._snapshot = None
                 self._spanner_transaction_started = True
                 self._transaction.begin()
@@ -398,9 +429,10 @@ class Connection:
         if self.database is None:
             raise ValueError("Database needs to be passed for this operation")
         if not self._client_transaction_started:
-            warnings.warn(
-                CLIENT_TRANSACTION_NOT_STARTED_WARNING, UserWarning, stacklevel=2
-            )
+            if not self._ignore_transaction_warnings:
+                warnings.warn(
+                    CLIENT_TRANSACTION_NOT_STARTED_WARNING, UserWarning, stacklevel=2
+                )
             return
 
         self.run_prior_DDL_statements()
@@ -418,9 +450,10 @@ class Connection:
         This is a no-op if there is no active client transaction.
         """
         if not self._client_transaction_started:
-            warnings.warn(
-                CLIENT_TRANSACTION_NOT_STARTED_WARNING, UserWarning, stacklevel=2
-            )
+            if not self._ignore_transaction_warnings:
+                warnings.warn(
+                    CLIENT_TRANSACTION_NOT_STARTED_WARNING, UserWarning, stacklevel=2
+                )
             return
         try:
             if self._spanner_transaction_started and not self._read_only:
@@ -449,7 +482,9 @@ class Connection:
 
             return self.database.update_ddl(ddl_statements).result()
 
-    def run_statement(self, statement: Statement):
+    def run_statement(
+        self, statement: Statement, request_options: RequestOptions = None
+    ):
         """Run single SQL statement in begun transaction.
 
         This method is never used in autocommit mode. In
@@ -463,6 +498,9 @@ class Connection:
         :param retried: (Optional) Retry the SQL statement if statement
                         execution failed. Defaults to false.
 
+        :type request_options: :class:`RequestOptions`
+        :param request_options: Request options to use for this statement.
+
         :rtype: :class:`google.cloud.spanner_v1.streamed.StreamedResultSet`,
                 :class:`google.cloud.spanner_dbapi.checksum.ResultsChecksum`
         :returns: Streamed result set of the statement and a
@@ -473,7 +511,7 @@ class Connection:
             statement.sql,
             statement.params,
             param_types=statement.param_types,
-            request_options=self.request_options,
+            request_options=request_options or self.request_options,
         )
 
     @check_not_closed
@@ -654,6 +692,7 @@ def connect(
     user_agent=None,
     client=None,
     route_to_leader_enabled=True,
+    **kwargs,
 ):
     """Creates a connection to a Google Cloud Spanner database.
 
@@ -696,6 +735,8 @@ def connect(
         disable leader aware routing. Disabling leader aware routing would
         route all requests in RW/PDML transactions to the closest region.
 
+    **kwargs: Initial value for connection variables.
+
 
     :rtype: :class:`google.cloud.spanner_dbapi.connection.Connection`
     :returns: Connection object associated with the given Google Cloud Spanner

{google_cloud_spanner-3.50.1 → google_cloud_spanner-3.52.0}/google/cloud/spanner_dbapi/cursor.py

@@ -50,6 +50,7 @@ from google.cloud.spanner_dbapi.parsed_statement import (
 from google.cloud.spanner_dbapi.transaction_helper import CursorStatementType
 from google.cloud.spanner_dbapi.utils import PeekIterator
 from google.cloud.spanner_dbapi.utils import StreamedManyResultSets
+from google.cloud.spanner_v1 import RequestOptions
 from google.cloud.spanner_v1.merged_result_set import MergedResultSet
 
 ColumnDetails = namedtuple("column_details", ["null_ok", "spanner_type"])
@@ -97,6 +98,39 @@ class Cursor(object):
         self._parsed_statement: ParsedStatement = None
         self._in_retry_mode = False
         self._batch_dml_rows_count = None
+        self._request_tag = None
+
+    @property
+    def request_tag(self):
+        """The request tag that will be applied to the next statement on this
+        cursor. This property is automatically cleared when a statement is
+        executed.
+
+        Returns:
+            str: The request tag that will be applied to the next statement on
+                 this cursor.
+        """
+        return self._request_tag
+
+    @request_tag.setter
+    def request_tag(self, value):
+        """Sets the request tag for the next statement on this cursor. This
+        property is automatically cleared when a statement is executed.
+
+        Args:
+            value (str): The request tag for the statement.
+        """
+        self._request_tag = value
+
+    @property
+    def request_options(self):
+        options = self.connection.request_options
+        if self._request_tag:
+            if not options:
+                options = RequestOptions()
+            options.request_tag = self._request_tag
+            self._request_tag = None
+        return options
 
     @property
     def is_closed(self):
@@ -284,7 +318,7 @@ class Cursor(object):
                     sql,
                     params=args,
                     param_types=self._parsed_statement.statement.param_types,
-                    request_options=self.connection.request_options,
+                    request_options=self.request_options,
                 )
                 self._result_set = None
             else:
@@ -318,7 +352,9 @@ class Cursor(object):
         if self.connection._client_transaction_started:
             while True:
                 try:
-                    self._result_set = self.connection.run_statement(statement)
+                    self._result_set = self.connection.run_statement(
+                        statement, self.request_options
+                    )
                     self._itr = PeekIterator(self._result_set)
                     return
                 except Aborted:
@@ -478,7 +514,7 @@ class Cursor(object):
             sql,
             params,
             get_param_types(params),
-            request_options=self.connection.request_options,
+            request_options=self.request_options,
         )
         # Read the first element so that the StreamedResultSet can
         # return the metadata after a DQL statement.

{google_cloud_spanner-3.50.1 → google_cloud_spanner-3.52.0}/google/cloud/spanner_dbapi/parse_utils.py

@@ -29,12 +29,19 @@ from .parsed_statement import ParsedStatement, StatementType, Statement
 from .types import DateStr, TimestampStr
 from .utils import sanitize_literals_for_upload
 
+# Note: This mapping deliberately does not contain a value for float.
+# The reason for that is that it is better to just let Spanner determine
+# the parameter type instead of specifying one explicitly. The reason for
+# this is that if the client specifies FLOAT64, and the actual column that
+# the parameter is used for is of type FLOAT32, then Spanner will return an
+# error. If however the client does not specify a type, then Spanner will
+# automatically choose the appropriate type based on the column where the
+# value will be inserted/updated or that it will be compared with.
 TYPES_MAP = {
     bool: spanner.param_types.BOOL,
     bytes: spanner.param_types.BYTES,
     str: spanner.param_types.STRING,
     int: spanner.param_types.INT64,
-    float: spanner.param_types.FLOAT64,
     datetime.datetime: spanner.param_types.TIMESTAMP,
     datetime.date: spanner.param_types.DATE,
     DateStr: spanner.param_types.DATE,
@@ -148,7 +155,7 @@ STMT_UPDATING = "UPDATING"
 STMT_INSERT = "INSERT"
 
 # Heuristic for identifying statements that don't need to be run as updates.
-RE_NON_UPDATE = re.compile(r"^\W*(SELECT)", re.IGNORECASE)
+RE_NON_UPDATE = re.compile(r"^\W*(SELECT|GRAPH|FROM)", re.IGNORECASE)
 
 RE_WITH = re.compile(r"^\s*(WITH)", re.IGNORECASE)
 

{google_cloud_spanner-3.50.1 → google_cloud_spanner-3.52.0}/google/cloud/spanner_dbapi/transaction_helper.py

@@ -20,7 +20,7 @@ import time
 
 from google.cloud.spanner_dbapi.batch_dml_executor import BatchMode
 from google.cloud.spanner_dbapi.exceptions import RetryAborted
-from google.cloud.spanner_v1.session import _get_retry_delay
+from google.cloud.spanner_v1._helpers import _get_retry_delay
 
 if TYPE_CHECKING:
     from google.cloud.spanner_dbapi import Connection, Cursor

{google_cloud_spanner-3.50.1 → google_cloud_spanner-3.52.0}/google/cloud/spanner_v1/_helpers.py

@@ -19,6 +19,7 @@ import decimal
 import math
 import time
 import base64
+import threading
 
 from google.protobuf.struct_pb2 import ListValue
 from google.protobuf.struct_pb2 import Value
@@ -26,10 +27,15 @@ from google.protobuf.message import Message
 from google.protobuf.internal.enum_type_wrapper import EnumTypeWrapper
 
 from google.api_core import datetime_helpers
+from google.api_core.exceptions import Aborted
 from google.cloud._helpers import _date_from_iso8601_date
 from google.cloud.spanner_v1 import TypeCode
 from google.cloud.spanner_v1 import ExecuteSqlRequest
 from google.cloud.spanner_v1 import JsonObject
+from google.cloud.spanner_v1.request_id_header import with_request_id
+from google.rpc.error_details_pb2 import RetryInfo
+
+import random
 
 # Validation error messages
 NUMERIC_MAX_SCALE_ERR_MSG = (
@@ -266,66 +272,69 @@ def _parse_value_pb(value_pb, field_type, field_name, column_info=None):
     :returns: value extracted from value_pb
     :raises ValueError: if unknown type is passed
     """
+    decoder = _get_type_decoder(field_type, field_name, column_info)
+    return _parse_nullable(value_pb, decoder)
+
+
+def _get_type_decoder(field_type, field_name, column_info=None):
+    """Returns a function that converts a Value protobuf to cell data.
+
+    :type field_type: :class:`~google.cloud.spanner_v1.types.Type`
+    :param field_type: type code for the value
+
+    :type field_name: str
+    :param field_name: column name
+
+    :type column_info: dict
+    :param column_info: (Optional) dict of column name and column information.
+            An object where column names as keys and custom objects as corresponding
+            values for deserialization. It's specifically useful for data types like
+            protobuf where deserialization logic is on user-specific code. When provided,
+            the custom object enables deserialization of backend-received column data.
+            If not provided, data remains serialized as bytes for Proto Messages and
+            integer for Proto Enums.
+
+    :rtype: a function that takes a single protobuf value as an input argument
+    :returns: a function that can be used to extract a value from a protobuf value
+    :raises ValueError: if unknown type is passed
+    """
+
     type_code = field_type.code
-    if value_pb.HasField("null_value"):
-        return None
     if type_code == TypeCode.STRING:
-        return value_pb.string_value
+        return _parse_string
     elif type_code == TypeCode.BYTES:
-        return value_pb.string_value.encode("utf8")
+        return _parse_bytes
     elif type_code == TypeCode.BOOL:
-        return value_pb.bool_value
+        return _parse_bool
     elif type_code == TypeCode.INT64:
-        return int(value_pb.string_value)
+        return _parse_int64
     elif type_code == TypeCode.FLOAT64:
-        if value_pb.HasField("string_value"):
-            return float(value_pb.string_value)
-        else:
-            return value_pb.number_value
+        return _parse_float
     elif type_code == TypeCode.FLOAT32:
-        if value_pb.HasField("string_value"):
-            return float(value_pb.string_value)
-        else:
-            return value_pb.number_value
+        return _parse_float
     elif type_code == TypeCode.DATE:
-        return _date_from_iso8601_date(value_pb.string_value)
+        return _parse_date
     elif type_code == TypeCode.TIMESTAMP:
-        DatetimeWithNanoseconds = datetime_helpers.DatetimeWithNanoseconds
-        return DatetimeWithNanoseconds.from_rfc3339(value_pb.string_value)
-    elif type_code == TypeCode.ARRAY:
-        return [
-            _parse_value_pb(
-                item_pb, field_type.array_element_type, field_name, column_info
-            )
-            for item_pb in value_pb.list_value.values
-        ]
-    elif type_code == TypeCode.STRUCT:
-        return [
-            _parse_value_pb(
-                item_pb, field_type.struct_type.fields[i].type_, field_name, column_info
-            )
-            for (i, item_pb) in enumerate(value_pb.list_value.values)
-        ]
+        return _parse_timestamp
     elif type_code == TypeCode.NUMERIC:
-        return decimal.Decimal(value_pb.string_value)
+        return _parse_numeric
     elif type_code == TypeCode.JSON:
-        return JsonObject.from_str(value_pb.string_value)
+        return _parse_json
     elif type_code == TypeCode.PROTO:
-        bytes_value = base64.b64decode(value_pb.string_value)
-        if column_info is not None and column_info.get(field_name) is not None:
-            default_proto_message = column_info.get(field_name)
-            if isinstance(default_proto_message, Message):
-                proto_message = type(default_proto_message)()
-                proto_message.ParseFromString(bytes_value)
-                return proto_message
-        return bytes_value
+        return lambda value_pb: _parse_proto(value_pb, column_info, field_name)
     elif type_code == TypeCode.ENUM:
-        int_value = int(value_pb.string_value)
-        if column_info is not None and column_info.get(field_name) is not None:
-            proto_enum = column_info.get(field_name)
-            if isinstance(proto_enum, EnumTypeWrapper):
-                return proto_enum.Name(int_value)
-        return int_value
+        return lambda value_pb: _parse_proto_enum(value_pb, column_info, field_name)
+    elif type_code == TypeCode.ARRAY:
+        element_decoder = _get_type_decoder(
+            field_type.array_element_type, field_name, column_info
+        )
+        return lambda value_pb: _parse_array(value_pb, element_decoder)
+    elif type_code == TypeCode.STRUCT:
+        element_decoders = [
+            _get_type_decoder(item_field.type_, field_name, column_info)
+            for item_field in field_type.struct_type.fields
+        ]
+        return lambda value_pb: _parse_struct(value_pb, element_decoders)
     else:
         raise ValueError("Unknown type: %s" % (field_type,))
 
@@ -351,6 +360,87 @@ def _parse_list_value_pbs(rows, row_type):
     return result
 
 
+def _parse_string(value_pb) -> str:
+    return value_pb.string_value
+
+
+def _parse_bytes(value_pb):
+    return value_pb.string_value.encode("utf8")
+
+
+def _parse_bool(value_pb) -> bool:
+    return value_pb.bool_value
+
+
+def _parse_int64(value_pb) -> int:
+    return int(value_pb.string_value)
+
+
+def _parse_float(value_pb) -> float:
+    if value_pb.HasField("string_value"):
+        return float(value_pb.string_value)
+    else:
+        return value_pb.number_value
+
+
+def _parse_date(value_pb):
+    return _date_from_iso8601_date(value_pb.string_value)
+
+
+def _parse_timestamp(value_pb):
+    DatetimeWithNanoseconds = datetime_helpers.DatetimeWithNanoseconds
+    return DatetimeWithNanoseconds.from_rfc3339(value_pb.string_value)
+
+
+def _parse_numeric(value_pb):
+    return decimal.Decimal(value_pb.string_value)
+
+
+def _parse_json(value_pb):
+    return JsonObject.from_str(value_pb.string_value)
+
+
+def _parse_proto(value_pb, column_info, field_name):
+    bytes_value = base64.b64decode(value_pb.string_value)
+    if column_info is not None and column_info.get(field_name) is not None:
+        default_proto_message = column_info.get(field_name)
+        if isinstance(default_proto_message, Message):
+            proto_message = type(default_proto_message)()
+            proto_message.ParseFromString(bytes_value)
+            return proto_message
+    return bytes_value
+
+
+def _parse_proto_enum(value_pb, column_info, field_name):
+    int_value = int(value_pb.string_value)
+    if column_info is not None and column_info.get(field_name) is not None:
+        proto_enum = column_info.get(field_name)
+        if isinstance(proto_enum, EnumTypeWrapper):
+            return proto_enum.Name(int_value)
+    return int_value
+
+
+def _parse_array(value_pb, element_decoder) -> []:
+    return [
+        _parse_nullable(item_pb, element_decoder)
+        for item_pb in value_pb.list_value.values
+    ]
+
+
+def _parse_struct(value_pb, element_decoders):
+    return [
+        _parse_nullable(item_pb, element_decoders[i])
+        for (i, item_pb) in enumerate(value_pb.list_value.values)
+    ]
+
+
+def _parse_nullable(value_pb, decoder):
+    if value_pb.HasField("null_value"):
+        return None
+    else:
+        return decoder(value_pb)
+
+
 class _SessionWrapper(object):
     """Base class for objects wrapping a session.
 
@@ -374,11 +464,29 @@ def _metadata_with_prefix(prefix, **kw):
     return [("google-cloud-resource-prefix", prefix)]
 
 
+def _retry_on_aborted_exception(
+    func,
+    deadline,
+):
+    """
+    Handles retry logic for Aborted exceptions, considering the deadline.
+    """
+    attempts = 0
+    while True:
+        try:
+            attempts += 1
+            return func()
+        except Aborted as exc:
+            _delay_until_retry(exc, deadline=deadline, attempts=attempts)
+            continue
+
+
 def _retry(
     func,
     retry_count=5,
     delay=2,
     allowed_exceptions=None,
+    beforeNextRetry=None,
 ):
     """
     Retry a function with a specified number of retries, delay between retries, and list of allowed exceptions.
@@ -395,6 +503,9 @@ def _retry(
     """
     retries = 0
     while retries <= retry_count:
+        if retries > 0 and beforeNextRetry:
+            beforeNextRetry(retries, delay)
+
         try:
             return func()
         except Exception as exc:
@@ -437,3 +548,99 @@ def _metadata_with_leader_aware_routing(value, **kw):
         List[Tuple[str, str]]: RPC metadata with leader aware routing header
     """
     return ("x-goog-spanner-route-to-leader", str(value).lower())
+
+
+def _delay_until_retry(exc, deadline, attempts):
+    """Helper for :meth:`Session.run_in_transaction`.
+
+    Detect retryable abort, and impose server-supplied delay.
+
+    :type exc: :class:`google.api_core.exceptions.Aborted`
+    :param exc: exception for aborted transaction
+
+    :type deadline: float
+    :param deadline: maximum timestamp to continue retrying the transaction.
+
+    :type attempts: int
+    :param attempts: number of call retries
+    """
+
+    cause = exc.errors[0]
+    now = time.time()
+    if now >= deadline:
+        raise
+
+    delay = _get_retry_delay(cause, attempts)
+    if delay is not None:
+        if now + delay > deadline:
+            raise
+
+        time.sleep(delay)
+
+
+def _get_retry_delay(cause, attempts):
+    """Helper for :func:`_delay_until_retry`.
+
+    :type exc: :class:`grpc.Call`
+    :param exc: exception for aborted transaction
+
+    :rtype: float
+    :returns: seconds to wait before retrying the transaction.
+
+    :type attempts: int
+    :param attempts: number of call retries
+    """
+    if hasattr(cause, "trailing_metadata"):
+        metadata = dict(cause.trailing_metadata())
+    else:
+        metadata = {}
+    retry_info_pb = metadata.get("google.rpc.retryinfo-bin")
+    if retry_info_pb is not None:
+        retry_info = RetryInfo()
+        retry_info.ParseFromString(retry_info_pb)
+        nanos = retry_info.retry_delay.nanos
+        return retry_info.retry_delay.seconds + nanos / 1.0e9
+
+    return 2**attempts + random.random()
+
+
+class AtomicCounter:
+    def __init__(self, start_value=0):
+        self.__lock = threading.Lock()
+        self.__value = start_value
+
+    @property
+    def value(self):
+        with self.__lock:
+            return self.__value
+
+    def increment(self, n=1):
+        with self.__lock:
+            self.__value += n
+            return self.__value
+
+    def __iadd__(self, n):
+        """
+        Defines the inplace += operator result.
+        """
+        with self.__lock:
+            self.__value += n
+            return self
+
+    def __add__(self, n):
+        """
+        Defines the result of invoking: value = AtomicCounter + addable
+        """
+        with self.__lock:
+            n += self.__value
+            return n
+
+    def __radd__(self, n):
+        """
+        Defines the result of invoking: value = addable + AtomicCounter
+        """
+        return self.__add__(n)
+
+
+def _metadata_with_request_id(*args, **kwargs):
+    return with_request_id(*args, **kwargs)