Forem: Efe Omoregie

Generating PDF files with Python

Efe Omoregie — Sat, 01 Nov 2025 11:08:38 +0000

Python, with its extensive collection of libraries, provides powerful tools to create PDF files dynamically. This blog post will explore some of the most popular Python libraries for PDF generation, provide insights into their strengths and help you select the best tool for your project.

Why Automate PDF Generation?

Automating PDF creation can streamline numerous business processes. Here are a few common applications:

Invoice Generation: Automatically create and send invoices to clients.
Reporting: Generate daily, weekly, or monthly reports from various data sources.
E-commerce: Produce order confirmations, shipping labels, and product catalogues.
Data Visualisation: Save plots and charts from libraries like Matplotlib as PDF files.

Top Python Libraries for PDF Generation

Several Python libraries are available for creating PDFs, each with unique features and use cases. Let's explore three of the most popular options: ReportLab, FPDF2, and WeasyPrint.

1. ReportLab

ReportLab is one of the most established Python libraries for generating PDFs. It offers a powerful, low-level API for drawing text, graphics, and images directly onto a PDF canvas. For more complex documents, ReportLab provides a high-level templating language.

Key Features:

Extensive capabilities for creating complex and customised PDFs.
Support for tables, graphs, and various graphic elements.
Cross-platform compatibility.
Both open-source and commercial versions are available.

Installation:

pip install reportlab

Simple Example:

from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import letter

c = canvas.Canvas("reportlab_example.pdf", pagesize=letter)
c.drawString(72, 800, "Hello, ReportLab!")
c.save()

This code snippet creates a PDF named "reportlab_example.pdf" and draws the string "Hello, ReportLab!" at a specified coordinate on the page.

2. FPDF2

FPDF2 is a popular choice for developers looking for a straightforward and easy-to-use library. It is a port of the FPDF library from PHP and is known for its minimalist design and lack of dependencies.

Key Features:

Simple and intuitive API, making it easy to learn.
Support for headers, footers, and automatic page breaks.
Basic HTML rendering capabilities.
Ability to add custom fonts.

Installation:

pip install fpdf2

Simple Example:

from fpdf import FPDF

pdf = FPDF()
pdf.add_page()
pdf.set_font("Arial", size=12)
pdf.cell(200, 10, txt="Hello, FPDF2!", ln=1, align="C")
pdf.output("fpdf2_example.pdf")

This example generates a PDF with centred text.

3. WeasyPrint

WeasyPrint is a modern library that renders HTML and CSS into PDFs, making it an excellent choice for web developers. It leverages existing web development skills to create high-quality, professional-looking documents.

Key Features:

Converts HTML and CSS to PDF.
Supports modern CSS features like Flexbox and Grid.
Can generate PDFs from URLs or HTML strings.
Excellent for generating reports, invoices, and other printable documents from web content.

Installation:

pip install WeasyPrint

Simple Example:

from weasyprint import HTML

html_string = "<h1>Hello, WeasyPrint!</h1><p>This PDF was generated from HTML.</p>"
HTML(string=html_string).write_pdf("weasyprint_example.pdf")

This code demonstrates how to create a PDF from a simple HTML string.

Choosing the Right Library

The best library for your project depends on your specific needs:

For complex, highly customized documents where you need precise control over every element, ReportLab is the top contender.
If you need to quickly generate simple to moderately complex PDFs and prefer a straightforward API, FPDF2 is an excellent starting point.
For those who are already proficient with web technologies and want to leverage their HTML and CSS skills to create beautiful PDFs, WeasyPrint is the ideal choice.

Conclusion

Python's diverse ecosystem of libraries makes PDF generation an accessible task for developers of all skill levels. By knowing the available libraries, you can select the most appropriate tool to automate your document creation workflows and produce professional-quality PDFs.

Analysing Patterns in an SMS Spam Dataset Using Data Mining Techniques

Efe Omoregie — Sat, 15 Mar 2025 12:18:55 +0000

Introduction

