style: apply ruff-format fixes

Change-Id: I2b522c578078ebf8ac70d258027906dc1c7c57b5

Author: sunym1991

instrumentation-loongsuite/loongsuite-instrumentation-mem0/src/opentelemetry/instrumentation/mem0/internal/_extractors.py

@@ -175,7 +175,9 @@ def _extract_input_content(
     return None
 
 
-def _extract_output_preview(result: Any, max_len: Optional[int] = None) -> Optional[str]:
+def _extract_output_preview(
+    result: Any, max_len: Optional[int] = None
+) -> Optional[str]:
     """
     Extract output content from Memory operation result, returning fields containing content.
 

instrumentation-loongsuite/loongsuite-instrumentation-mem0/src/opentelemetry/instrumentation/mem0/internal/_wrapper.py

@@ -226,8 +226,12 @@ def _float_or_none(value: Any) -> float | None:
     def _filter_operation_attrs_for_invocation(operation_attrs: dict) -> dict:
         """Remove keys that should be carried by MemoryInvocation fields rather than custom attributes."""
         # Strip content keys: content should go to invocation.input_messages/output_messages
-        operation_attrs.pop(SemanticAttributes.GEN_AI_MEMORY_INPUT_MESSAGES, None)
-        operation_attrs.pop(SemanticAttributes.GEN_AI_MEMORY_OUTPUT_MESSAGES, None)
+        operation_attrs.pop(
+            SemanticAttributes.GEN_AI_MEMORY_INPUT_MESSAGES, None
+        )
+        operation_attrs.pop(
+            SemanticAttributes.GEN_AI_MEMORY_OUTPUT_MESSAGES, None
+        )
         # Strip server info keys: server info should go to invocation.server_address/server_port
         operation_attrs.pop(SemanticAttributes.SERVER_ADDRESS, None)
         operation_attrs.pop(SemanticAttributes.SERVER_PORT, None)
@@ -265,23 +269,31 @@ def _apply_extracted_attrs_to_invocation(
                 )
 
             # Map content to invocation fields (let util decide whether to record them)
-            if (input_msg := operation_attrs.get(
-                SemanticAttributes.GEN_AI_MEMORY_INPUT_MESSAGES
-            )) is not None:
+            if (
+                input_msg := operation_attrs.get(
+                    SemanticAttributes.GEN_AI_MEMORY_INPUT_MESSAGES
+                )
+            ) is not None:
                 invocation.input_messages = input_msg
-            if (output_msg := operation_attrs.get(
-                SemanticAttributes.GEN_AI_MEMORY_OUTPUT_MESSAGES
-            )) is not None:
+            if (
+                output_msg := operation_attrs.get(
+                    SemanticAttributes.GEN_AI_MEMORY_OUTPUT_MESSAGES
+                )
+            ) is not None:
                 invocation.output_messages = output_msg
 
             # Map server info to invocation fields
-            if (server_addr := operation_attrs.get(
-                SemanticAttributes.SERVER_ADDRESS
-            )) is not None:
+            if (
+                server_addr := operation_attrs.get(
+                    SemanticAttributes.SERVER_ADDRESS
+                )
+            ) is not None:
                 invocation.server_address = safe_str(server_addr)
-            if (server_port := operation_attrs.get(
-                SemanticAttributes.SERVER_PORT
-            )) is not None:
+            if (
+                server_port := operation_attrs.get(
+                    SemanticAttributes.SERVER_PORT
+                )
+            ) is not None:
                 try:
                     invocation.server_port = int(server_port)
                 except Exception:

instrumentation-loongsuite/loongsuite-instrumentation-mem0/tests/conftest.py

@@ -338,7 +338,9 @@ def environment():
 
 @pytest.fixture(scope="function")
 def instrument_with_content(tracer_provider, meter_provider):
-    os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "SPAN_ONLY"
+    os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = (
+        "SPAN_ONLY"
+    )
     instrumentor = Mem0Instrumentor()
     instrumentor.instrument(
         tracer_provider=tracer_provider, meter_provider=meter_provider
@@ -350,7 +352,9 @@ def instrument_with_content(tracer_provider, meter_provider):
 
 @pytest.fixture(scope="function")
 def instrument_no_content(tracer_provider, meter_provider):
-    os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "NO_CONTENT"
+    os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = (
+        "NO_CONTENT"
+    )
     instrumentor = Mem0Instrumentor()
     instrumentor.instrument(
         tracer_provider=tracer_provider, meter_provider=meter_provider
@@ -371,7 +375,9 @@ def instrument_with_factories_patched(
     patch_factories(monkeypatch)
 
     # Then instrument (enable internal phase capture)
-    os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "SPAN_ONLY"
+    os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = (
+        "SPAN_ONLY"
+    )
     os.environ["OTEL_INSTRUMENTATION_MEM0_INNER_ENABLED"] = "True"
     instrumentor = Mem0Instrumentor()
     instrumentor.instrument(

instrumentation-loongsuite/loongsuite-instrumentation-mem0/tests/test_memory_client_errors_vcr.py

@@ -55,12 +55,12 @@ def test_client_connection_error_vcr(
     error_spans = [
         s for s in spans if s.status.status_code == StatusCode.ERROR
     ]
-    assert error_spans, (
-        "Should generate at least one top-level span with ERROR status"
-    )
-    assert any("error.type" in s.attributes for s in error_spans), (
-        "Error span should contain error.type"
-    )
+    assert (
+        error_spans
+    ), "Should generate at least one top-level span with ERROR status"
+    assert any(
+        "error.type" in s.attributes for s in error_spans
+    ), "Error span should contain error.type"
 
 
 def _start_test_http_server(status_code: int) -> Tuple[HTTPServer, str]:

instrumentation-loongsuite/loongsuite-instrumentation-mem0/tests/test_memory_operations_vcr.py

@@ -342,9 +342,7 @@ def test_internal_subphases_attributes(
     assert any(
         s.attributes.get("gen_ai.memory.vector.method") in valid_vec_methods
         for s in vec_spans
-    ), (
-        f"Vector method should be one of valid values, actual: {[s.attributes.get('gen_ai.memory.vector.method') for s in vec_spans]}"
-    )
+    ), f"Vector method should be one of valid values, actual: {[s.attributes.get('gen_ai.memory.vector.method') for s in vec_spans]}"
     # Verify provider (now uses data_source.type)
     assert any(
         s.attributes.get("gen_ai.memory.data_source.type") is not None
@@ -360,9 +358,9 @@ def test_internal_subphases_attributes(
     if m.reranker is not None:
         # If Memory instance has reranker, should be able to collect reranker span
         # Because reranker is created via factory, will be instrumented
-        assert reranker_spans, (
-            "When reranker exists, should collect reranker stage spans"
-        )
+        assert (
+            reranker_spans
+        ), "When reranker exists, should collect reranker stage spans"
         # Verify attributes
         assert any(
             s.attributes.get("gen_ai.provider.name") is not None
@@ -376,9 +374,9 @@ def test_internal_subphases_attributes(
         if s.attributes.get("gen_ai.memory.graph.method") is not None
     ]
     if m.enable_graph:
-        assert graph_spans, (
-            "When graph is enabled, should collect graph stage spans"
-        )
+        assert (
+            graph_spans
+        ), "When graph is enabled, should collect graph stage spans"
 
     # 4. LLM and Embedding: do not require generating mem0 subphase spans
     # These should be handled by corresponding LLM/Embedding plugins
@@ -440,17 +438,17 @@ def test_vector_operations_detailed_attributes(
             or "gen_ai.memory.vector.k" in search_span.attributes
         ), "search span should contain limit or k"
         # Verify filter_keys (note: actual attribute name is filter_keys, not filters.keys)
-        assert "gen_ai.memory.vector.filter_keys" in search_span.attributes, (
-            "search span should contain filter_keys"
-        )
+        assert (
+            "gen_ai.memory.vector.filter_keys" in search_span.attributes
+        ), "search span should contain filter_keys"
         filter_keys = search_span.attributes.get(
             "gen_ai.memory.vector.filter_keys"
         )
         assert "user_id" in filter_keys, "filter_keys should contain user_id"
         # Verify result_count
-        assert "gen_ai.memory.vector.result_count" in search_span.attributes, (
-            "search span should contain result_count"
-        )
+        assert (
+            "gen_ai.memory.vector.result_count" in search_span.attributes
+        ), "search span should contain result_count"
 
 
 @pytest.mark.vcr()
@@ -516,9 +514,9 @@ def test_graph_operations_detailed_attributes(
         result_count = add_span.attributes.get(
             "gen_ai.memory.graph.result_count"
         )
-        assert result_count is not None and result_count >= 0, (
-            f"add span should contain result_count, actual value: {result_count}"
-        )
+        assert (
+            result_count is not None and result_count >= 0
+        ), f"add span should contain result_count, actual value: {result_count}"
 
 
 @pytest.mark.vcr()
@@ -557,9 +555,9 @@ def test_reranker_operations_detailed_attributes(
     assert reranker_spans, "should collect reranker spans"
 
     reranker_span = reranker_spans[0]
-    assert reranker_span.attributes.get("gen_ai.provider.name") == "fake", (
-        "should contain correct provider.name"
-    )
+    assert (
+        reranker_span.attributes.get("gen_ai.provider.name") == "fake"
+    ), "should contain correct provider.name"
     # Now uses gen_ai.rerank.documents_count instead of gen_ai.memory.reranker.input_count
     if "gen_ai.rerank.documents_count" in reranker_span.attributes:
         documents_count = reranker_span.attributes.get(