dspy.Code

dspy.Code

Bases: Type

Code type in DSPy.

This type is useful for code generation and code analysis.

Example 1: dspy.Code as output type in code generation:

import dspy

dspy.configure(lm=dspy.LM("openai/gpt-4o-mini"))


class CodeGeneration(dspy.Signature):
    '''Generate python code to answer the question.'''

    question: str = dspy.InputField(description="The question to answer")
    code: dspy.Code["java"] = dspy.OutputField(description="The code to execute")


predict = dspy.Predict(CodeGeneration)

result = predict(question="Given an array, find if any of the two numbers sum up to 10")
print(result.code)

Example 2: dspy.Code as input type in code analysis:

import dspy
import inspect

dspy.configure(lm=dspy.LM("openai/gpt-4o-mini"))

class CodeAnalysis(dspy.Signature):
    '''Analyze the time complexity of the function.'''

    code: dspy.Code["python"] = dspy.InputField(description="The function to analyze")
    result: str = dspy.OutputField(description="The time complexity of the function")


predict = dspy.Predict(CodeAnalysis)


def sleepsort(x):
    import time

    for i in x:
        time.sleep(i)
        print(i)

result = predict(code=inspect.getsource(sleepsort))
print(result.result)

Functions

description() -> str classmethod

Source code in dspy/adapters/types/code.py

@classmethod
def description(cls) -> str:
    return (
        "Code represented in a string, specified in the `code` field. If this is an output field, the code "
        "field should follow the markdown code block format, e.g. \n```python\n{code}\n``` or \n```cpp\n{code}\n```"
        f"\nProgramming language: {cls.language}"
    )

extract_custom_type_from_annotation(annotation) classmethod

Extract all custom types from the 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]].

Source code in dspy/adapters/types/base_type.py

@classmethod
def extract_custom_type_from_annotation(cls, annotation):
    """Extract all custom types from the 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. Nested type like `list[dict[str, Event]]` passes `isinstance(annotation, type)` in python 3.10
    # while fails in python 3.11. To accommodate 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:
        return []

    result = []
    # Recurse into all type args
    for arg in get_args(annotation):
        result.extend(cls.extract_custom_type_from_annotation(arg))

    return result

format()

Source code in dspy/adapters/types/code.py

def format(self):
    return f"{self.code}"

serialize_model()

Override to bypass the <> and <> tags.

Source code in dspy/adapters/types/code.py

@pydantic.model_serializer()
def serialize_model(self):
    """Override to bypass the <<CUSTOM-TYPE-START-IDENTIFIER>> and <<CUSTOM-TYPE-END-IDENTIFIER>> tags."""
    return self.format()

validate_input(data: Any) classmethod

Source code in dspy/adapters/types/code.py

@pydantic.model_validator(mode="before")
@classmethod
def validate_input(cls, data: Any):
    if isinstance(data, cls):
        return data

    if isinstance(data, str):
        return {"code": _filter_code(data)}

    if isinstance(data, dict):
        if "code" not in data:
            raise ValueError("`code` field is required for `dspy.Code`")
        if not isinstance(data["code"], str):
            raise ValueError(f"`code` field must be a string, but received type: {type(data['code'])}")
        return {"code": _filter_code(data["code"])}

    raise ValueError(f"Received invalid value for `dspy.Code`: {data}")

:::