Spam messages are a persistent problem in modern communication, cluttering inboxes with unwanted advertisements, phishing attempts, and fraudulent schemes. With the rise of SMS-based scams, automated spam detection has become a crucial area in text classification. In this blog, we apply data mining techniques to analyze and predict spam patterns using the SMS Spam Collection Dataset.

We employ classification to predict whether a message is spam or ham (legitimate) and clustering to explore natural patterns in the dataset. We use Logistic Regression as our primary classification model and K-Means Clustering to identify underlying structures in the data.

Dataset Overview

The dataset is sourced from the UCI Machine Learning Repository, containing 5,574 SMS messages labeled as either spam or ham.

Attributes

v1: Label indicating whether the message is spam or ham.
v2: The text content of the message.

Data Preprocessing

Since SMS messages contain various formats, punctuation, and case variations, preprocessing is essential. The key steps include:

Lowercasing text to maintain consistency.
Removing punctuation and special characters to clean the text.
Tokenization (splitting sentences into words).
Removing stop words (words like "is", "the", etc., that don't add meaning).
Stemming using PorterStemmer to reduce words to their root forms (e.g., "running" → "run").
TF-IDF Transformation to convert text into numerical representations.

import pandas as pd
import re
import nltk
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer
from sklearn.feature_extraction.text import TfidfVectorizer 

nltk.download('stopwords')
stop_words = set(stopwords.words('english'))
stemmer = PorterStemmer()

def preprocess_text(text):
    text = text.lower()
    text = re.sub(r'\W', ' ', text)
    words = text.split()
    words = [stemmer.stem(word) for word in words if word not in stop_words]
    return ' '.join(words)

Exploratory Data Analysis (EDA)

Before training our models, we explore the dataset to understand message distributions and characteristics.

1. Spam vs Ham Distribution

Understanding class balance helps in selecting appropriate modeling techniques.

import matplotlib.pyplot as plt
import seaborn as sns

label_counts = df['label'].value_counts()
plt.figure(figsize=(6, 4))
sns.barplot(x=label_counts.index, y=label_counts.values, palette='husl')
plt.title('Distribution of Spam vs Ham Messages')
plt.xlabel('Message Type')
plt.ylabel('Count')
plt.show()

We observe that spam messages are fewer than ham messages, indicating a class imbalance that must be considered when training models.

2. Message Length Analysis

Spam messages are often either very short (promotional) or very long (attempting to seem legitimate).

df['message_length'] = df['message'].apply(len)

plt.figure(figsize=(8, 5))
sns.histplot(df['message_length'], bins=30, kde=True, color='purple')
plt.title('Distribution of Message Lengths')
plt.xlabel('Message Length (Characters)')
plt.ylabel('Frequency')
plt.show()

3. Word Cloud Analysis

A word cloud helps visualize the most frequently used words in spam vs ham messages.

from wordcloud import WordCloud

spam_words = ' '.join(df[df['label'] == 'spam']['processed_message'])
ham_words = ' '.join(df[df['label'] == 'ham']['processed_message'])

spam_wordcloud = WordCloud(width=600, height=400, background_color='white').generate(spam_words)
ham_wordcloud = WordCloud(width=600, height=400, background_color='white').generate(ham_words)

plt.figure(figsize=(10, 6))
plt.subplot(1, 2, 1)
plt.imshow(spam_wordcloud, interpolation='bilinear')
plt.title('Spam Messages Word Cloud')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.imshow(ham_wordcloud, interpolation='bilinear')
plt.title('Ham Messages Word Cloud')
plt.axis('off')

plt.show()

We observe that spam messages frequently contain words like "free", "win", "call", and "urgent", while ham messages contain more conversational terms.

Pattern Discovery

1. Classification Using Logistic Regression

Using PyCaret, we compare different classification models to identify the best one.

from pycaret.classification import *

df_model = pd.DataFrame({'message': df['processed_message'], 'label': df['label']})
clf = setup(data=df_model, target='label', train_size=0.8, session_id=123)

best_model = compare_models()
print(best_model)

Results:

The Logistic Regression model performed best, achieving:

Accuracy: 89%
Precision: 90%
Recall: 89%

2. Confusion Matrix Analysis

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

y_pred = best_model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()
plt.show()

We notice a high precision but low recall for spam detection, meaning the model is very accurate when predicting spam, but it misses many actual spam messages (high false negative rate).

3. Clustering Using K-Means

Even though we already have labels, clustering can reveal natural groupings in the dataset.

from pycaret.clustering import *

cluster_setup = setup(df_model, session_id=123)
kmeans = create_model('kmeans', num_clusters=2)
assignments = assign_model(kmeans)
plot_model(kmeans, plot='elbow')

Findings:

Messages naturally cluster into two categories, reinforcing that spam messages have distinct patterns.
Cluster 0 represents ham, while Cluster 1 represents spam.

Conclusion

Logistic Regression achieved 89% accuracy, performing well but struggling with recall.
Spam messages tend to have more promotional and urgent language.
Clustering confirms that spam messages form a distinct category, reinforcing the potential of unsupervised learning in spam detection.

Final Thoughts

Spam detection is an evolving challenge as scammers adapt their techniques. Data mining and machine learning provide powerful tools to analyze and predict spam patterns, leading to better spam filters and improved communication security.

🔗 Github Repository with complete code: GitHub - SMS Spam Data Mining

🚀 Have thoughts or suggestions? Let’s discuss this in the comments!

Setting Up The Laravel Queue Worker on Heroku

Efe Omoregie — Sat, 19 Jun 2021 21:57:25 +0000

You've successfully deployed your Laravel application on Heroku. But then you hit a roadblock: your queue workers won't start the way they do on traditional Apache or Nginx servers. If you've been struggling with this, you're not alone.

Here's a straightforward guide to setting up Laravel queue workers on Heroku so your background jobs run smoothly.

Understanding the Heroku Approach

Heroku uses a different architecture than traditional servers. Instead of SSH access and long-running processes, Heroku relies on dynos (lightweight containers) and a Procfile to define how your application runs.

Step 1: Configure Your Procfile

In the root directory of your Laravel project, you'll need a Procfile that tells Heroku which processes to run. Add the following line to define your queue worker:

worker: php artisan queue:work --tries=3 --timeout=90

Let's break this down:

worker: The name of your process type (you can name it anything, but "worker" is conventional)
php artisan queue:work: The Laravel command that processes queued jobs
--tries=3: Optional flag to retry failed jobs up to 3 times
--timeout=90: Optional flag to set a maximum execution time of 90 seconds per job

You can customize these flags based on your application's needs. Other useful options include:

--sleep=3: Seconds to wait before polling for new jobs
--queue=high,default: Specify which queues to process and their priority
--max-jobs=1000: Maximum number of jobs to process before restarting

Step 2: Scale Your Worker Dyno

Once your Procfile is configured and your changes are deployed to Heroku, you need to provision a worker dyno. Run this command from your terminal:

heroku ps:scale worker=1 --app your-heroku-app

This tells Heroku to spin up one worker dyno for your application. You can scale this up or down depending on your queue volume:

# Scale to 3 workers for higher throughput
heroku ps:scale worker=3 --app your-heroku-app

# Scale down to 0 to stop processing queues
heroku ps:scale worker=0 --app your-heroku-app

Step 3: Verify Your Worker is Running

Check that your worker dyno is active:

heroku ps --app your-heroku-app

You should see output showing both your web and worker dynos running.

Important Considerations

Cost: Worker dynos consume additional dyno hours and may incur costs depending on your Heroku plan. Monitor your usage in the Heroku dashboard.

Queue Driver: Make sure your Laravel application is configured to use a persistent queue driver like Redis or a database. The sync driver won't work properly with background workers.

Monitoring: Use heroku logs --tail --ps worker to monitor your queue worker logs and troubleshoot any issues.

That's it! Your Laravel queues should now be processing jobs in the background on Heroku. If you run into issues, check your logs and verify your queue configuration in config/queue.php.