Updated the DatabricksRM class to use Databricks service principals.

.github/workflows/run_tests.yml

@@ -50,7 +50,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.11"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -93,7 +93,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.11"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5

docs/docs/cheatsheet.md

@@ -271,7 +271,7 @@ your_dspy_program_compiled = labeled_fewshot_optimizer.compile(student = your_ds
 ```python
 from dspy.teleprompt import BootstrapFewShot
 
-fewshot_optimizer = BootstrapFewShot(metric=your_defined_metric, max_bootstrapped_demos=4, max_labeled_demos=16, max_rounds=1, max_errors=5)
+fewshot_optimizer = BootstrapFewShot(metric=your_defined_metric, max_bootstrapped_demos=4, max_labeled_demos=16, max_rounds=1, max_errors=10)
 
 your_dspy_program_compiled = fewshot_optimizer.compile(student = your_dspy_program, trainset=trainset)
 ```
@@ -281,7 +281,7 @@ your_dspy_program_compiled = fewshot_optimizer.compile(student = your_dspy_progr
 ```python
 from dspy.teleprompt import BootstrapFewShot
 
-fewshot_optimizer = BootstrapFewShot(metric=your_defined_metric, max_bootstrapped_demos=4, max_labeled_demos=16, max_rounds=1, max_errors=5, teacher_settings=dict(lm=gpt4))
+fewshot_optimizer = BootstrapFewShot(metric=your_defined_metric, max_bootstrapped_demos=4, max_labeled_demos=16, max_rounds=1, max_errors=10, teacher_settings=dict(lm=gpt4))
 
 your_dspy_program_compiled = fewshot_optimizer.compile(student = your_dspy_program, trainset=trainset)
 ```

dspy/.internal_dspyai/pyproject.toml

@@ -2,7 +2,7 @@
 #replace_package_name_marker
 name="dspy-ai"  
 #replace_package_version_marker
-version="2.6.25"  
+version="2.6.27"  
 description = "DSPy"  
 readme = "README.md"  
 authors = [  

dspy/__metadata__.py

@@ -1,7 +1,7 @@
 #replace_package_name_marker
 __name__="dspy"
 #replace_package_version_marker
-__version__="2.6.25"
+__version__="2.6.27"
 __description__="DSPy"
 __url__="https://github.com/stanfordnlp/dspy"
 __author__="Omar Khattab"

dspy/adapters/json_adapter.py

@@ -219,8 +219,8 @@ def _get_structured_outputs_response_format(signature: SignatureMeta) -> type[py
     # Build the model with extra fields forbidden.
     pydantic_model = pydantic.create_model(
         "DSPyProgramOutputs",
+        __config__=pydantic.ConfigDict(extra="forbid"),
         **fields,
-        __config__=type("Config", (), {"extra": "forbid"}),
     )
 
     # Generate the initial schema.

dspy/adapters/types/base_type.py

@@ -41,9 +41,13 @@ def extract_custom_type_from_annotation(cls, annotation):
         This is used to extract all custom types from the annotation of a field, while the annotation can
         have arbitrary level of nesting. For example, we detect `Tool` is in `list[dict[str, Tool]]`.
         """
-        # Direct match
-        if isinstance(annotation, type) and issubclass(annotation, cls):
-            return [annotation]
+        # Direct match. Nested type like `list[dict[str, Event]]` passes `isinstance(annotation, type)` in python 3.10
+        # while fails in python 3.11. To accomodate users using python 3.10, we need to capture the error and ignore it.
+        try:
+            if isinstance(annotation, type) and issubclass(annotation, cls):
+                return [annotation]
+        except TypeError:
+            pass
 
         origin = get_origin(annotation)
         if origin is None:

dspy/adapters/types/tool.py

@@ -206,17 +206,23 @@ def from_langchain(cls, tool: "BaseTool") -> "Tool":
             A Tool object.
 
         Example:
+
         ```python
-        from langchain.tools import tool
+        import asyncio
         import dspy
+        from langchain.tools import tool as lc_tool
 
-        @tool
+        @lc_tool
         def add(x: int, y: int):
             "Add two numbers together."
             return x + y
 
-        tool = dspy.Tool.from_langchain(add)
-        print(await tool.acall(x=1, y=2))
+        dspy_tool = dspy.Tool.from_langchain(add)
+
+        async def run_tool():
+            return await dspy_tool.acall(x=1, y=2)
+
+        print(asyncio.run(run_tool()))
         # 3
         ```
         """

dspy/clients/base_lm.py

@@ -137,7 +137,7 @@ def copy(self, **kwargs):
         return new_instance
 
     def inspect_history(self, n: int = 1):
-        return inspect_history(self.history, n)
+        return pretty_print_history(self.history, n)
 
     def update_global_history(self, entry):
         if settings.disable_history:

dspy/datasets/hotpotqa.py

@@ -20,8 +20,8 @@ def __init__(
 
         from datasets import load_dataset
 
-        hf_official_train = load_dataset("vincentkoc/hotpot_qa_archive", "fullwiki", split="train", trust_remote_code=True)
-        hf_official_dev = load_dataset("vincentkoc/hotpot_qa_archive", "fullwiki", split="validation", trust_remote_code=True)
+        hf_official_train = load_dataset("hotpot_qa", "fullwiki", split="train", trust_remote_code=True)
+        hf_official_dev = load_dataset("hotpot_qa", "fullwiki", split="validation", trust_remote_code=True)
 
         official_train = []
         for raw_example in hf_official_train:

dspy/dsp/colbertv2.py

@@ -151,7 +151,7 @@ def forward(self, query: str, k: int = 7, **kwargs):
 
         if kwargs.get("filtered_pids"):
             filtered_pids = kwargs.get("filtered_pids")
-            assert type(filtered_pids) == List[int], "The filtered pids should be a list of integers"
+            assert isinstance(filtered_pids, list) and all(isinstance(pid, int) for pid in filtered_pids), "The filtered pids should be a list of integers"
             device = "cuda" if torch.cuda.is_available() else "cpu"
             results = self.searcher.search(
                 query,

dspy/dsp/utils/settings.py

@@ -26,6 +26,7 @@
     stream_listeners=[],
     provide_traceback=False,  # Whether to include traceback information in error logs.
     num_threads=8,  # Number of threads to use for parallel processing.
+    max_errors=10,  # Maximum errors before halting operations.
 )
 
 # Global base configuration and owner tracking

dspy/evaluate/evaluate.py

@@ -56,7 +56,7 @@ def __init__(
         num_threads: Optional[int] = None,
         display_progress: bool = False,
         display_table: Union[bool, int] = False,
-        max_errors: int = 5,
+        max_errors: Optional[int] = None,
         return_all_scores: bool = False,
         return_outputs: bool = False,
         provide_traceback: Optional[bool] = None,
@@ -71,7 +71,8 @@ def __init__(
             display_progress (bool): Whether to display progress during evaluation.
             display_table (Union[bool, int]): Whether to display the evaluation results in a table.
                 If a number is passed, the evaluation results will be truncated to that number before displayed.
-            max_errors (int): The maximum number of errors to allow before stopping evaluation.
+            max_errors (Optional[int]): The maximum number of errors to allow before
+                stopping evaluation. If ``None``, inherits from ``dspy.settings.max_errors``.
             return_all_scores (bool): Whether to return scores for every data record in `devset`.
             return_outputs (bool): Whether to return the dspy program's outputs for every data in `devset`.
             provide_traceback (Optional[bool]): Whether to provide traceback information during evaluation.
@@ -151,7 +152,11 @@ def __call__(
         executor = ParallelExecutor(
             num_threads=num_threads,
             disable_progress_bar=not display_progress,
-            max_errors=self.max_errors,
+            max_errors=(
+                self.max_errors
+                if self.max_errors is not None
+                else dspy.settings.max_errors
+            ),
             provide_traceback=self.provide_traceback,
             compare_results=True,
         )

dspy/predict/code_act.py

@@ -1,7 +1,7 @@
 import inspect
+from typing import Callable, Union, Type, Optional
 import logging
 from inspect import Signature
-from typing import Callable, Type, Union
 
 import dspy
 from dspy.adapters.types.tool import Tool
@@ -17,15 +17,15 @@ class CodeAct(ReAct, ProgramOfThought):
     CodeAct is a module that utilizes the Code Interpreter and predefined tools to solve the problem.
     """
 
-    def __init__(self, signature: Union[str, Type[Signature]], tools: list[Callable], max_iters: int = 5):
+    def __init__(self, signature: Union[str, Type[Signature]], tools: list[Callable], max_iters: int = 5, interpreter: Optional[PythonInterpreter] = None):
         """
         Initializes the CodeAct class with the specified model, temperature, and max tokens.
 
         Args:
             signature (Union[str, Type[Signature]]): The signature of the module.
             tools (list[Callable]): The tool callables to be used. CodeAct only accepts functions and not callable objects.
             max_iters (int): The maximum number of iterations to generate the answer.
-
+            interpreter: PythonInterpreter instance to use. If None, a new one is instantiated.
         Example:
             ```python
             from dspy.predict import CodeAct
@@ -67,8 +67,8 @@ def factorial(n):
         self.codeact = dspy.Predict(codeact_signature)
         self.extractor = dspy.ChainOfThought(extract_signature)
         # It will raises exception when dspy cannot find available deno instance by now.
-        self.interpreter = PythonInterpreter()
-
+        self.interpreter = interpreter or 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()])

dspy/predict/parallel.py

@@ -10,15 +10,15 @@ class Parallel:
     def __init__(
         self,
         num_threads: Optional[int] = None,
-        max_errors: int = 10,
+        max_errors: Optional[int] = None,
         access_examples: bool = True,
         return_failed_examples: bool = False,
         provide_traceback: Optional[bool] = None,
         disable_progress_bar: bool = False,
     ):
         super().__init__()
         self.num_threads = num_threads or settings.num_threads
-        self.max_errors = max_errors
+        self.max_errors = settings.max_errors if max_errors is None else max_errors
         self.access_examples = access_examples
         self.return_failed_examples = return_failed_examples
         self.provide_traceback = provide_traceback

dspy/predict/program_of_thought.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import re
-from typing import Type, Union
+from typing import Type, Union, Optional
 
 import dspy
 from dspy.primitives.program import Module
@@ -27,11 +27,12 @@ class ProgramOfThought(Module):
     ```
     """
 
-    def __init__(self, signature: Union[str, Type[Signature]], max_iters=3):
+    def __init__(self, signature: Union[str, Type[Signature]], max_iters=3, interpreter: Optional[PythonInterpreter] = None):
         """
         Args:
             signature: The signature of the module.
             max_iters: The maximum number of iterations to retry code generation and execution.
+            interpreter: PythonInterpreter instance to use. If None, a new one is instantiated.
         """
         super().__init__()
         self.signature = signature = ensure_signature(signature)
@@ -59,7 +60,7 @@ def __init__(self, signature: Union[str, Type[Signature]], max_iters=3):
             ),
         )
         # It will raises exception when dspy cannot find available deno instance by now.
-        self.interpreter = PythonInterpreter()
+        self.interpreter = interpreter or PythonInterpreter()
 
     def _generate_signature(self, mode):
         signature_dict = dict(self.input_fields)

dspy/primitives/program.py

@@ -115,7 +115,7 @@ def batch(
         self,
         examples,
         num_threads: Optional[int] = None,
-        max_errors: int = 10,
+        max_errors: Optional[int] = None,
         return_failed_examples: bool = False,
         provide_traceback: Optional[bool] = None,
         disable_progress_bar: bool = False,
@@ -127,10 +127,11 @@ def batch(
             examples: List of dspy.Example instances to process.
             num_threads: Number of threads to use for parallel processing.
             max_errors: Maximum number of errors allowed before stopping execution.
+                If ``None``, inherits from ``dspy.settings.max_errors``.
             return_failed_examples: Whether to return failed examples and exceptions.
             provide_traceback: Whether to include traceback information in error logs.
             disable_progress_bar: Whether to display the progress bar.
-            
+
         Returns:
             List of results, and optionally failed examples and exceptions.
         """