peewee Python (Cómo funciona: una guía para desarrolladores)

Introducción

Peewee es un micro y expresivoORMque tiene como objetivo facilitar la interacción con la base de datos en Python. Es ligero, fácil de usar y lo suficientemente confiable para soportar consultas complejas o esquemas de base de datos. Peewee es compatible con SQLite, MySQL y PostgreSQL con una sintaxis intuitiva, lo que lo hace muy fácil de aprender, convirtiéndose así en muy popular entre estudiantes y profesionales.

IronPDF es una biblioteca de Python que permite el trabajo completo, de extremo a extremo, con documentos PDF: crear, leer, editar y gestionar. Usando Python .NET, uno puede utilizar IronPDF con aplicaciones Python, derivando así capacidades muy fuertes de generación de PDF. Esta combinación es, por lo tanto, muy útil para generar informes PDF basados en datos recuperados de bases de datos.

Esta integración combina Peewee con IronPDF para la creación de aplicaciones por desarrolladores de Python de tal manera que la gestión eficiente de bases de datos y consultas sea posible junto con la generación de documentos PDF dinámicos y basados en datos. Esta combinación prepara un flujo de trabajo perfecto desde la recuperación de datos hasta la generación de informes y, por lo tanto, ofrece un conjunto de herramientas muy sólidas para crear documentación profesional y automatizada. Comenzando con informes comerciales simples como facturas, y pasando por informes complejos, Peewee e IronPDF juntos proporcionan una solución impecable para la generación de PDFs impulsada por bases de datos en cualquier aplicación Python.

¿Qué es PeeWee Python?

Peeweees un ORM pequeño y expresivo para Python que facilita el trabajo con una base de datos. Crea modelos fácilmente y facilita la creación de consultas comunes como buscar, agregar, actualizar y eliminar múltiples registros en la base de datos. Peewee podría utilizarse en muchos casos diferentes, la razón es que admite diferentes backends: SQLite, MySQL y PostgreSQL.

Algo que gusta de Peewee es su simplicidad y facilidad. Es muy fácil para un desarrollador crear modelos como clases en Python, mientras que todas las consultas contra la base de datos se realizan como código Python gracias a una API sencilla. A pesar de esta simplicidad, Peewee es muy poderoso ya que tiene soporte para consultas complicadas, combinaciones y relaciones complejas, y admite agrupamiento de conexiones.

La flexibilidad y el diseño minimalista hacen que Peewee sea bastante útil para proyectos pequeños y aplicaciones más grandes donde la facilidad de uso y el desarrollo rápido se vuelven primordiales. Manejar interacciones complejas con bases de datos con muy poco código estándar lo ha convertido en un ORM atractivo para cualquier desarrollador de Python.

Características de Peewee Python

Peewee es una biblioteca ORM ligera y expresiva para Python que permite interactuar fácilmente con la base de datos. Se enumeran a continuación algunas de sus características importantes:

Fácil y sencillo: Peewee tiene una API muy fácil e intuitiva de exponer. Los desarrolladores pueden definir modelos con todos sus atributos normales sin ningún problema usándolo e interactuar con la base de datos utilizando código Python fácilmente.

Múltiples bases de datos: Admite SQLite, MySQL, PostgreSQL y CockroachDB.

Sintaxis de Consulta Expresiva: Peewee tiene una sintaxis limpia y expresiva para consultar bases de datos. Podemos usar las mismas operaciones de consulta como Select, Create, Update y una consulta de delete, lo que permite a los desarrolladores escribir consultas complejas utilizando construcciones Pythónicas.

Definición del modelo: Se definen los modelos de la base de datos como clases de Python en Peewee. Los campos de la clase coinciden con las columnas de la base de datos. Esta definición garantiza que si se realiza algún tipo de cambio en el esquema de la base de datos, se hagan cambios equivalentes en el código de Python, y viceversa.

Relaciones: Soporta todas las relaciones, incluidas claves foráneas, relaciones uno a uno y de muchos a muchos, necesarias para modelar datos complejos.

Agrupamiento de Conexiones: Peewee viene con agrupamiento de conexiones integrado para mejorar el rendimiento mediante la reutilización de conexiones de base de datos.

Transacciones: Las transacciones atómicas aseguran que se ejecute un conjunto de operaciones de base de datos, pero en caso de que alguna falle, todas se revierten para mantener la validez de sus datos.

Señales y Hooks: Peewee proporciona señales y hooks para implementar comportamientos personalizados antes o después de algunos eventos, como guardar o eliminar un registro.

