auto style fix (#8309)

Author: chenmoneygithub

dspy/adapters/__init__.py

@@ -2,7 +2,7 @@
 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.types import History, Image, Audio, BaseType, Tool, ToolCalls
+from dspy.adapters.types import Audio, BaseType, History, Image, Tool, ToolCalls
 
 __all__ = [
     "Adapter",

dspy/adapters/types/__init__.py

@@ -1,7 +1,7 @@
-from dspy.adapters.types.history import History
-from dspy.adapters.types.image import Image
 from dspy.adapters.types.audio import Audio
 from dspy.adapters.types.base_type import BaseType
+from dspy.adapters.types.history import History
+from dspy.adapters.types.image import Image
 from dspy.adapters.types.tool import Tool, ToolCalls
 
 __all__ = ["History", "Image", "Audio", "BaseType", "Tool", "ToolCalls"]

dspy/adapters/types/audio.py

@@ -48,7 +48,7 @@ def validate_input(cls, values: Any) -> Any:
         """
         if isinstance(values, cls):
             return {"data": values.data, "format": values.format}
-        return encode_audio(values) 
+        return encode_audio(values)
 
     @classmethod
     def from_url(cls, url: str) -> "Audio":
@@ -142,4 +142,4 @@ def encode_audio(audio: Union[str, bytes, dict, "Audio", Any], sampling_rate: in
         encoded = base64.b64encode(audio).decode("utf-8")
         return {"data": encoded, "format": format}
     else:
-        raise ValueError(f"Unsupported type for encode_audio: {type(audio)}")
+        raise ValueError(f"Unsupported type for encode_audio: {type(audio)}")

dspy/dsp/utils/dpr.py

@@ -158,7 +158,7 @@ def __init__(self, **kwargs):
             annotators: None or empty set (only tokenizes).
         """
         self._regexp = regex.compile(
-            "(%s)|(%s)" % (self.ALPHA_NUM, self.NON_WS),  # noqa: UP031
+            "(%s)|(%s)" % (self.ALPHA_NUM, self.NON_WS),
             flags=regex.IGNORECASE + regex.UNICODE + regex.MULTILINE,
         )
         if len(kwargs.get("annotators", {})) > 0:

dspy/predict/__init__.py

@@ -2,13 +2,13 @@
 from dspy.predict.best_of_n import BestOfN
 from dspy.predict.chain_of_thought import ChainOfThought
 from dspy.predict.chain_of_thought_with_hint import ChainOfThoughtWithHint
+from dspy.predict.code_act import CodeAct
 from dspy.predict.knn import KNN
 from dspy.predict.multi_chain_comparison import MultiChainComparison
 from dspy.predict.parallel import Parallel
 from dspy.predict.predict import Predict
 from dspy.predict.program_of_thought import ProgramOfThought
 from dspy.predict.react import ReAct, Tool
-from dspy.predict.code_act import CodeAct
 from dspy.predict.refine import Refine
 
 __all__ = [

dspy/predict/code_act.py

@@ -68,7 +68,7 @@ def factorial(n):
         self.extractor = dspy.ChainOfThought(extract_signature)
         # It will raises exception when dspy cannot find available deno instance by now.
         self.interpreter = PythonInterpreter()
-    
+
     def _build_instructions(self, signature, tools):
         instructions = [f"{signature.instructions}\n"] if signature.instructions else []
         inputs = ", ".join([f"`{k}`" for k in signature.input_fields.keys()])
@@ -85,14 +85,14 @@ def _build_instructions(self, signature, tools):
 
         for idx, tool in enumerate(tools.values()):
             instructions.append(f"({idx + 1}) {tool}")
-        
+
         return instructions
 
     def forward(self, **kwargs):
         # Define the tool funcitons in the interpreter
         for tool in self.tools.values():
             self.interpreter(inspect.getsource(tool.func))
-        
+
         trajectory = {}
         max_iters = kwargs.pop("max_iters", self.max_iters)
         for idx in range(max_iters):
@@ -111,7 +111,7 @@ def forward(self, **kwargs):
                 trajectory[f"code_output_{idx}"] = output
             else:
                 trajectory[f"observation_{idx}"] = f"Failed to execute the generated code: {error}"
-            
+
             if code_data.finished:
                 break
 

dspy/signatures/signature.py

@@ -19,9 +19,9 @@ class MySignature(dspy.Signature):
 import importlib
 import inspect
 import re
+import sys
 import types
 import typing
-import sys
 from copy import deepcopy
 from typing import Any, Dict, Optional, Tuple, Type, Union
 
@@ -71,48 +71,48 @@ def _detect_custom_types_from_caller(signature_str):
 
         # Get type references from caller frames by walking the stack
         found_types = {}
-        
+
         needed_types = set()
         dotted_types = {}
-        
+
         for type_name in type_names:
             parts = type_name.split('.')
             base_name = parts[0]
-            
+
             if base_name not in typing.__dict__ and base_name not in __builtins__:
                 if len(parts) > 1:
                     dotted_types[type_name] = base_name
                     needed_types.add(base_name)
                 else:
                     needed_types.add(type_name)
-        
+
         if not needed_types:
             return None
-            
+
         frame = None
         try:
             frame = sys._getframe(1)  # Start one level up (skip this function)
-            
+
             max_frames = 100
             frame_count = 0
-            
+
             while frame and needed_types and frame_count < max_frames:
                 frame_count += 1
-                
+
                 for type_name in list(needed_types):
                     if type_name in frame.f_locals:
                         found_types[type_name] = frame.f_locals[type_name]
                         needed_types.remove(type_name)
                     elif frame.f_globals and type_name in frame.f_globals:
                         found_types[type_name] = frame.f_globals[type_name]
                         needed_types.remove(type_name)
-                
+
                 # If we found all needed types, stop looking
                 if not needed_types:
                     break
-                    
+
                 frame = frame.f_back
-                
+
             if needed_types and frame_count >= max_frames:
                 import logging
                 logging.getLogger("dspy").warning(
@@ -132,7 +132,7 @@ def _detect_custom_types_from_caller(signature_str):
 
         return found_types or None
 
-    def __new__(mcs, signature_name, bases, namespace, **kwargs):  # noqa: N804
+    def __new__(mcs, signature_name, bases, namespace, **kwargs):
         # At this point, the orders have been swapped already.
         field_order = [name for name, value in namespace.items() if isinstance(value, FieldInfo)]
         # Set `str` as the default type for all fields
@@ -283,10 +283,7 @@ def append(cls, name, field, type_=None) -> Type["Signature"]:
     def delete(cls, name) -> Type["Signature"]:
         fields = dict(cls.fields)
 
-        if name in fields:
-            del fields[name]
-        else:
-            raise ValueError(f"Field `{name}` not found in `{cls.__name__}`.")
+        fields.pop(name, None)
 
         return Signature(fields, cls.instructions)
 
@@ -411,7 +408,7 @@ class MyType:
     if custom_types:
         names = dict(typing.__dict__)
         names.update(custom_types)
-    
+
     fields = _parse_signature(signature, names) if isinstance(signature, str) else signature
 
     # Validate the fields, this is important because we sometimes forget the
@@ -549,15 +546,15 @@ def resolve_name(type_name: str):
     if isinstance(node, ast.Attribute):
         base = _parse_type_node(node.value, names)
         attr_name = node.attr
-        
+
         if hasattr(base, attr_name):
             return getattr(base, attr_name)
-        
+
         if isinstance(node.value, ast.Name):
             full_name = f"{node.value.id}.{attr_name}"
             if full_name in names:
                 return names[full_name]
-        
+
         raise ValueError(f"Unknown attribute: {attr_name} on {base}")
 
     if isinstance(node, ast.Subscript):

dspy/teleprompt/grpo.py

@@ -298,7 +298,7 @@ def compile(
         num_student_predictors = len(student.predictors())
 
         logging.info("Preparing the teacher program(s)... We will ensure that the provided programs have the same program structure as the student program.")
-        if isinstance(teacher, list) and len(teacher) == 0 or teacher is None:
+        if (isinstance(teacher, list) and len(teacher) == 0) or teacher is None:
             teacher = student
         teachers = teacher if isinstance(teacher, list) else [teacher]
         for t in teachers:

dspy/teleprompt/mipro_optimizer_v2.py

@@ -4,9 +4,8 @@
 import sys
 import textwrap
 import time
-from typing import TYPE_CHECKING
 from collections import defaultdict
-from typing import Any, Callable, Dict, List, Literal, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, Optional, Tuple
 
 import numpy as np
 

dspy/utils/langchain_tool.py

@@ -24,13 +24,13 @@ async def func(**kwargs):
             result = await tool.ainvoke(kwargs)
             return result
         except Exception as e:
-            raise RuntimeError(f"Failed to call LangChain tool {tool.name}: {str(e)}")
-    
+            raise RuntimeError(f"Failed to call LangChain tool {tool.name}: {e!s}")
+
     # Get args_schema from the tool
     # https://python.langchain.com/api_reference/core/tools/langchain_core.tools.base.BaseTool.html#langchain_core.tools.base.BaseTool.args_schema
     args_schema = tool.args_schema
     args, _, arg_desc = convert_input_schema_to_tool_args(args_schema.model_json_schema())
-    
+
     # The args_schema of Langchain tool is a pydantic model, so we can get the type hints from the model fields
     arg_types = {
         key: field.annotation if field.annotation is not None else Any
@@ -44,4 +44,4 @@ async def func(**kwargs):
         args=args,
         arg_types=arg_types,
         arg_desc=arg_desc
-    ) 
+    )