peewee Python ((Comment ça fonctionne : Un guide pour les développeurs))

Introduction

Peewee est un petit, expressifORMqui vise à faciliter l'interaction avec la base de données en Python. Il est léger, facile à utiliser et suffisamment fiable pour prendre en charge des requêtes complexes ou des schémas de base de données. Peewee prend en charge SQLite, MySQL et PostgreSQL avec une syntaxe intuitive, ce qui le rend très facile à apprendre, et donc très populaire parmi les étudiants et les professionnels.

IronPDF est une bibliothèque Python qui permet un travail complet, de bout en bout, avec les documents PDF : créer, lire, éditer et gérer. En utilisant Python .NET, on peut utiliser IronPDF avec des applications Python, ce qui permet de tirer parti de capacités très puissantes de génération de PDF. Cette combinaison est donc très utile pour générer des rapports PDF basés sur des données extraites des bases de données.

Cette intégration associe Peewee à IronPDF pour la création d'applications par les développeurs Python, permettant ainsi une gestion et une interrogation efficaces des bases de données, en plus de la génération de documents PDF dynamiques et axés sur les données. Cette combinaison prépare un flux de travail parfait allant de la récupération des données à la génération de rapports et offre ainsi un ensemble d'outils très puissants pour créer une documentation professionnelle et automatisée. En commençant par des rapports commerciaux simples comme les factures, et en allant jusqu'aux rapports complexes, Peewee et IronPDF ensemble fournissent une solution parfaite pour la génération de PDF basée sur des bases de données dans n'importe quelle application Python.

Qu'est-ce que PeeWee Python ?

Peeweeest un petit ORM expressif pour Python qui facilite le travail avec une base de données. Il crée des modèles facilement et simplifie la création de requêtes courantes telles que la recherche, l'ajout, la mise à jour et la suppression de plusieurs enregistrements dans la base de données. Peewee pourrait être utilisé dans de nombreux cas d'utilisation différents, la raison étant qu'il prend en charge différents backends : SQLite, MySQL et PostgreSQL.

Ce qui est appréciable chez Peewee, c'est sa simplicité et sa facilité d'utilisation. Il est très facile pour un développeur de créer des modèles en tant que classes en Python, tandis que toutes les requêtes contre la base de données sont effectuées en tant que code Python grâce à une API simple. Malgré cette simplicité, Peewee est très puissant puisqu'il prend en charge des requêtes complexes, des jointures, et des relations complexes, et prend en charge le pooling de connexions.

La flexibilité et le design minimaliste rendent Peewee très utile pour les petits projets et les applications plus importantes où la facilité d'utilisation et le développement rapide deviennent primordiaux. Gérer des interactions complexes avec des bases de données avec très peu de code standardisé en a fait un ORM attrayant pour tout développeur Python.

Fonctionnalités de Peewee Python

Peewee est une bibliothèque ORM légère et expressive pour Python, permettant d'interagir facilement avec la base de données. Un certain nombre de ses fonctionnalités importantes sont énumérées ci-dessous :

Facile et Simple : Peewee possède une API très facile et intuitive à exposer. Les développeurs peuvent définir des modèles avec tous leurs attributs normaux sans aucune difficulté en l'utilisant et interagir facilement avec la base de données en utilisant du code Python.

Bases de données multiples : Il prend en charge SQLite, MySQL, PostgreSQL et CockroachDB.

Syntaxe de requête expressive : Peewee dispose d'une syntaxe claire et expressive pour interroger les bases de données, nous pouvons utiliser les mêmes opérations de requête comme Sélectionner, Créer, Mettre à jour, et une requête de suppression permettant aux développeurs d'écrire des requêtes complexes en utilisant des structures inspirées de Python.

Définition de modèle: On définit les modèles de base de données comme des classes Python dans Peewee. Les champs de la classe correspondent aux colonnes de la base de données. Cette définition garantit que si l'on effectue une modification quelconque dans le schéma de la base de données, des changements équivalents sont apportés au code Python, et vice versa.

