google-api-core 2.19.2__tar.gz → 2.20.0__tar.gz

{google_api_core-2.19.2/google_api_core.egg-info → google_api_core-2.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-api-core
-Version: 2.19.2
+Version: 2.20.0
 Summary: Google API client core library
 Home-page: https://github.com/googleapis/python-api-core
 Author: Google LLC

google_api_core-2.19.2/google/api_core/rest_streaming.py → google_api_core-2.20.0/google/api_core/_rest_streaming_base.py

@@ -1,4 +1,4 @@
-# Copyright 2021 Google LLC
+# Copyright 2024 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,18 +17,17 @@
 from collections import deque
 import string
 from typing import Deque, Union
+import types
 
 import proto
-import requests
 import google.protobuf.message
 from google.protobuf.json_format import Parse
 
 
-class ResponseIterator:
-    """Iterator over REST API responses.
+class BaseResponseIterator:
+    """Base Iterator over REST API responses. This class should not be used directly.
 
     Args:
-        response (requests.Response): An API response object.
         response_message_cls (Union[proto.Message, google.protobuf.message.Message]): A response
         class expected to be returned from an API.
 
@@ -38,13 +37,9 @@ class ResponseIterator:
 
     def __init__(
         self,
-        response: requests.Response,
         response_message_cls: Union[proto.Message, google.protobuf.message.Message],
     ):
-        self._response = response
         self._response_message_cls = response_message_cls
-        # Inner iterator over HTTP response's content.
-        self._response_itr = self._response.iter_content(decode_unicode=True)
         # Contains a list of JSON responses ready to be sent to user.
         self._ready_objs: Deque[str] = deque()
         # Current JSON response being built.
@@ -57,9 +52,7 @@ class ResponseIterator:
         # Whether an escape symbol "\" was encountered.
         self._escape_next = False
 
-    def cancel(self):
-        """Cancel existing streaming operation."""
-        self._response.close()
+        self._grab = types.MethodType(self._create_grab(), self)
 
     def _process_chunk(self, chunk: str):
         if self._level == 0:
@@ -104,29 +97,22 @@ class ResponseIterator:
                 self._obj += char
             self._escape_next = not self._escape_next if char == "\\" else False
 
-    def __next__(self):
-        while not self._ready_objs:
-            try:
-                chunk = next(self._response_itr)
-                self._process_chunk(chunk)
-            except StopIteration as e:
-                if self._level > 0:
-                    raise ValueError("Unfinished stream: %s" % self._obj)
-                raise e
-        return self._grab()
-
-    def _grab(self):
-        # Add extra quotes to make json.loads happy.
+    def _create_grab(self):
         if issubclass(self._response_message_cls, proto.Message):
-            return self._response_message_cls.from_json(
-                self._ready_objs.popleft(), ignore_unknown_fields=True
-            )
+
+            def grab(this):
+                return this._response_message_cls.from_json(
+                    this._ready_objs.popleft(), ignore_unknown_fields=True
+                )
+
+            return grab
         elif issubclass(self._response_message_cls, google.protobuf.message.Message):
-            return Parse(self._ready_objs.popleft(), self._response_message_cls())
+
+            def grab(this):
+                return Parse(this._ready_objs.popleft(), this._response_message_cls())
+
+            return grab
         else:
             raise ValueError(
                 "Response message class must be a subclass of proto.Message or google.protobuf.message.Message."
             )
-
-    def __iter__(self):
-        return self

{google_api_core-2.19.2 → google_api_core-2.20.0}/google/api_core/exceptions.py

@@ -22,7 +22,7 @@ from __future__ import absolute_import
 from __future__ import unicode_literals
 
 import http.client
-from typing import Dict
+from typing import Optional, Dict
 from typing import Union
 import warnings
 
@@ -442,6 +442,12 @@ class DeadlineExceeded(GatewayTimeout):
     grpc_status_code = grpc.StatusCode.DEADLINE_EXCEEDED if grpc is not None else None
 
 
+class AsyncRestUnsupportedParameterError(NotImplementedError):
+    """Raised when an unsupported parameter is configured against async rest transport."""
+
+    pass
+
+
 def exception_class_for_http_status(status_code):
     """Return the exception class for a specific HTTP status code.
 
@@ -476,22 +482,37 @@ def from_http_status(status_code, message, **kwargs):
     return error
 
 
-def from_http_response(response):
-    """Create a :class:`GoogleAPICallError` from a :class:`requests.Response`.
+def _format_rest_error_message(error, method, url):
+    method = method.upper() if method else None
+    message = "{method} {url}: {error}".format(
+        method=method,
+        url=url,
+        error=error,
+    )
+    return message
+
+
+# NOTE: We're moving away from `from_http_status` because it expects an aiohttp response compared
+# to `format_http_response_error` which expects a more abstract response from google.auth and is
+# compatible with both sync and async response types.
+# TODO(https://github.com/googleapis/python-api-core/issues/691): Add type hint for response.
+def format_http_response_error(
+    response, method: str, url: str, payload: Optional[Dict] = None
+):
+    """Create a :class:`GoogleAPICallError` from a google auth rest response.
 
     Args:
-        response (requests.Response): The HTTP response.
+        response Union[google.auth.transport.Response, google.auth.aio.transport.Response]: The HTTP response.
+        method Optional(str): The HTTP request method.
+        url Optional(str): The HTTP request url.
+        payload Optional(dict): The HTTP response payload. If not passed in, it is read from response for a response type of google.auth.transport.Response.
 
     Returns:
         GoogleAPICallError: An instance of the appropriate subclass of
             :class:`GoogleAPICallError`, with the message and errors populated
             from the response.
     """
-    try:
-        payload = response.json()
-    except ValueError:
-        payload = {"error": {"message": response.text or "unknown error"}}
-
+    payload = {} if not payload else payload
     error_message = payload.get("error", {}).get("message", "unknown error")
     errors = payload.get("error", {}).get("errors", ())
     # In JSON, details are already formatted in developer-friendly way.
@@ -504,12 +525,7 @@ def from_http_response(response):
         )
     )
     error_info = error_info[0] if error_info else None
