Téléchargement prompt template - Téléchargement du code source prompt template

Modèle invite

Une bibliothèque Python légère et zéro dépendance pour gérer les modèles d'invite LLM. Construit sur les principes de conception de string.Template mais avec des fonctionnalités améliorées spécialement conçues pour l'ingénierie invite LLM.

Caractéristiques

Validation de modèle forte avec des messages d'erreur détaillés
Support aux accolades imbriquées et aux structures JSON complexes
Sérialisation de valeur automatique pour les types de python communs
Prise en charge de la valeur par défaut avec une copie profonde pour les types mutables
Population de modèles incrémentiels avec héritage de valeur
Type Indices pour un support IDE amélioré
Zéro dépendances - juste pur python
Couverture de test à 100%

Installation

pip install prompt-template

Usage

La bibliothèque est intentionnellement très simple à utiliser. L'idée est de garder les choses simples, de faire la validation et de sérialiser intégrée et de faciliter le débogage.

Modèles 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.

Valeurs par défaut

 # 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"}

Modèles nommés

L'ajout d'un nom à votre modèle améliore les messages d'erreur avec le contexte:

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

Modèles JSON complexes

La bibliothèque gère les structures imbriquées avec élégance:

 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" ]
)

Population de modèles incrémentiels

Vous pouvez construire des modèles progressivement, en préservant les défauts en cours de route:

 # 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" )

Type de traitement et sérialisation automatique

La bibliothèque gère automatiquement divers types 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 ]
    }
)

Sérialisation personnalisée

Étendre la classe de base pour personnaliser la sérialisation de la valeur:

 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.

Gestion des erreurs

La bibliothèque fournit des erreurs étendues spécifiques:

Valeurs manquantes

 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'}

Clés non valides

 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'}

Erreurs de sérialisation

 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 } " )