Migraciones: Además, esto integra bibliotecas de terceros con la principal, Peewee-migrate, y de esta manera gestiona las migraciones de esquemas de base de datos. Esto ayudará en la transición fluida de las versiones de una base de datos.

Extensibilidad: Peewee se puede extender fácilmente mediante campos personalizados, consultas u otras características según las necesidades específicas de la aplicación.

Extensiones de Playhouse: Este módulo viene con una variedad de extensiones para el playhouse, incluyendo búsqueda de texto completo para SQLite, algunas funciones específicas de PostgreSQL, y algunas herramientas para gestionar conexiones.

Soporte Asíncrono: aiopeewee es una extensión que permite a Peewee soportar operaciones asíncronas adecuadas para Aplicaciones de Alto Rendimiento.

Crear y Configurar Peewee

Los siguientes pasos te ayudan a comenzar con Peewee en cualquier proyecto de Python, configurando una aplicación simple utilizando Peewee ORM.

Instalar Peewee

Primero, instala Peewee usando pip:

pip install peewee

pip install peewee

Define tus modelos

Asegúrate de definir tus modelos de base de datos en un archivo Python llamado app.py. Aquí, haremos lo mismo por simplicidad, usando SQLite.

from peewee import SqliteDatabase, Model, CharField, IntegerField, ForeignKeyField
# Define the database connection
db = SqliteDatabase('my_database.db')
# Define a base model class
class BaseModel(Model):
    class Meta:
        database = db
# Define a User model
class User(BaseModel):
    username = CharField(unique=True)
    age = IntegerField()
# Define a model instance programmatically or we can define foreign or primary key
class Tweet(BaseModel):
    user = ForeignKeyField(User, backref='tweets')
    content = CharField()
# Create the tables
db.connect()
db.create_tables([User, Tweet])

from peewee import SqliteDatabase, Model, CharField, IntegerField, ForeignKeyField
# Define the database connection
db = SqliteDatabase('my_database.db')
# Define a base model class
class BaseModel(Model):
    class Meta:
        database = db
# Define a User model
class User(BaseModel):
    username = CharField(unique=True)
    age = IntegerField()
# Define a model instance programmatically or we can define foreign or primary key
class Tweet(BaseModel):
    user = ForeignKeyField(User, backref='tweets')
    content = CharField()
# Create the tables
db.connect()
db.create_tables([User, Tweet])

Insertar datos

Ahora agreguemos algunos datos a nuestra base de datos.

def insert_data():
    # Insert a new user
    alice = User.create(username='Alice', age=30)
    # Insert some tweets for Alice
    Tweet.create(user=alice, content='Hello world!')
    Tweet.create(user=alice, content='I love Peewee!')
    bob = User.create(username='Bob', age=25)
    Tweet.create(user=bob, content='This is Bob')
insert_data()

def insert_data():
    # Insert a new user
    alice = User.create(username='Alice', age=30)
    # Insert some tweets for Alice
    Tweet.create(user=alice, content='Hello world!')
    Tweet.create(user=alice, content='I love Peewee!')
    bob = User.create(username='Bob', age=25)
    Tweet.create(user=bob, content='This is Bob')
insert_data()

Consultar datos

Ahora, construyamos un código para extraer toda esta información de nuestra base de datos.

def query_data():
    # Query to select multiple records
    for user in User.select():
        print(f'User: {user.username}, Age: {user.age}')
    # instance matching query
    for tweet in Tweet.select().join(User).where(User.username == 'Alice'):
        print(f'{tweet.user.username} tweeted: {tweet.content}')
query_data()

def query_data():
    # Query to select multiple records
    for user in User.select():
        print(f'User: {user.username}, Age: {user.age}')
    # instance matching query
    for tweet in Tweet.select().join(User).where(User.username == 'Alice'):
        print(f'{tweet.user.username} tweeted: {tweet.content}')
query_data()

A continuación se muestra la captura de pantalla combinada de todos los códigos anteriores.

Para empezar

En primer lugar, necesitarás importar Peewee para las características asociadas con el Mapeo Objeto-Relacional y IronPDF para la generación de PDFs. Este tutorial supone que ya tienes conocimiento de Python y cómo configurar IronPDF para trabajar en Python a través de Python .NET y Peewee. Los siguientes pasos lo guiarán a través de cómo crear una aplicación simple usando Peewee para interactuar con una base de datos, y se utilizará IronPDF para generar un informe en PDF.

