Support more ast types in Signature typed parsing

[thomasahle]

On the website, you see this example:

import dspy
dspy.configure(lm=dspy.LM('gpt-4o-mini-2024-07-18'))

# Define the DSPy module for classification. It will use the hint at training time, if available.
signature = dspy.Signature("text -> label").with_updated_fields('label', type_=Literal[tuple(CLASSES)])
classify = dspy.ChainOfThoughtWithHint(signature)

# Optimize via BootstrapFinetune.
optimizer = dspy.BootstrapFinetune(metric=(lambda x, y, trace=None: x.label == y.label), num_threads=24)
optimized = optimizer.compile(classify, trainset=trainset)

optimized_classifier(text="What does a pending cash withdrawal mean?")

This would have been a lot cleaner as

signature = dspy.Signature(f"text -> label:Literal{CLASSES}")

We already has support for most of this.
If you see

dspy/dspy/signatures/signature.py

Line 402 in a8d1107

def _parse_type_node(node, names=None) -> Any:

you just have to add a case for ast.Constant, like this:

    if isinstance(node, ast.Constant):
        return node.value

Then you get

In[1]: dspy.Signature(f"text -> label:Literal[1,2]")
Out[1]:
StringSignature(text -> label
    instructions='Given the fields `text`, produce the fields `label`.'
    text = Field(annotation=str required=True json_schema_extra={'__dspy_field_type': 'input', 'prefix': 'Text:', 'desc': '${text}'})
    label = Field(annotation=Literal[1, 2] required=True json_schema_extra={'__dspy_field_type': 'output', 'prefix': 'Label:', 'desc': '${label}'})
)

and

In[1]: CLASSES = ["good", "bad"]
In[2]: dspy.Signature(f"text -> label:Literal{CLASSES}")
Out[2]:
StringSignature(text -> label
    instructions='Given the fields `text`, produce the fields `label`.'
    text = Field(annotation=str required=True json_schema_extra={'__dspy_field_type': 'input', 'prefix': 'Text:', 'desc': '${text}'})
    label = Field(annotation=Literal['good', 'bad'] required=True json_schema_extra={'__dspy_field_type': 'output', 'prefix': 'Label:', 'desc': '${label}'})
)

[okhat]

Hey @thomasahle ! Welcome back --- so happy to see an issue from you once again!

Yes this makes sense to me. I wonder also if we should consider the following syntactic sugar:

dspy.Signature("a, b -> c", a=int, c=dspy.Field(float, desc="percentage score"))
# b=str by default
# c=dspy.Field not necessarily OutputField, because the input/output status is inferred from the signature string

[thomasahle]

Hey @okhat! I saw your nice new website, and wanted to help streamline the demos :-)

Having something like you suggest would be nice when using more complicated types. But note we already have the following decorator in

dspy/dspy/functional/functional.py

Line 22 in 6178c28

def predictor(*args: tuple, **kwargs) -> Callable[..., dspy.Module]:

which gives you

@predictor
def classify(text:str) -> Literal[*CLASSES]:
    pass

For simple types and demos, the string notation is still neat though. Presumably we still want to allow
dspy.Signature("context:list[str], query:str -> answer:str") and all that, so we might as well give full access to things like dspy.Signature("text:str -> label:Literal[1,2,3]").
After all, the code is already there, and very general using the ast module.

[thomasahle]

Just forgot, we also have this inline way of creating Signatures:

sig = Signature({
    "input_str_list": (List[str], InputField()),
    "input_dict_int": (Dict[str, int], InputField()),
    "output_tup": (Tuple[int, float], OutputField()),
})

but that's probably not recommended in most code.