Relations : Il prend en charge toutes les relations, y compris les clés étrangères, les relations un-à-un et plusieurs-à-plusieurs, nécessaires à la modélisation de données complexes.

Connection Pooling : Peewee est équipé d'un pooling de connexions intégré pour améliorer les performances grâce à la réutilisation des connexions à la base de données.

Transactions : Les transactions atomiques garantissent qu'un ensemble d'opérations de base de données est exécuté - mais si l'une d'elles échoue, toutes sont annulées pour maintenir la validité de vos données.

Signaux et hooks : Peewee fournit des signaux et des hooks pour implémenter un comportement personnalisé avant ou après certains événements, comme l'enregistrement ou la suppression d'un enregistrement.

Migrations : De plus, cela intègre des bibliothèques tierces avec la principale, Peewee-migrate, et gère ainsi les migrations de schéma de base de données. Cela aidera à une transition en douceur des versions d'une base de données.

Extensibilité : Peewee peut être facilement étendu par des champs personnalisés, des requêtes ou quelques autres fonctionnalités selon les besoins concrets de l'application.

Extensions Playhouse : Ce module est fourni avec une variété d'extensions pour le playhouse, y compris la recherche en texte intégral pour SQLite, quelques fonctionnalités spécifiques à PostgreSQL et quelques outils pour gérer les connexions.

Support asynchrone : aiopeewee est une extension qui permet à Peewee de prendre en charge les opérations asynchrones adaptées aux applications à haute performance.

Créer et configurer Peewee

Les étapes suivantes vous aident à démarrer avec Peewee dans tout projet Python, en configurant une application simple en utilisant Peewee ORM.

Installer Peewee

Tout d'abord, installez Peewee en utilisant pip :

pip install peewee

pip install peewee

Définir vos modèles

Assurez-vous de définir vos modèles de base de données dans un fichier Python appelé app.py. Ici, nous ferons la même chose pour plus de simplicité, en utilisant 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])

Insérer des données

Ajoutons maintenant des données à notre base de données.

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()

Requêter des données

Maintenant, construisons un code pour extraire toutes ces informations de notre base de données.

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()

Ci-dessous se trouve la capture d'écran combinée de tous les codes ci-dessus.

Pour commencer

Tout d'abord, vous devrez importer Peewee pour les fonctionnalités associées à la cartographie objet-relationnelle, et IronPDF pour la génération de PDF. Ce tutoriel suppose que vous avez déjà des connaissances en Python et que vous savez comment configurer IronPDF pour fonctionner en Python via Python .NET et Peewee. Les étapes suivantes vous guideront pour créer une application simple utilisant Peewee pour interagir avec une base de données, et IronPDF sera utilisé pour générer un rapport PDF.

Qu'est-ce qu'IronPDF ?

LesIronPDFLe module Python est une bibliothèque avancée pour créer, modifier et lire des fichiers PDF. Il offre un grand nombre de fonctionnalités permettant aux programmeurs d'effectuer de nombreuses activités programmables avec des PDFs. Cela inclut la conversion des fichiers HTML en fichiers PDF dans le but de modifier des PDF existants. Cela le rendra plus flexible et facilitera la génération de rapports de grande qualité au format PDF. Les programmes générant et traitant des PDF de manière dynamique peuvent en profiter.

Conversion de HTML en PDF

Toutes les données HTML, datées à tout moment, peuvent être facilement converties en un document PDF grâce aux capacités d'IronPDF. Il offre en outre à l'utilisateur une plateforme pour créer des publications PDF extrêmement innovantes et captivantes directement à partir de matériel en ligne, tout en utilisant toutes les capacités les plus récentes de HTML5, CSS3 et JavaScript.

Générer et éditer des PDF

