DSPy: The framework for programming—not prompting—language models
Python
Better support for string types
Thomas D Ahleba550d0667a2
diff --git a/dspy/functional/functional.py b/dspy/functional/functional.pyindex a45fc4aeb..15725aacf 100644--- a/dspy/functional/functional.py+++ b/dspy/functional/functional.py@@ -53,9 +53,9 @@ class FunctionalModule(dspy.Module):self.__dict__[name] = attr.copy()-def TypedChainOfThought(signature, max_retries=3) -> dspy.Module: # noqa: N802+def TypedChainOfThought(signature, instructions=None, *, max_retries=3) -> dspy.Module: # noqa: N802"""Just like TypedPredictor, but adds a ChainOfThought OutputField."""- signature = ensure_signature(signature)+ signature = ensure_signature(signature, instructions)output_keys = ", ".join(signature.output_fields.keys())return TypedPredictor(signature.prepend(@@ -70,7 +70,7 @@ def TypedChainOfThought(signature, max_retries=3) -> dspy.Module: # noqa: N802class TypedPredictor(dspy.Module):- def __init__(self, signature, max_retries=3, wrap_json=False, explain_errors=False):+ def __init__(self, signature, instructions=None, *, max_retries=3, wrap_json=False, explain_errors=False):"""Like dspy.Predict, but enforces type annotations in the signature.Args:@@ -79,14 +79,14 @@ class TypedPredictor(dspy.Module):wrap_json: If True, json objects in the input will be wrapped in ```json ... ```"""super().__init__()- self.signature = ensure_signature(signature)+ self.signature = ensure_signature(signature, instructions)self.predictor = dspy.Predict(signature)self.max_retries = max_retriesself.wrap_json = wrap_jsonself.explain_errors = explain_errorsdef copy(self) -> "TypedPredictor":- return TypedPredictor(self.signature, self.max_retries, self.wrap_json)+ return TypedPredictor(self.signature, max_retries=self.max_retries, wrap_json=self.wrap_json)def __repr__(self):"""Return a string representation of the TypedPredictor object."""diff --git a/dspy/signatures/signature.py b/dspy/signatures/signature.pyindex 74fa3ee73..d10f71718 100644--- a/dspy/signatures/signature.py+++ b/dspy/signatures/signature.py@@ -206,11 +206,13 @@ class Signature(BaseModel, metaclass=SignatureMeta):pass-def ensure_signature(signature: Union[str, Type[Signature]]) -> Signature:+def ensure_signature(signature: Union[str, Type[Signature]], instructions=None) -> Signature:if signature is None:return Noneif isinstance(signature, str):- return Signature(signature)+ return Signature(signature, instructions)+ if instructions is not None:+ raise ValueError("Don't specify instructions when initializing with a Signature")return signature@@ -277,27 +279,22 @@ def _parse_signature(signature: str) -> Tuple[Type, Field]:if signature.count("->") != 1:raise ValueError(f"Invalid signature format: '{signature}', must contain exactly one '->'.")+ inputs_str, outputs_str = signature.split("->")+fields = {}- inputs_str, outputs_str = map(str.strip, signature.split("->"))- inputs = [v.strip() for v in inputs_str.split(",") if v.strip()]- outputs = [v.strip() for v in outputs_str.split(",") if v.strip()]- for name_type in inputs:- name, type_ = _parse_named_type_node(name_type)+ for name, type_ in _parse_arg_string(inputs_str):fields[name] = (type_, InputField())- for name_type in outputs:- name, type_ = _parse_named_type_node(name_type)+ for name, type_ in _parse_arg_string(outputs_str):fields[name] = (type_, OutputField())return fields-def _parse_named_type_node(node, names=None) -> Any:- parts = node.split(":")- if len(parts) == 1:- return parts[0], str- name, type_str = parts- type_ = _parse_type_node(ast.parse(type_str), names)- return name, type_+def _parse_arg_string(string: str, names=None) -> Dict[str, str]:+ args = ast.parse("def f(" + string + "): pass").body[0].args.args+ names = [arg.arg for arg in args]+ types = [str if arg.annotation is None else _parse_type_node(arg.annotation) for arg in args]+ return zip(names, types)def _parse_type_node(node, names=None) -> Any:@@ -306,7 +303,7 @@ def _parse_type_node(node, names=None) -> Any:without using structural pattern matching introduced in Python 3.10."""if names is None:- names = {}+ names = typing.__dict__if isinstance(node, ast.Module):body = node.body@@ -325,16 +322,23 @@ def _parse_type_node(node, names=None) -> Any:for type_ in [int, str, float, bool, list, tuple, dict]:if type_.__name__ == id_:return type_+ raise ValueError(f"Unknown name: {id_}")- elif isinstance(node, ast.Subscript):+ if isinstance(node, ast.Subscript):base_type = _parse_type_node(node.value, names)arg_type = _parse_type_node(node.slice, names)return base_type[arg_type]- elif isinstance(node, ast.Tuple):+ if isinstance(node, ast.Tuple):elts = node.eltsreturn tuple(_parse_type_node(elt, names) for elt in elts)+ if isinstance(node, ast.Call):+ if node.func.id == "Field":+ keys = [kw.arg for kw in node.keywords]+ values = [kw.value.value for kw in node.keywords]+ return Field(**dict(zip(keys, values)))+raise ValueError(f"Code is not syntactically valid: {node}")diff --git a/tests/functional/test_functional.py b/tests/functional/test_functional.pyindex 2bedfa356..c106a13c4 100644--- a/tests/functional/test_functional.py+++ b/tests/functional/test_functional.py@@ -781,3 +781,24 @@ def _test_demos_missing_input():Input: What is the capital of France?Thoughts: My thoughtsOutput: Paris""")+++def test_conlist():+ dspy.settings.configure(+ lm=DummyLM(['{"value": []}', '{"value": [1]}', '{"value": [1, 2]}', '{"value": [1, 2, 3]}'])+ )++ @predictor+ def make_numbers(input: str) -> Annotated[list[int], Field(min_items=2)]:+ pass++ assert make_numbers(input="What are the first two numbers?") == [1, 2]+++def test_conlist2():+ dspy.settings.configure(+ lm=DummyLM(['{"value": []}', '{"value": [1]}', '{"value": [1, 2]}', '{"value": [1, 2, 3]}'])+ )++ make_numbers = TypedPredictor("input:str -> output:Annotated[List[int], Field(min_items=2)]")+ assert make_numbers(input="What are the first two numbers?").output == [1, 2]