-
-    message = "{method} {url}: {error}".format(
-        method=response.request.method,
-        url=response.request.url,
-        error=error_message,
-    )
+    message = _format_rest_error_message(error_message, method, url)
 
     exception = from_http_status(
         response.status_code,
@@ -522,6 +538,26 @@ def from_http_response(response):
     return exception
 
 
+def from_http_response(response):
+    """Create a :class:`GoogleAPICallError` from a :class:`requests.Response`.
+
+    Args:
+        response (requests.Response): The HTTP response.
+
+    Returns:
+        GoogleAPICallError: An instance of the appropriate subclass of
+            :class:`GoogleAPICallError`, with the message and errors populated
+            from the response.
+    """
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = {"error": {"message": response.text or "unknown error"}}
+    return format_http_response_error(
+        response, response.request.method, response.request.url, payload
+    )
+
+
 def exception_class_for_grpc_status(status_code):
     """Return the exception class for a specific :class:`grpc.StatusCode`.
 

{google_api_core-2.19.2 → google_api_core-2.20.0}/google/api_core/gapic_v1/method_async.py

@@ -25,6 +25,8 @@ from google.api_core.gapic_v1.method import _GapicCallable
 from google.api_core.gapic_v1.method import DEFAULT  # noqa: F401
 from google.api_core.gapic_v1.method import USE_DEFAULT_METADATA  # noqa: F401
 
+_DEFAULT_ASYNC_TRANSPORT_KIND = "grpc_asyncio"
+
 
 def wrap_method(
     func,
@@ -32,6 +34,7 @@ def wrap_method(
     default_timeout=None,
     default_compression=None,
     client_info=client_info.DEFAULT_CLIENT_INFO,
+    kind=_DEFAULT_ASYNC_TRANSPORT_KIND,
 ):
     """Wrap an async RPC method with common behavior.
 
@@ -40,7 +43,8 @@ def wrap_method(
             and ``compression`` arguments and applies the common error mapping,
             retry, timeout, metadata, and compression behavior to the low-level RPC method.
     """
-    func = grpc_helpers_async.wrap_errors(func)
+    if kind == _DEFAULT_ASYNC_TRANSPORT_KIND:
+        func = grpc_helpers_async.wrap_errors(func)
 
     metadata = [client_info.to_grpc_metadata()] if client_info is not None else None
 

google_api_core-2.20.0/google/api_core/rest_streaming.py

@@ -0,0 +1,66 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Helpers for server-side streaming in REST."""
+
+from typing import Union
+
+import proto
+import requests
+import google.protobuf.message
+from google.api_core._rest_streaming_base import BaseResponseIterator
+
+
+class ResponseIterator(BaseResponseIterator):
+    """Iterator over REST API responses.
+
+    Args:
+        response (requests.Response): An API response object.
+        response_message_cls (Union[proto.Message, google.protobuf.message.Message]): A response
+        class expected to be returned from an API.
+
+    Raises:
+        ValueError:
+            - If `response_message_cls` is not a subclass of `proto.Message` or `google.protobuf.message.Message`.
+    """
+
+    def __init__(
+        self,
+        response: requests.Response,
+        response_message_cls: Union[proto.Message, google.protobuf.message.Message],
+    ):
+        self._response = response
+        # Inner iterator over HTTP response's content.
+        self._response_itr = self._response.iter_content(decode_unicode=True)
+        super(ResponseIterator, self).__init__(
+            response_message_cls=response_message_cls
+        )
+
+    def cancel(self):
+        """Cancel existing streaming operation."""
+        self._response.close()
+
+    def __next__(self):
+        while not self._ready_objs:
+            try:
+                chunk = next(self._response_itr)
+                self._process_chunk(chunk)
+            except StopIteration as e:
+                if self._level > 0:
+                    raise ValueError("Unfinished stream: %s" % self._obj)
+                raise e
+        return self._grab()
+
+    def __iter__(self):
+        return self

google_api_core-2.20.0/google/api_core/rest_streaming_async.py

@@ -0,0 +1,83 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Helpers for asynchronous server-side streaming in REST."""
+
+from typing import Union
+
+import proto
+
+try:
+    import google.auth.aio.transport
+except ImportError as e:  # pragma: NO COVER
+    raise ImportError(
+        "google-auth>=2.35.0 is required to use asynchronous rest streaming."
+    ) from e
+
+import google.protobuf.message
+from google.api_core._rest_streaming_base import BaseResponseIterator
+
+
+class AsyncResponseIterator(BaseResponseIterator):
+    """Asynchronous Iterator over REST API responses.
+
+    Args:
+        response (google.auth.aio.transport.Response): An API response object.
+        response_message_cls (Union[proto.Message, google.protobuf.message.Message]): A response
+        class expected to be returned from an API.
+
+    Raises:
+        ValueError:
+            - If `response_message_cls` is not a subclass of `proto.Message` or `google.protobuf.message.Message`.
+    """
+
+    def __init__(
+        self,
+        response: google.auth.aio.transport.Response,
+        response_message_cls: Union[proto.Message, google.protobuf.message.Message],
+    ):
+        self._response = response
+        self._chunk_size = 1024
+        self._response_itr = self._response.content().__aiter__()
+        super(AsyncResponseIterator, self).__init__(
+            response_message_cls=response_message_cls
+        )
+
+    async def __aenter__(self):
+        return self
+
+    async def cancel(self):
+        """Cancel existing streaming operation."""
+        await self._response.close()
+
+    async def __anext__(self):
+        while not self._ready_objs:
+            try:
+                chunk = await self._response_itr.__anext__()
+                chunk = chunk.decode("utf-8")
+                self._process_chunk(chunk)
+            except StopAsyncIteration as e:
+                if self._level > 0:
+                    raise ValueError("i Unfinished stream: %s" % self._obj)
+                raise e
+            except ValueError as e:
+                raise e
+        return self._grab()
+
+    def __aiter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        """Cancel existing async streaming operation."""
+        await self._response.close()

{google_api_core-2.19.2 → google_api_core-2.20.0}/google/api_core/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "2.19.2"
+__version__ = "2.20.0"

{google_api_core-2.19.2 → google_api_core-2.20.0/google_api_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-api-core
-Version: 2.19.2
+Version: 2.20.0
 Summary: Google API client core library
 Home-page: https://github.com/googleapis/python-api-core
 Author: Google LLC

{google_api_core-2.19.2 → google_api_core-2.20.0}/google_api_core.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ README.rst
 setup.cfg
 setup.py
 google/api_core/__init__.py
+google/api_core/_rest_streaming_base.py
 google/api_core/bidi.py
 google/api_core/client_info.py
 google/api_core/client_options.py
@@ -23,6 +24,7 @@ google/api_core/protobuf_helpers.py
 google/api_core/py.typed
 google/api_core/rest_helpers.py
 google/api_core/rest_streaming.py
+google/api_core/rest_streaming_async.py
 google/api_core/retry_async.py
 google/api_core/timeout.py
 google/api_core/universe.py
@@ -62,10 +64,12 @@ google_api_core.egg-info/not-zip-safe
 google_api_core.egg-info/requires.txt
 google_api_core.egg-info/top_level.txt
 tests/__init__.py
+tests/helpers.py
 tests/asyncio/__init__.py
 tests/asyncio/test_grpc_helpers_async.py
 tests/asyncio/test_operation_async.py
 tests/asyncio/test_page_iterator_async.py
+tests/asyncio/test_rest_streaming_async.py
 tests/asyncio/future/__init__.py
 tests/asyncio/future/test_async_future.py
 tests/asyncio/gapic/test_config_async.py

{google_api_core-2.19.2 → google_api_core-2.20.0}/tests/asyncio/gapic/test_method_async.py

@@ -252,3 +252,14 @@ async def test_wrap_method_with_overriding_timeout_as_a_number():
 
     assert result == 42
     method.assert_called_once_with(timeout=22, metadata=mock.ANY)
+
+
+@pytest.mark.asyncio
+async def test_wrap_method_without_wrap_errors():
+    fake_call = mock.AsyncMock()
+
+    wrapped_method = gapic_v1.method_async.wrap_method(fake_call, kind="rest")
+    with mock.patch("google.api_core.grpc_helpers_async.wrap_errors") as method:
+        await wrapped_method()
+
+        method.assert_not_called()