Vous pourriez générer de nouveaux documents PDF avec du texte, des images, des tableaux, etc., même avec l'aide d'un langage de programmation. Vous êtes autorisé à ouvrir des documents préparés à l'avance et à les modifier en utilisant IronPDF, en ajoutant des personnalisations supplémentaires. Les contenus d'un document PDF peuvent être ajoutés, modifiés ou supprimés à tout moment.

Conception et style complexes

Étant donné qu'il possède un style de contenu inhérent pour les fichiers PDF, des mises en page complexes peuvent être contrôlées avec plusieurs polices, couleurs et autres éléments de conception qui rendent cela possible. De plus, JavaScript ne peut pas être appliqué pour gérer le contenu dynamique dans les PDFs afin de permettre un rendu facile du contenu HTML.

Installer IronPDF

IronPDF peut être installé en utilisant Pip. La commande d'installation sera comme indiqué ci-dessous :

pip install ironpdf

pip install ironpdf

Combinez Peewee avec IronPDF

Le Peewee ORM peut être créé et configuré, les données peuvent être insérées, et des rapports PDF peuvent être produits en combinant toutes les étapes dans le fichier 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()

Ce code montre comment utiliser Python .NET pour combiner IronPDF, une bibliothèque Python pour la création de PDF, avec Peewee, un ORM léger pour Python. En utilisant Peewee, il crée d'abord une base de données SQLite et définit les modèles User et Tweet avec les champs appropriés. Après la création des tables de la base de données, des données d'exemple y sont ajoutées. Ensuite, en utilisant la classe ChromePdfRenderer de IronPDF, la fonction generate_pdf récupère ces données et les transforme en une chaîne HTML qui est ensuite rendue sous forme de PDF.

Le répertoire de travail actuel est l'endroit où le PDF est stocké. Utiliser les avantages de Peewee pour l'administration de base de données et IronPDF pour produire des documents polisDocuments PDF, cette configuration permet des interactions fluides avec la base de données et la sortie automatisée de rapports PDF au sein d'une application Python.

Conclusion

Cela fournira une option fiable pour les développeurs Python cherchant à gérer des bases de données et à générer des documents PDF dynamiques une fois qu'IronPDF sera intégré dans Peewee. Avec les fonctionnalités ORM faciles à utiliser, les interactions avec la base de données sont simplifiées dans Peewee, permettant à un développeur de construire et de modifier les schémas de base de données avec beaucoup de facilité. D'autre part, IronPDF dispose d'un package qui facilite la traduction de contenu HTML en rapports PDF de qualité.

Cette combinaison sera donc très utile dans les applications qui génèrent des rapports automatiques en utilisant des données dynamiques récupérées à partir de bases de données. Les développeurs peuvent tirer parti de la facilité avec laquelle il est possible de définir des modèles et d'exécuter des requêtes avec Peewee, et de la puissance d'IronPDF pour créer des PDF, afin d'améliorer efficacement l'efficacité et la productivité. Peewee et IronPDF, en tant que combinaison, se transforment en manipulations flexibles et efficaces pour répondre à un large éventail de besoins applicatifs de diverses manières au sein de l'univers de développement Python. Cela peut aller de la facturation aux rapports sur des documents spéciaux.

CombinaisonIronPDFavec d'autresIron Softwareles produits aideront à offrir aux clients des solutions logicielles supérieures qui proposent des solutions complexes aux utilisateurs. Cela va, pour votre bien, simplifier la tâche d'amélioration des opérations de projets et des procédures en général.

Outre les fonctionnalités de base, il existe une documentation détaillée, une communauté active et un cycle de mises à jour régulières pour IronPDF. Sur la base des informations ci-dessus des paragraphes précédents, un développeur peut considérer Iron Software comme un partenaire fiable pour les projets de développement logiciel moderne. Pour découvrir toutes les fonctionnalités de cette bibliothèque, IronPDF propose un essai gratuit pour un développeur. Dans les jours à venir, vous vous assurerez de tirer pleinement parti des 749 $ dépensés pour les frais de licence.