¿Qué es IronPDF?

EnIronPDFEl módulo de Python es una biblioteca avanzada para crear, editar y leer PDF. Ofrece una gran cantidad de funcionalidades para que los programadores puedan realizar muchas actividades programables con PDFs. Esto incluye convertir archivos HTML a archivos PDF con el fin de editar PDFs existentes. Eso lo hará más flexible y más fácil para generar excelentes informes en formato PDF. Los programas que generan y procesan PDFs dinámicamente pueden aprovechar esto.

Conversión de HTML a PDF

Cualquier dato HTML, fechado en cualquier momento, podría ser fácilmente convertido a un documento PDF con las capacidades de IronPDF. Además, proporciona una plataforma al usuario para crear publicaciones PDF extremadamente innovadoras y llamativas directamente a partir del material en línea, utilizando todas las capacidades más recientes de HTML5, CSS3 y JavaScript.

Generar y editar PDF

Puedes generar nuevos documentos PDF con texto, imágenes, tablas, etc., incluso con la ayuda de un lenguaje de programación. Se le permite abrir documentos preparados con anticipación y editarlos utilizando IronPDF, añadiendo una mayor personalización. Cualquier contenido de un documento PDF puede añadirse, cambiarse o eliminarse en cualquier momento.

Diseño y estilo complejo

Dado que tiene un estilo de contenido para archivos PDF de manera inherente, se pueden controlar diseños complejos con varias fuentes, colores y otros elementos de diseño que hacen esto posible. Además, no se puede aplicar JavaScript para manejar material dinámico en archivos PDF para permitir la fácil renderización de contenido HTML.

Instalar IronPDF

IronPDF se puede instalar utilizando Pip. El comando de instalación se muestra a continuación:

pip install ironpdf

pip install ironpdf

Combina Peewee con IronPDF

El ORM Peewee puede ser creado y configurado, se pueden insertar datos y se pueden producir informes en PDF combinando todas las etapas en el archivo app.py.

from peewee import SqliteDatabase, Model, CharField, IntegerField, ForeignKeyField
import os
from ironpdf import *     import warnings
warnings.filterwarnings('ignore')
License.LicenseKey = "";
# Define the database connection
db = SqliteDatabase('my_database.db')
# Define a base model class
class BaseModel(Model):
# class Meta
    class Meta:
        database = db
#creating single model instance
class User(BaseModel):
    username = CharField(unique=True)
    age = IntegerField()
# Define a Tweet model
class Tweet(BaseModel):
    user = ForeignKeyField(User, backref='tweets')
    content = CharField()
# Create the tables
db.connect()
db.create_tables([User, Tweet])
def insert_data():
    # Insert a new user
    alice = User.create(username='Alice', age=30)
    # Insert some tweets for Alice
    Tweet.create(user=alice, content='Hello world!')
    Tweet.create(user=alice, content='I love Peewee!')
    bob = User.create(username='Bob', age=25)
    Tweet.create(user=bob, content='This is Bob')
def generate_pdf():
    # model SQL query to fetch data from the database
    users = User.select()
    tweets = Tweet.select().join(User)
    # Prepare HTML content for the PDF
    html_content = """
    <html>
    <head><title>Data Report</title></head>
    <body>
        <h1>User Data Report</h1>
        <h2>Users</h2>
        <ul>
    """
    for user in users:
        html_content += f"<li>{user.username}, Age: {user.age}</li>"
    html_content += "</ul><h2>Tweets</h2><ul>"
    for tweet in tweets:
        html_content += f"<li>{tweet.user.username} tweeted: {tweet.content}</li>"
    html_content += "</ul></body></html>"
    # Create a PDF document using IronPDF
    renderer = ChromePdfRenderer()
    pdf = renderer.RenderHtmlAsPdf(html_content)
    # Save the PDF file
    output_path = os.path.join(os.getcwd(), "Data_Report.pdf")
    pdf.SaveAs(output_path)
    print(f"PDF Report saved to {output_path}")
if __name__ == '__main__':
    insert_data()
    generate_pdf()

from peewee import SqliteDatabase, Model, CharField, IntegerField, ForeignKeyField
import os
from ironpdf import *     import warnings
warnings.filterwarnings('ignore')
License.LicenseKey = "";
# Define the database connection
db = SqliteDatabase('my_database.db')
# Define a base model class
class BaseModel(Model):
# class Meta
    class Meta:
        database = db
