| name | report-generation |
| description | Creating structured PDF reports from data, templates, and AI-generated content using professional toolchains |
| metadata | {"author":"cosmicstack-labs","version":"1.0.0","category":"pdf-generation","tags":["report-generation","pdf-report","data-to-pdf","templating","business-reports"]} |
Report Generation
Create structured, data-driven PDF reports that communicate insights effectively. This skill covers the full pipeline — from data sources and templates to polished PDF output with charts, tables, and professional formatting.
Report Structure Fundamentals
A well-structured report follows a consistent pattern that guides the reader from context to conclusions.
Standard Report Anatomy
┌────────────────────────────────────────┐
│ Cover Page │
│ Title, subtitle, author, date, │
│ organization branding │
├────────────────────────────────────────┤
│ Table of Contents │
│ Auto-generated from headings │
├────────────────────────────────────────┤
│ Executive Summary │
│ Key findings in 1-2 paragraphs │
├────────────────────────────────────────┤
│ Introduction / Background │
│ Context, objectives, scope │
├────────────────────────────────────────┤
│ Methodology │
│ How data was collected/analyzed │
├────────────────────────────────────────┤
│ Findings / Results │
│ Data presentation with charts/tables │
├────────────────────────────────────────┤
│ Discussion │
│ Interpretation of results │
├────────────────────────────────────────┤
│ Conclusions │
│ Summary of key takeaways │
├────────────────────────────────────────┤
│ Recommendations │
│ Actionable next steps │
├────────────────────────────────────────┤
│ Appendices │
│ Raw data, methodology details, refs │
└────────────────────────────────────────┘
Report Metadata Standards
"""Report metadata schema for consistent document properties."""
from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional
@dataclass
class ReportMetadata:
"""Standard metadata for all generated reports."""
title: str
subtitle: Optional[str] = None
author: str = "Automated Report System"
organization: str = "Cosmic Stack Labs"
department: Optional[str] = None
version: str = "1.0"
report_date: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))
period_start: Optional[str] = None
period_end: Optional[str] = None
classification: str = "Internal"
document_id: Optional[str] = None
keywords: list[str] = field(default_factory=list)
def to_dict(self) -> dict:
"""Convert to dictionary for template rendering."""
return {
: .title,
: .subtitle,
: .author,
: .organization,
: .department,
: .version,
: .report_date,
: .period_start,
: .period_end,
: .classification,
: .document_id ,
: .join(.keywords) .keywords ,
}
metadata = ReportMetadata(
title=,
subtitle=,
author=,
department=,
version=,
period_start=,
period_end=,
classification=,
keywords=[, , , ],
)
2. Template Engines
Jinja2 + WeasyPrint Pipeline
This is the most flexible approach for branded, data-rich reports.
Report Template (HTML)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>{{ metadata.title }}</title>
<style>
@page {
size: A4;
margin: 2.5cm 2cm 2.5cm 2cm;
@top-center {
content: "{{ metadata.organization }}";
font-size: 8pt;
color: #666;
font-family: 'Helvetica', sans-serif;
}
@bottom-center {
content: "Page " counter(page) " of " counter(pages);
font-size: 8pt;
color: #666;
font-family: 'Helvetica', sans-serif;
}
@bottom-left {
content: "{{ metadata.classification }}";
font-size: 7pt;
color: #999;
font-style: italic;
}
}
@page:first {
@top-center { content: none; }
@bottom-left { content: none; }
}
body {
font-family: 'Helvetica', 'Arial', sans-serif;
font-size: 10pt;
line-height: 1.6;
color: #333;
}
/* Cover page */
.cover-page {
page-break-after: always;
text-align: center;
padding-top: 8cm;
}
.cover-page .org-name {
font-size: 11pt;
color: #666;
letter-spacing: 2px;
text-transform: uppercase;
margin-bottom: 2cm;
}
.cover-page h1 {
font-size: 28pt;
color: #1a1a2e;
margin-bottom: 0.5cm;
border: none;
}
.cover-page .subtitle {
font-size: 16pt;
color: #555;
margin-bottom: 1.5cm;
}
.cover-page .meta-info {
font-size: 10pt;
color: #777;
line-height: 2;
}
/* Section headings */
h1 {
font-size: 20pt;
color: #1a1a2e;
border-bottom: 2px solid #1a1a2e;
padding-bottom: 6px;
page-break-before: always;
page-break-after: avoid;
}
h1:first-of-type {
page-break-before: avoid;
}
h2 {
font-size: 14pt;
color: #2c3e50;
margin-top: 1cm;
page-break-after: avoid;
}
h3 {
font-size: 12pt;
color: #555;
margin-top: 0.7cm;
page-break-after: avoid;
}
/* Tables */
table {
width: 100%;
border-collapse: collapse;
margin: 0.8em 0;
font-size: 9pt;
}
thead {
display: table-header-group;
}
tr {
page-break-inside: avoid;
}
th {
background: {{ accent_color }};
color: white;
padding: 8px 10px;
text-align: left;
font-weight: bold;
}
td {
padding: 6px 10px;
border-bottom: 1px solid #e0e0e0;
}
tr:nth-child(even) td {
background: #f8f9fa;
}
tr:hover td {
background: #e8f4f8;
}
/* Executive summary box */
.executive-summary {
background: #f0f4f8;
border-left: 4px solid {{ accent_color }};
padding: 16px 20px;
margin: 1em 0;
font-size: 11pt;
line-height: 1.7;
}
.executive-summary h2 {
margin-top: 0;
color: {{ accent_color }};
}
/* Charts and images */
.chart-container {
text-align: center;
margin: 1em 0;
page-break-inside: avoid;
}
.chart-container img {
max-width: 100%;
max-height: 12cm;
}
.chart-caption {
font-size: 9pt;
color: #666;
font-style: italic;
margin-top: 4px;
}
/* Callout boxes */
.callout {
padding: 12px 16px;
margin: 0.8em 0;
border-radius: 4px;
page-break-inside: avoid;
}
.callout-info {
background: #e3f2fd;
border-left: 4px solid #1565c0;
}
.callout-warning {
background: #fff3e0;
border-left: 4px solid #ef6c00;
}
.callout-success {
background: #e8f5e9;
border-left: 4px solid #2e7d32;
}
/* Page breaks */
.page-break {
page-break-before: always;
}
{{ metadata.organization }}
{{ metadata.title }}
{% if metadata.subtitle %}
{{ metadata.subtitle }}
{% endif %}
{% if metadata.department %}{{ metadata.department }}{% endif %}
Author: {{ metadata.author }}
Date: {{ metadata.report_date }}
{% if metadata.period_start and metadata.period_end %}
Period: {{ metadata.period_start }} — {{ metadata.period_end }}
{% endif %}
Version: {{ metadata.version }}
Document ID: {{ metadata.document_id }}
Table of Contents
{% for section in sections %}
{{ section.number }} {{ section.title }}
{% endfor %}
{% for section in sections %}
<h{{ section.level }} id="{{ section.anchor }}">
{{ section.number }} {{ section.title }}
</h{{ section.level }}>
{% for paragraph in section.content %}
{% if paragraph.type == 'text' %}
{{ paragraph.text }}
{% elif paragraph.type == 'table' %}
{% for header in paragraph.headers %}
{{ header }}
{% endfor %}
{% for row in paragraph.rows %}
{% for cell in row %}
{{ cell }}
{% endfor %}
{% endfor %}
{% if paragraph.caption %}
Table: {{ paragraph.caption }}
{% endif %}
{% elif paragraph.type == 'chart' %}
{% if paragraph.caption %}
Figure: {{ paragraph.caption }}
{% endif %}
{% elif paragraph.type == 'callout' %}
{{ paragraph.title }}
{{ paragraph.text }}
{% elif paragraph.type == 'list' %}
{% for item in paragraph.items %}
{{ item }}
{% endfor %}
{% endif %}
{% endfor %}
{% endfor %}
Python Report Generator
"""Complete report generation system using Jinja2 and WeasyPrint."""
import json
import os
from pathlib import Path
from datetime import datetime
from typing import Optional
import jinja2
import matplotlib.pyplot as plt
import pandas as pd
from weasyprint import HTML
class ReportGenerator:
"""Generate professional PDF reports from data and templates."""
def __init__(self, template_dir: str = "templates", output_dir: str = "output"):
self.template_dir = Path(template_dir)
self.output_dir = Path(output_dir)
self.output_dir.mkdir(parents=True, exist_ok=True)
self.env = jinja2.Environment(
loader=jinja2.FileSystemLoader(str(self.template_dir)),
autoescape=False,
)
def generate_chart(self, data: pd.DataFrame, chart_type: str,
title: str, output_path: str) -> str:
"""Generate a matplotlib chart and save to file."""
fig, ax = plt.subplots(figsize=(, ))
chart_type == :
data.plot(kind=, ax=ax)
chart_type == :
data.plot(kind=, ax=ax, marker=)
chart_type == :
data.plot(kind=, ax=ax, autopct=)
chart_type == :
data.plot(kind=, ax=ax)
ax.set_title(title, fontsize=, fontweight=)
ax.set_xlabel()
ax.spines[].set_visible()
ax.spines[].set_visible()
ax.grid(axis=, alpha=)
plt.tight_layout()
plt.savefig(output_path, dpi=, bbox_inches=)
plt.close()
output_path
() -> :
path = Path(data_path)
path.suffix == :
pd.read_csv(path).to_dict(orient=)
path.suffix == :
(path, ) f:
json.load(f)
path.suffix == :
pd.read_excel(path).to_dict(orient=)
:
ValueError()
() -> []:
sections = []
section_number =
section_config config.get(, []):
section_number +=
section = {
: section_config.get(, ),
: section_config[],
: section_config[].lower().replace(, ),
: (section_number),
: [],
}
block section_config.get(, []):
block_type = block.get(, )
block_type == :
section[].append({
: ,
: block[],
})
block_type == :
headers = block.get(, [])
rows = []
row_data block.get(, []):
rows.append([row_data.get(h.lower().replace(, ), )
h headers])
section[].append({
: ,
: headers,
: rows,
: block.get(, ),
})
block_type == :
chart_path = os.path.join(
.output_dir,
)
df = pd.DataFrame(block.get(, []))
.generate_chart(
df, block.get(, ),
block.get(, ), chart_path
)
section[].append({
: ,
: chart_path,
: block.get(, ),
})
block_type == :
section[].append({
: ,
: block.get(, ),
: block.get(, ),
: block.get(, ),
})
sections.append(section)
sections
() -> :
raw_data = .load_data(data_source)
sections = .build_sections_from_data(raw_data, config)
template = .env.get_template(config.get(, ))
html_content = template.render(
metadata=metadata,
sections=sections,
accent_color=accent_color,
)
output_filename =
output_path = (.output_dir / output_filename)
HTML(string=html_content).write_pdf(output_path)
()
output_path
__name__ == :
gen = ReportGenerator()
report_config = {
: ,
: [
{
: ,
: ,
: [
{: , : },
{: ,
: ,
: ,
: },
],
},
{
: ,
: ,
: [
{: ,
: ,
: ,
: ,
: ,
: [
{: , : , : , : },
{: , : , : , : },
{: , : , : , : },
{: , : , : , : },
]},
{: ,
: [, , , , , ],
: ,
: [
{: , : , : ,
: , : , : },
{: , : , : ,
: , : , : },
{: , : , : ,
: , : , : },
]},
],
},
],
}
gen.generate(
data_source=,
config=report_config,
metadata={
: ,
: ,
: ,
: ,
: ,
: ,
: ,
: ,
},
accent_color=,
)
3. Data Source Integration
CSV to Report
"""Generate a report directly from CSV data."""
import pandas as pd
from jinja2 import Environment, FileSystemLoader
from weasyprint import HTML
def csv_to_report(csv_path: str, template_path: str, output_path: str):
"""Convert a CSV file into a formatted PDF report."""
df = pd.read_csv(csv_path)
summary = {
'total_rows': len(df),
'columns': list(df.columns),
'numeric_summary': {}
}
for col in df.select_dtypes(include=['number']).columns:
summary['numeric_summary'][col] = {
'mean': round(df[col].mean(), 2),
'median': round(df[col].median(), 2),
'min': round(df[col].min(), 2),
'max': round(df[col].max(), 2),
'std': round(df[col].std(), 2),
}
env = Environment(loader=FileSystemLoader('.'))
template = env.get_template(template_path)
html = template.render(
title=f"Report: {csv_path}",
data=df.to_dict(orient=),
summary=summary,
columns=df.columns.tolist(),
)
HTML(string=html).write_pdf(output_path)
csv_to_report(, , )
SQL Database → Report
"""Generate a report from SQL database queries."""
import sqlite3
import pandas as pd
from jinja2 import Environment, FileSystemLoader
from weasyprint import HTML
def sql_to_report(db_path: str, queries: dict, template_path: str,
output_path: str):
"""Generate a PDF report from SQL database queries."""
conn = sqlite3.connect(db_path)
results = {}
for name, query in queries.items():
df = pd.read_sql_query(query, conn)
results[name] = {
'headers': df.columns.tolist(),
'rows': df.values.tolist(),
'row_count': len(df),
}
conn.close()
env = Environment(loader=FileSystemLoader('.'))
template = env.get_template(template_path)
html = template.render(results=results)
HTML(string=html).write_pdf(output_path)
queries = {
'top_customers': """
SELECT customer_name, total_spent, order_count, last_order_date
FROM customers
ORDER BY total_spent DESC
LIMIT 20
""",
'monthly_revenue': """
SELECT strftime('%Y-%m', order_date) as month,
SUM(amount) as revenue,
COUNT(*) as orders
FROM orders
WHERE order_date >= date('now', '-12 months')
GROUP BY month
ORDER BY month
""",
}
sql_to_report('analytics.db', queries, 'sql_report.html', 'analytics_report.pdf')
API Data → Report
"""Generate a report from external API data."""
import requests
import matplotlib.pyplot as plt
import seaborn as sns
from jinja2 import Environment, FileSystemLoader
from weasyprint import HTML
def api_to_report(api_endpoint: str, headers: dict, params: dict,
template_path: str, output_path: str):
"""Fetch data from an API and generate a PDF report."""
response = requests.get(api_endpoint, headers=headers, params=params)
response.raise_for_status()
data = response.json()
if 'timeline' in data:
fig, ax = plt.subplots(figsize=(10, 5))
dates = [item['date'] for item in data['timeline']]
values = [item['value'] for item in data['timeline']]
ax.plot(dates, values, marker='o', linewidth=2)
ax.set_title('Timeline Trend')
ax.tick_params(axis='x', rotation=45)
plt.tight_layout()
plt.savefig('timeline_chart.png', dpi=150)
plt.close()
env = Environment(loader=FileSystemLoader('.'))
template = env.get_template(template_path)
html = template.render(data=data)
HTML(string=html).write_pdf(output_path)
4. Chart Embedding in Reports
Matplotlib for Report Charts
"""Professional chart styling for reports."""
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
import pandas as pd
matplotlib.rcParams.update({
'figure.dpi': 200,
'font.family': 'sans-serif',
'font.size': 10,
'axes.titlesize': 12,
'axes.labelsize': 10,
'axes.grid': True,
'grid.alpha': 0.3,
'grid.linestyle': '--',
})
def create_bar_chart(data: pd.DataFrame, output_path: str,
title: str = "", xlabel: str = "", ylabel: str = ""):
"""Create a professional bar chart for reports."""
fig, ax = plt.subplots(figsize=(8, 4.5))
colors = ['#1a1a2e', '#16213e', '#0f3460', '#e94560', '#533483']
bars = data.plot(kind='bar', ax=ax, color=colors[:len(data.columns)], width=0.7)
ax.set_title(title, fontweight='bold', pad=12)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.spines[].set_visible()
ax.spines[].set_visible()
ax.legend(frameon=)
container ax.containers:
ax.bar_label(container, fmt=, padding=, fontsize=)
plt.tight_layout()
plt.savefig(output_path, bbox_inches=)
plt.close()
():
fig, ax = plt.subplots(figsize=(, ))
colors = [, , , ,
, , , ]
wedges, texts, autotexts = ax.pie(
data.values,
labels=data.index,
autopct=,
startangle=,
colors=colors[:(data)],
wedgeprops={: , : },
)
autotext autotexts:
autotext.set_color()
autotext.set_fontsize()
ax.set_title(title, fontweight=, pad=)
plt.tight_layout()
plt.savefig(output_path, bbox_inches=)
plt.close()
Programmatic Chart Generation (Plotly to Static Images)
"""Generate charts using Plotly for interactive-capable reports."""
import plotly.express as px
import plotly.graph_objects as go
import pandas as pd
def plotly_to_image(fig, output_path: str, width=800, height=450):
"""Save a Plotly figure as a static image for PDF embedding."""
fig.write_image(output_path, width=width, height=height, scale=2)
def create_plotly_charts(data_path: str, output_dir: str):
"""Create multiple charts from data for report embedding."""
df = pd.read_csv(data_path)
fig = px.line(
df, x='date', y=['forecast', 'actual'],
title='Revenue Forecast vs Actual',
template='plotly_white',
labels={'value': 'Revenue ($K)', 'date': ''},
)
plotly_to_image(fig, f'{output_dir}/revenue_forecast.png')
pivot = df.pivot_table(
values='revenue', index='product', columns='region', aggfunc='sum'
)
fig = px.imshow(
pivot,
text_auto='.0f',
color_continuous_scale='Blues',
title='Revenue Heatmap by Product and Region',
)
plotly_to_image(fig, f'{output_dir}/revenue_heatmap.png', height=)
fig = px.bar(
df, x=, y=, color=,
barmode=,
title=,
template=,
)
plotly_to_image(fig, )
5. Dynamic Tables
Complex Table Formatting
"""Advanced table formatting for PDF reports."""
from reportlab.lib import colors
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import cm
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph
from reportlab.lib.styles import getSampleStyleSheet
def styled_table_report(data: list[list], headers: list[str],
output_path: str, title: str = ""):
"""Generate a report with professionally styled tables."""
doc = SimpleDocTemplate(output_path, pagesize=A4,
leftMargin=2*cm, rightMargin=2*cm,
topMargin=2*cm, bottomMargin=2*cm)
styles = getSampleStyleSheet()
story = []
if title:
story.append(Paragraph(title, styles['Title']))
table_data = [headers] + data
col_widths = [max(
len(str(row[i])) for row in table_data
) * 0.12 * cm + 1.5 * cm for i in range(len(headers))]
total_width = sum(col_widths)
page_width = A4[0] - 4*cm
total_width > page_width:
col_widths = [w * page_width / total_width w col_widths]
table = Table(table_data, colWidths=col_widths, repeatRows=)
row_colors = [colors.HexColor(), colors.white]
style_commands = [
(, (, ), (-, ), colors.HexColor()),
(, (, ), (-, ), colors.white),
(, (, ), (-, ), ),
(, (, ), (-, ), ),
(, (, ), (-, ), ),
(, (, ), (-, -), ),
(, (, ), (-, -), ),
(, (, ), (-, -), ),
(, (, ), (-, -), ),
(, (, ), (-, -), ),
(, (, ), (-, -), ),
(, (, ), (-, -), ),
(, (, ), (-, -), ),
(, (, ), (-, -), , colors.HexColor()),
(, (, ), (-, ), , colors.HexColor()),
*[(, (, i), (-, i), row_colors[i % ])
i (, (table_data))],
]
row_idx (, (table_data)):
col_idx ((headers)):
:
value = (table_data[row_idx][col_idx])
value < :
style_commands.append(
(, (col_idx, row_idx),
(col_idx, row_idx), colors.HexColor())
)
(ValueError, TypeError):
table.setStyle(TableStyle(style_commands))
story.append(table)
doc.build(story)
()
headers = [, , , , , , ]
data = [
[, , , , , , ],
[, , , , , , ],
[, , , , , , ],
[, , , , , , ],
[, , , , , , ],
[, , , , , , ],
]
styled_table_report(data, headers, ,
)
6. Cover Pages, Watermarks, and PDF Metadata
Professional Cover Page
"""Generate a custom cover page for reports."""
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import cm
from reportlab.lib import colors
from reportlab.pdfgen import canvas
from reportlab.lib.styles import ParagraphStyle
from reportlab.platypus import Paragraph
def create_cover_page(output_path: str, title: str, subtitle: str,
author: str, date: str, organization: str,
classification: str = "Internal"):
"""Generate a professional cover page as a standalone PDF."""
c = canvas.Canvas(output_path, pagesize=A4)
width, height = A4
c.setFillColor(colors.HexColor('#1a1a2e'))
c.rect(0, 0, width, height * 0.15, fill=1, stroke=0)
c.setFillColor(colors.HexColor('#0f3460'))
c.rect(0, height * 0.15, width, 0.3*cm, fill=1, stroke=0)
c.setFillColor(colors.white)
c.setFont('Helvetica', 10)
c.drawString(3*cm, height - 1.5*cm, organization.upper())
c.setFillColor(colors.HexColor())
c.setFont(, )
c.drawRightString(width - *cm, height - *cm, classification)
c.setFillColor(colors.HexColor())
c.setFont(, )
words = title.split()
lines = []
current_line = []
word words:
test_line = .join(current_line + [word])
c.stringWidth(test_line, , ) < width - *cm:
current_line.append(word)
:
lines.append(.join(current_line))
current_line = [word]
lines.append(.join(current_line))
y_position = height *
line lines:
c.drawCentredString(width / , y_position, line)
y_position -=
subtitle:
c.setFont(, )
c.setFillColor(colors.HexColor())
c.drawCentredString(width / , y_position - , subtitle)
c.setStrokeColor(colors.HexColor())
c.setLineWidth()
line_y = y_position -
c.line(width * , line_y, width * , line_y)
meta_y = line_y -
c.setFont(, )
c.setFillColor(colors.HexColor())
meta_items = [
,
,
,
]
item meta_items:
c.drawCentredString(width / , meta_y, item)
meta_y -=
c.save()
()
create_cover_page(
,
title=,
subtitle=,
author=,
date=,
organization=,
classification=,
)
Watermark and Confidentiality Markings
"""Add watermarks and confidentiality markings to PDF pages."""
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import cm
from reportlab.lib import colors
from reportlab.pdfgen import canvas
def add_watermark(input_pdf: str, output_pdf: str,
watermark_text: str = "CONFIDENTIAL",
opacity: float = 0.15):
"""Add a diagonal watermark to every page of a PDF."""
from PyPDF2 import PdfReader, PdfWriter
from reportlab.pdfgen import canvas as pdf_canvas
import io
reader = PdfReader(input_pdf)
writer = PdfWriter()
for page_num in range(len(reader.pages)):
page = reader.pages[page_num]
packet = io.BytesIO()
c = pdf_canvas.Canvas(packet, pagesize=A4)
c.saveState()
c.setFillColor(colors.HexColor('#000000'))
c.setFont('Helvetica-Bold', 60)
c.setFillAlpha(opacity)
c.translate(A4[0] / 2, A4[1] / 2)
c.rotate(45)
c.drawCentredString(0, 0, watermark_text)
c.restoreState()
c.setFillColor(colors.HexColor())
c.setFillAlpha()
c.rect(, , A4[], *cm, fill=, stroke=)
c.setFillColor(colors.white)
c.setFont(, )
c.setFillAlpha()
c.drawCentredString(A4[] / , *cm,
)
c.save()
packet.seek()
watermark = PdfReader(packet)
page.merge_page(watermark.pages[])
writer.add_page(page)
(output_pdf, ) f:
writer.write(f)
()
PDF Metadata Injection
"""Set PDF metadata properties for document management."""
from PyPDF2 import PdfReader, PdfWriter
from datetime import datetime
def set_pdf_metadata(input_pdf: str, output_pdf: str,
title: str, author: str, subject: str,
keywords: list[str], document_id: str = ""):
"""Set standard PDF metadata fields."""
reader = PdfReader(input_pdf)
writer = PdfWriter()
for page in reader.pages:
writer.add_page(page)
writer.add_metadata({
'/Title': title,
'/Author': author,
'/Subject': subject,
'/Keywords': ', '.join(keywords),
'/Producer': 'Mercury Report Generator v1.0',
'/Creator': 'Cosmic Stack Labs Report System',
'/CreationDate': datetime.now().strftime("D:%Y%m%d%H%M%S"),
})
if document_id:
writer.add_metadata({
'/DocumentID': document_id,
})
with open(output_pdf, 'wb') as f:
writer.write(f)
print(f"Metadata applied: {output_pdf}")
set_pdf_metadata(
,
,
title=,
author=,
subject=,
keywords=[, , , ],
document_id=,
)
7. Automated Report Pipelines
Scheduled Report Generation
"""Automated report generation pipeline with scheduling."""
import schedule
import time
import json
from datetime import datetime
from pathlib import Path
from report_generator import ReportGenerator
class AutomatedReportPipeline:
"""Scheduled report generation system."""
def __init__(self, config_path: str = "reports_config.json"):
self.gen = ReportGenerator()
with open(config_path, 'r') as f:
self.reports = json.load(f)
def generate_report(self, report_name: str):
"""Generate a specific report by name."""
config = self.reports.get(report_name)
if not config:
print(f"Report '{report_name}' not found in config")
return
print(f"[{datetime.now()}] Generating report: {report_name}")
metadata = config['metadata']
metadata['report_date'] = datetime.now().strftime("%Y-%m-%d")
try:
output = self.gen.generate(
data_source=config[],
config=config[],
metadata=metadata,
accent_color=config.get(, ),
)
()
.notify(report_name, output)
Exception e:
()
():
()
():
.generate_report(report_name)
():
name, config .reports.items():
schedule_str = config.get()
schedule_str:
schedule_str == :
schedule.every().day.at().do(
.generate_report, name
)
schedule_str == :
schedule.every().monday.at().do(
.generate_report, name
)
schedule_str == :
schedule.every().month.at().do(
.generate_report, name
)
()
():
.schedule_all()
()
:
:
schedule.run_pending()
time.sleep()
KeyboardInterrupt:
()
pipeline = AutomatedReportPipeline()
pipeline.run_loop()
Event-Triggered Pipeline
"""Event-driven report generation using file system watchers."""
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
import json
import time
from pathlib import Path
class DataChangeHandler(FileSystemEventHandler):
"""Trigger report generation when data files change."""
def __init__(self, pipeline):
self.pipeline = pipeline
self.cooldown = {}
def on_modified(self, event):
if event.is_directory:
return
path = Path(event.src_path)
if path.suffix in ['.csv', '.json', '.xlsx']:
now = time.time()
last = self.cooldown.get(str(path), 0)
if now - last < 60:
return
self.cooldown[str(path)] = now
print(f"Data changed: {path.name}")
for name, config in self.pipeline.reports.items():
config.get() == (path):
()
.pipeline.generate_report(name)
():
event_handler = DataChangeHandler(pipeline)
observer = Observer()
observer.schedule(event_handler, watch_path, recursive=)
observer.start()
()
:
:
time.sleep()
KeyboardInterrupt:
observer.stop()
observer.join()
pipeline = AutomatedReportPipeline()
watch_data_directory(, pipeline)
Scoring Rubric
| Criteria | 1 (Basic) | 2 (Functional) | 3 (Proficient) | 4 (Advanced) | 5 (Expert) |
|---|
| Structure | Single section | Basic sections | Full report anatomy | Modular sections | Dynamic layout |
| Data Integration | Manual input | CSV import | CSV + JSON + SQL | Real-time APIs | Multiple sources |
| Visualizations | None | Static tables | Basic charts | Interactive charts (static) | Conditionally formatted |
| Templating | Hardcoded | Simple template | Jinja2 templates | Modular templates | Composable blocks |
| Automation | Manual | Shell script | Scheduled | Event-triggered | Full CI/CD pipeline |
| Quality | Plain text | Basic styling | Professional | Branded | Publication-ready |
Common Mistakes
- Report too long without summary: Busy stakeholders need the key insights first. Lead with the executive summary.
- Data without context: Raw numbers are meaningless without comparisons (YoY, budget, target). Always include benchmarks.
- Overcomplicating report structure: Seven sections maximum for business reports. Deeper detail goes in appendices.
- Charts without captions: Every figure and table needs a numbered caption for reference in text.
- Ignoring page breaks: Charts breaking across pages is unprofessional. Use
page-break-inside: avoid.
- No PDF metadata: Documents without title, author, or subject are hard to find in document management systems.
- Missing file size optimization: Large embedded images bloat PDFs. Resize to screen resolution (150-200 DPI).
- Template not tested with real data: Test templates with edge cases — empty datasets, long text, special characters.
- Forgetting the TOC: Any report over 5 pages needs a table of contents with page numbers.
- No version control on reports: Include a version number and change log in the report footer or metadata.
