Interop with DSPy

[AntonLobach]

Hello,

I’m in the process of converting some DSPy code and currently working with the Signature class.

For example:

class Emotion(dspy.Signature):
    """Classify emotion."""

    sentence: str = dspy.InputField()
    sentiment: Literal['sadness', 'joy', 'love', 'anger', 'fear', 'surprise'] = dspy.OutputField()

Since DSPy aims to abstract manual prompting, everything in the class above is used as context for the LLM. That is:

The docstring is required, it provides semantic meaning that the LLM relies on.

The actual names sentence and sentiment and the type hints convey semantic meaning to the LLM about the expected input and output.

What I was able to come up with so far:

(ns dspytest.core
  (:import
   dspy
   [typing :refer [Literal]]))

(def SentimentLiteral
  (aget Literal #py ("sadness" "joy" "love" "anger" "fear" "surprise")))

;; Define the Emotion class using deftype with type hints
(def Emotion
  (python/type "Emotion"
               #py (dspy/Signature)
               #py {"__doc__" "Classify emotion."
                    "__annotations__" {"sentence" python/str
                                       "sentiment" SentimentLiteral}
                    "sentence" (dspy/InputField ** :desc "Input sentence")
                    "sentiment" (dspy/OutputField ** :desc "Sentence sentiment")}))

(def sentence
  "I started feeling so good")

(def classify (dspy/Predict Emotion))

(classify ** :sentence sentence)

It works but is there a more idiomatic/elegant way of writing that code in Basilisp?

Is there any way of inspecting generated Python AST from the REPL something akin to CL's disassemble?