Reformat with ruff.

Author: michaelsafyan

instrumentation-genai/opentelemetry-instrumentation-google-genai/tests/common/auth.py

@@ -16,6 +16,5 @@
 
 
 class FakeCredentials(google.auth.credentials.AnonymousCredentials):
-
     def refresh(self, request):
         pass

instrumentation-genai/opentelemetry-instrumentation-google-genai/tests/generate_content/base.py

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import asyncio
 import unittest
 import unittest.mock
 
-from google.genai.models import Models, AsyncModels
+from google.genai.models import AsyncModels, Models
+
 from ..common.base import TestCase as CommonTestCaseBase
 from .util import convert_to_response, create_response
 
@@ -45,7 +45,7 @@ def mock_generate_content(self):
         if self._generate_content_mock is None:
             self._create_and_install_mocks()
         return self._generate_content_mock
-    
+
     @property
     def mock_generate_content_stream(self):
         if self._generate_content_stream_mock is None:
@@ -68,66 +68,88 @@ def _create_and_install_mocks(self):
 
     def _create_nonstream_mock(self):
         mock = unittest.mock.MagicMock()
+
         def _default_impl(*args, **kwargs):
             if not self._responses:
                 return create_response(text="Some response")
             index = self._response_index % len(self._responses)
             result = self._responses[index]
             self._response_index += 1
             return result
+
         mock.side_effect = _default_impl
         return mock
 
     def _create_stream_mock(self):
         mock = unittest.mock.MagicMock()
+
         def _default_impl(*args, **kwargs):
             for response in self._responses:
                 yield response
+
         mock.side_effect = _default_impl
         return mock
 
     def _install_mocks(self):
         output_wrapped = self._wrap_output(self._generate_content_mock)
-        output_wrapped_stream = self._wrap_output_stream(self._generate_content_stream_mock)
+        output_wrapped_stream = self._wrap_output_stream(
+            self._generate_content_stream_mock
+        )
         Models.generate_content = output_wrapped
         Models.generate_content_stream = output_wrapped_stream
         AsyncModels.generate_content = self._async_wrapper(output_wrapped)
-        AsyncModels.generate_content_stream = self._async_stream_wrapper(output_wrapped_stream)
-    
+        AsyncModels.generate_content_stream = self._async_stream_wrapper(
+            output_wrapped_stream
+        )
+
     def _wrap_output(self, mock_generate_content):
         def _wrapped(*args, **kwargs):
             return convert_to_response(mock_generate_content(*args, **kwargs))
+
         return _wrapped
 
     def _wrap_output_stream(self, mock_generate_content_stream):
         def _wrapped(*args, **kwargs):
             for output in mock_generate_content_stream(*args, **kwargs):
-               yield convert_to_response(output)
+                yield convert_to_response(output)
+
         return _wrapped
 
     def _async_wrapper(self, mock_generate_content):
         async def _wrapped(*args, **kwargs):
             return mock_generate_content(*args, **kwargs)
+
         return _wrapped
 
     def _async_stream_wrapper(self, mock_generate_content_stream):
         async def _wrapped(*args, **kwargs):
             async def _internal_generator():
                 for result in mock_generate_content_stream(*args, **kwargs):
                     yield result
+
             return _internal_generator()
+
         return _wrapped
 
     def tearDown(self):
         super().tearDown()
         if self._generate_content_mock is None:
             assert Models.generate_content == self._original_generate_content
-            assert Models.generate_content_stream == self._original_generate_content_stream
-            assert AsyncModels.generate_content == self._original_async_generate_content
-            assert AsyncModels.generate_content_stream == self._original_async_generate_content_stream
+            assert (
+                Models.generate_content_stream
+                == self._original_generate_content_stream
+            )
+            assert (
+                AsyncModels.generate_content
+                == self._original_async_generate_content
+            )
+            assert (
+                AsyncModels.generate_content_stream
+                == self._original_async_generate_content_stream
+            )
         Models.generate_content = self._original_generate_content
         Models.generate_content_stream = self._original_generate_content_stream
         AsyncModels.generate_content = self._original_async_generate_content
         AsyncModels.generate_content_stream = (
             self._original_async_generate_content_stream
-        )
+        )

instrumentation-genai/opentelemetry-instrumentation-google-genai/tests/generate_content/streaming_base.py

@@ -16,6 +16,7 @@
 
 from .base import TestCase
 
+
 class StreamingTestCase(TestCase):
     # The "setUp" function is defined by "unittest.TestCase" and thus
     # this name must be used. Uncertain why pylint doesn't seem to
@@ -32,7 +33,6 @@ def generate_content(self, *args, **kwargs):
     def expected_function_name(self):
         raise NotImplementedError("Must implement 'expected_function_name'.")
 
-
     def test_instrumentation_does_not_break_core_functionality(self):
         self.configure_valid_response(text="Yep, it works!")
         responses = self.generate_content(