ruff

Author: isaacbmiller

dspy/adapters/__init__.py

@@ -1,8 +1,8 @@
+from dspy.adapters.baml_adapter import BAMLAdapter
 from dspy.adapters.base import Adapter
 from dspy.adapters.chat_adapter import ChatAdapter
 from dspy.adapters.json_adapter import JSONAdapter
 from dspy.adapters.two_step_adapter import TwoStepAdapter
-from dspy.adapters.baml_adapter import BAMLAdapter
 from dspy.adapters.types import Audio, Code, History, Image, Tool, ToolCalls, Type
 from dspy.adapters.xml_adapter import XMLAdapter
 

dspy/adapters/types/base_type.py

@@ -25,7 +25,7 @@ def format(self) -> list[dict[str, Any]]:
                 return [{"type": "image_url", "image_url": {"url": self.url}}]
         ```
     """
-    
+
     def __class_getitem__(cls, item):
         # Support generics while preserving custom instance check
         result = super().__class_getitem__(item)
@@ -37,13 +37,13 @@ def __instancecheck__(cls, instance):
         # First check normal instance check
         if super(Type, cls).__instancecheck__(instance):
             return True
-        
+
         # Check if instance is a string with custom type format
         # Thoretically we want types to implement their own data validation for whatever comes in the middle
         if isinstance(instance, str):
             pattern = rf"{CUSTOM_TYPE_START_IDENTIFIER}(.*?){CUSTOM_TYPE_END_IDENTIFIER}"
             return bool(re.search(pattern, instance))
-        
+
         return False
 
     def format(self) -> list[dict[str, Any]] | str:

dspy/adapters/types/image.py

@@ -11,7 +11,7 @@
 import pydantic
 import requests
 
-from dspy.adapters.types.base_type import Type, CUSTOM_TYPE_START_IDENTIFIER, CUSTOM_TYPE_END_IDENTIFIER
+from dspy.adapters.types.base_type import CUSTOM_TYPE_END_IDENTIFIER, CUSTOM_TYPE_START_IDENTIFIER, Type
 
 try:
     from PIL import Image as PILImage
@@ -240,26 +240,26 @@ def _extract_url_from_custom_type(text: str) -> str:
     """Extract the image URL from custom type format string."""
     pattern = rf"{CUSTOM_TYPE_START_IDENTIFIER}(.*?){CUSTOM_TYPE_END_IDENTIFIER}"
     match = re.search(pattern, text, re.DOTALL)
-    
+
     if not match:
         raise ValueError("No custom type format found in string")
-    
+
     custom_content = match.group(1).strip()
-    
+
     try:
         # Try to parse as JSON
         parsed = json.loads(custom_content.replace("'", '"'))
-        
+
         # Extract URL from the image_url structure
         if isinstance(parsed, list) and len(parsed) > 0:
             first_item = parsed[0]
             if isinstance(first_item, dict) and first_item.get("type") == "image_url":
                 image_url_dict = first_item.get("image_url", {})
                 if "url" in image_url_dict:
                     return image_url_dict["url"]
-        
+
         raise ValueError("Could not find image URL in custom type format")
-    
+
     except json.JSONDecodeError:
         raise ValueError(f"Invalid JSON in custom type format: {custom_content}")
 

dspy/adapters/utils.py

@@ -4,14 +4,13 @@
 import json
 import types
 from collections.abc import Mapping
+from copy import deepcopy
 from typing import Any, Literal, Union, get_args, get_origin
 
 import json_repair
-from litellm.utils import f
 import pydantic
 from pydantic import TypeAdapter
 from pydantic.fields import FieldInfo
-from copy import deepcopy
 
 from dspy.adapters.types.base_type import Type as DspyType
 from dspy.signatures.utils import get_dspy_field_type
@@ -55,7 +54,7 @@ def format_field_value(field_info: FieldInfo, value: Any, assume_text=True, is_p
     # If the annotation is a Type subclass, but the value is not a instance of that type, force it to be one.
     if issubclass(field_info.annotation, Type) and not isinstance(value, field_info.annotation) and not is_placeholder:
         value = field_info.annotation(value)
-    
+
     if isinstance(value, list) and field_info.annotation is str:
         # If the field has no special type requirements, format it as a nice numbered list for the LM.
         string_value = _format_input_list_field_value(value)

dspy/utils/dummies.py

@@ -4,12 +4,12 @@
 
 import numpy as np
 
-from dspy.adapters.chat_adapter import ChatAdapter, FieldInfoWithName, field_header_pattern
+from dspy.adapters.chat_adapter import FieldInfoWithName, field_header_pattern
 from dspy.clients.lm import LM
+from dspy.dsp.utils.settings import settings
 from dspy.dsp.utils.utils import dotdict
 from dspy.signatures.field import OutputField
 from dspy.utils.callback import with_callbacks
-from dspy.dsp.utils.settings import settings
 
 
 class DummyLM(LM):
@@ -105,7 +105,7 @@ def format_answer_fields(field_names_and_values: dict[str, Any]):
                 # Fallback to ChatAdapter if no adapter is set
                 from dspy.adapters.chat_adapter import ChatAdapter
                 adapter = ChatAdapter()
-            
+
             # Try to use role="assistant" if the adapter supports it (like JSONAdapter)
             try:
                 return adapter.format_field_with_value(fields_with_values, role="assistant")

tests/signatures/test_adapter_image.py

@@ -129,10 +129,10 @@ def test_basic_image_operations(test_case):
 @pytest.mark.parametrize(
     "adapter_type",
     [
-        "chat_adapter", 
-        "json_adapter", 
-        # "two_step_adapter", 
-        "baml_adapter", 
+        "chat_adapter",
+        "json_adapter",
+        # "two_step_adapter",
+        "baml_adapter",
         "xml_adapter",
     ],
 )
@@ -502,24 +502,24 @@ def test_from_methods_warn(tmp_path):
 def test_invalid_string_format():
     """Test that invalid string formats raise a ValueError"""
     invalid_string = "this_is_not_a_url_or_file"
-    
+
     # Should raise a ValueError and not pass the string through
     with pytest.raises(ValueError, match="Unrecognized") as warning_info:
         image = dspy.Image(invalid_string)
 
 def test_pil_image_with_download_parameter():
     """Test behavior when PIL image is passed with download=True"""
     sample_pil = PILImage.new("RGB", (60, 30), color="red")
-    
+
     # PIL image should be encoded regardless of download parameter
     image_no_download = dspy.Image(sample_pil)
     image_with_download = dspy.Image(sample_pil, download=True)
-    
+
     # Both should result in base64 encoded data URIs
     assert image_no_download.url.startswith("data:")
     assert image_with_download.url.startswith("data:")
     assert "base64," in image_no_download.url
     assert "base64," in image_with_download.url
-    
+
     # They should be identical since PIL images are always encoded
     assert image_no_download.url == image_with_download.url