#creating single model instance
class User(BaseModel):
    username = CharField(unique=True)
    age = IntegerField()
# Define a Tweet model
class Tweet(BaseModel):
    user = ForeignKeyField(User, backref='tweets')
    content = CharField()
# Create the tables
db.connect()
db.create_tables([User, Tweet])
def insert_data():
    # Insert a new user
    alice = User.create(username='Alice', age=30)
    # Insert some tweets for Alice
    Tweet.create(user=alice, content='Hello world!')
    Tweet.create(user=alice, content='I love Peewee!')
    bob = User.create(username='Bob', age=25)
    Tweet.create(user=bob, content='This is Bob')
def generate_pdf():
    # model SQL query to fetch data from the database
    users = User.select()
    tweets = Tweet.select().join(User)
    # Prepare HTML content for the PDF
    html_content = """
    <html>
    <head><title>Data Report</title></head>
    <body>
        <h1>User Data Report</h1>
        <h2>Users</h2>
        <ul>
    """
    for user in users:
        html_content += f"<li>{user.username}, Age: {user.age}</li>"
    html_content += "</ul><h2>Tweets</h2><ul>"
    for tweet in tweets:
        html_content += f"<li>{tweet.user.username} tweeted: {tweet.content}</li>"
    html_content += "</ul></body></html>"
    # Create a PDF document using IronPDF
    renderer = ChromePdfRenderer()
    pdf = renderer.RenderHtmlAsPdf(html_content)
    # Save the PDF file
    output_path = os.path.join(os.getcwd(), "Data_Report.pdf")
    pdf.SaveAs(output_path)
    print(f"PDF Report saved to {output_path}")
if __name__ == '__main__':
    insert_data()
    generate_pdf()

Este código muestra cómo usar Python .NET para combinar IronPDF, una biblioteca de Python para la creación de PDF, con Peewee, un ORM ligero para Python. Usando Peewee, primero crea una base de datos SQLite y define los modelos User y Tweet con los campos apropiados. Después de crear las tablas de la base de datos, se les añade datos de ejemplo. Luego, utilizando la clase ChromePdfRenderer de IronPDF, la función generate_pdf recupera estos datos y los transforma en una cadena HTML que luego se renderiza como un PDF.

El directorio de trabajo actual es donde se almacena el PDF. Usando las ventajas de Peewee para la administración de bases de datos e IronPDF para producir contenido pulidoDocumentos PDF, esta configuración permite interacciones fluidas con la base de datos y la generación automatizada de informes PDF dentro de una aplicación de Python.

Conclusión

Esto proporcionará una opción confiable para los desarrolladores de Python que buscan gestionar bases de datos y generar documentos PDF dinámicos una vez que IronPDF esté integrado en Peewee. Con las funciones ORM fáciles de usar, las interacciones con la base de datos se simplifican en Peewee, permitiendo a un desarrollador construir y modificar esquemas de bases de datos con mucha facilidad. Por otro lado, IronPDF tiene un paquete que facilita la traducción de contenido HTML a informes PDF de calidad.

Esta combinación será por lo tanto muy útil en aplicaciones que generan informes automáticos utilizando datos dinámicos recuperados de bases de datos. Los desarrolladores pueden aprovechar lo fácil que es definir modelos y ejecutar consultas con Peewee, y cómo IronPDF crea PDF de manera poderosa, para mejorar eficazmente la eficiencia y la productividad. Peewee e IronPDF, como combinación, se convierten en herramientas flexibles y efectivas para satisfacer una amplia variedad de necesidades de aplicaciones de diversas formas dentro del universo del desarrollo en Python. Estos pueden variar desde la facturación hasta los informes sobre documentos especiales.

Combinación deIronPDFcon otrosIron Softwarelos productos ayudarán a ofrecer soluciones de software superiores a los clientes que ofrecen soluciones complejas a los usuarios. Esto, para su beneficio, simplificará la tarea de mejorar las operaciones de proyectos y procedimientos en general.

Además de las funciones principales, hay documentación detallada, una comunidad activa y un ciclo regular de actualizaciones para IronPDF. Basado en la información anterior de los párrafos previos, un desarrollador puede considerar a Iron Software como un socio confiable para proyectos de desarrollo de software moderno. Para conocer todas las características de esta biblioteca, IronPDF ofrece una prueba gratuita para un desarrollador. En los próximos días, se asegurará de obtener el valor total por los $749 gastados en la tarifa de la licencia.