prompt template

Plantilla de inmediato

Una biblioteca Python liviana y dependencia de cero para administrar plantillas de inmediato LLM. Construido sobre los principios de diseño de string.Template pero con características mejoradas diseñadas específicamente para la ingeniería de inmediato LLM.

Características

• Validación de plantilla sólida con mensajes de error detallados
• Soporte para aparatos urbanos y estructuras JSON complejas
• Serialización del valor automático para tipos comunes de pitón
• Soporte de valor predeterminado con copia profunda para tipos mutables
• Plantilla incremental población con herencia de valor
• Escriba sugerencias para un soporte IDE mejorado
• Dependencias cero: solo Python pura
• Cobertura de prueba 100%

Instalación

pip install prompt-template

Uso

La biblioteca es intencionalmente muy simple de usar. La idea es mantenerlo simple, construir validación y serialización, y simplificar la depuración.

Plantillas simples

 from prompt_template import PromptTemplate

# Create a template
template = PromptTemplate ( "Hello ${name}! Welcome to ${location}." )

# Render with values
result = template . to_string ( name = "Alice" , location = "Wonderland" )
print ( result )  # Hello Alice! Welcome to Wonderland.

Valores predeterminados

 # Set default values that can be overridden later
template = PromptTemplate ( "Hello ${name}! Your settings are: ${settings}" )

# Set default values - they're safely deep copied
template . set_default (
    name = "Guest" ,
    settings = { "theme" : "light" , "language" : "en" }
)

# Use with defaults
print ( template . to_string ())
# Hello Guest! Your settings are: {"theme": "light", "language": "en"}

# Override specific values
print ( template . to_string ( name = "Alice" ))
# Hello Alice! Your settings are: {"theme": "light", "language": "en"}

# Override everything
print ( template . to_string (
    name = "Bob" ,
    settings = { "theme" : "dark" , "language" : "fr" }
))
# Hello Bob! Your settings are: {"theme": "dark", "language": "fr"}

Plantillas con nombre

Agregar un nombre a su plantilla mejora los mensajes de error con el contexto:

 template = PromptTemplate (
    name = "user_greeting" ,
    template = "Hello ${name}! Welcome to ${location}."
)

Plantillas json complejas

La biblioteca maneja estructuras anidadas elegantemente:

 template = PromptTemplate ( """
{
    "user": {
        "name": "${username}",
        "role": "${role}"
    },
    "settings": {
        "theme": "${theme}",
        "notifications": ${notifications},
        "preferences": ${preferences}
    }
}
""" )

# Values are automatically serialized
result = template . to_string (
    username = "john_doe" ,
    role = "admin" ,
    theme = "dark" ,
    notifications = { "email" : True , "push" : False },
    preferences = [ "daily_digest" , "weekly_report" ]
)

Población de plantillas incrementales

Puede construir plantillas de forma incremental, preservando los valores predeterminados en el camino:

 # Start with a base template
base = PromptTemplate ( """
Query parameters:
    Model: ${model}
    Temperature: ${temperature}
    User: ${user}
    Prompt: ${prompt}
""" )

# Set some defaults
base . set_default (
    model = "gpt-4" ,
    temperature = 0.7
)

# Create a partially populated template
user_template = base . substitute ( user = "alice" )

# Complete the template later
final = user_template . to_string ( prompt = "Tell me a story" )

Tipo de manejo y serialización automática

La biblioteca maneja automáticamente varios tipos de Python:

 from uuid import UUID
from decimal import Decimal
from datetime import datetime

template = PromptTemplate ( """
{
    "id": "${id}",
    "amount": "${amount}",
    "binary": "${binary_data}",
    "metadata": ${metadata}
}
""" )

result = template . to_string (
    id = UUID ( "550e8400-e29b-41d4-a716-446655440000" ),
    amount = Decimal ( "45.67" ),
    binary_data = b"Hello World" ,  # Automatically base64 encoded if needed
    metadata = {
        "timestamp" : datetime . now (),  # Serialized via JSON
        "values" : [ 1 , 2 , 3 ]
    }
)

Serialización personalizada

Extienda la clase base para personalizar la serialización del valor:

 from typing import Any
from datetime import datetime
from prompt_template import PromptTemplate as BasePromptTemplate
import orjson


class PromptTemplate ( BasePromptTemplate ):
    @ staticmethod
    def serializer ( value : Any ) -> str :
        return orjson . dumps ( value )  # use orjson for faster json serialization etc. 

Manejo de errores

La biblioteca proporciona errores extensos específicos:

Valores faltantes

 from prompt_template import MissingTemplateValuesError

template = PromptTemplate ( "Hello ${name}!" )
try :
    template . to_string ()  # No values provided
except MissingTemplateValuesError as e :
    print ( f"Missing values: { e . missing_values } " )  # {'name'}

Llaves no válidas

 from prompt_template import InvalidTemplateKeysError

template = PromptTemplate ( "Hello ${name}!" )
try :
    template . to_string ( name = "World" , invalid_key = "value" )
except InvalidTemplateKeysError as e :
    print ( f"Invalid keys: { e . invalid_keys } " )  # ['invalid_key']
    print ( f"Valid keys: { e . valid_keys } " )  # {'name'}

Errores de serialización

 from prompt_template import TemplateSerializationError

template = PromptTemplate ( "Value: ${value}" )
try :
    template . to_string ( value = object ())  # Non-serializable object
except TemplateSerializationError as e :
    print ( f"Failed to serialize key ' { e . key } ': { e . original_error } " )

Licencia

Licencia de MIT

---

Si encuentra útil la biblioteca, estre de GitHub.