280 lines
8.3 KiB
Python
280 lines
8.3 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""
|
|
Author: Hendrik Schutter, localhorst@mosad.xyz
|
|
Date of creation: 2022/11/16
|
|
Date of last modification: 2025/06/08
|
|
"""
|
|
|
|
import re
|
|
import dataclasses
|
|
import glob
|
|
import datetime
|
|
import json
|
|
import logging
|
|
import qrcode
|
|
from PIL import Image, ImageFont, ImageDraw
|
|
|
|
# Constants
|
|
FONT_PATH = "/usr/share/fonts"
|
|
DEFAULT_FONT_REGULAR = "DejaVuSans.ttf"
|
|
DEFAULT_FONT_BOLD = "DejaVuSans-Bold.ttf"
|
|
OUTPUT_WIDTH = 696 # px
|
|
OUTPUT_HEIGHT = 300 # px
|
|
TEXT_X_OFFSET = 300 # px
|
|
QR_CODE_SIZE = 289 # px
|
|
|
|
# Configure logging
|
|
logging.basicConfig(
|
|
level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
|
|
)
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class DriveData:
|
|
drive_index: int
|
|
drive_state: str
|
|
modelfamily: str
|
|
modelname: str
|
|
capacity: int
|
|
serialnumber: str
|
|
power_on_hours: int
|
|
power_cycle: int
|
|
smart_error_count: int
|
|
shred_timestamp: int
|
|
shred_duration: int
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class DriveDataPrintable:
|
|
modelfamily: str
|
|
modelname: str
|
|
capacity: str
|
|
serialnumber: str
|
|
power_on_hours: str
|
|
power_cycle: str
|
|
smart_error_count: str
|
|
shred_timestamp: str
|
|
shred_duration: str
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class ReHddInfo:
|
|
link: str
|
|
version: str
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class DriveDataJson:
|
|
drive: DriveData
|
|
rehdd: ReHddInfo
|
|
|
|
|
|
def find_font_path(font_name):
|
|
"""Finds the full path of the specified font."""
|
|
try:
|
|
files = glob.glob(f"{FONT_PATH}/**/{font_name}", recursive=True)
|
|
return files[0] if files else None
|
|
except Exception as e:
|
|
logging.error(f"Error locating font {font_name}: {e}")
|
|
return None
|
|
|
|
|
|
def human_readable_capacity(size, decimal_places=0, base=1000):
|
|
"""Converts bytes to a human-readable string."""
|
|
units = (
|
|
["B", "KB", "MB", "GB", "TB", "PB"]
|
|
if base == 1000
|
|
else ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]
|
|
)
|
|
for unit in units:
|
|
if size < base or unit == units[-1]:
|
|
return f"{size:.{decimal_places}f} {unit}"
|
|
size /= base
|
|
|
|
|
|
def human_readable_power_on_hours(hours):
|
|
"""Converts hours to human-readable string in hours, days, and years."""
|
|
return (
|
|
str(hours)
|
|
+ "h or "
|
|
+ str(int(hours / 24))
|
|
+ "d or "
|
|
+ str("{:.2f}".format(float(hours / 24 / 365)))
|
|
+ "y"
|
|
)
|
|
|
|
|
|
def cut_string(max_length, data, direction="end"):
|
|
"""Trims a string to the maximum length, adding ellipses if necessary."""
|
|
if len(data) > max_length:
|
|
return (
|
|
f"{data[:max_length-4]} ..."
|
|
if direction == "end"
|
|
else f"... {data[-(max_length-4):]}"
|
|
)
|
|
return data
|
|
|
|
|
|
def format_to_printable(drive):
|
|
return DriveDataPrintable(
|
|
cut_string(20, re.sub(r"[^a-zA-Z0-9. ]", "", drive.modelfamily), "end"),
|
|
cut_string(20, re.sub(r"[^a-zA-Z0-9. ]", "", drive.modelname), "end"),
|
|
cut_string(20, human_readable_capacity(drive.capacity), "end"),
|
|
cut_string(16, re.sub(r"[^a-zA-Z0-9.-_]", "", drive.serialnumber), "start"),
|
|
cut_string(30, human_readable_power_on_hours(drive.power_on_hours), "end"),
|
|
cut_string(10, str(drive.power_cycle), "end"),
|
|
cut_string(10, str(drive.smart_error_count), "end"),
|
|
cut_string(
|
|
30,
|
|
datetime.datetime.fromtimestamp(
|
|
drive.shred_timestamp, datetime.UTC
|
|
).strftime("%Y-%m-%d %H:%M:%S"),
|
|
"end",
|
|
),
|
|
cut_string(30, str(datetime.timedelta(seconds=drive.shred_duration)), "end"),
|
|
)
|
|
|
|
|
|
def draw_text(drawable, printable_data, font_regular, font_bold, font_bold_bigger):
|
|
"""Draws the formatted text onto the image."""
|
|
text_y_offset = 10
|
|
value_column_x_offset = 120
|
|
font_size = 20
|
|
|
|
drawable.text(
|
|
(TEXT_X_OFFSET, text_y_offset), printable_data.serialnumber, (0), font=font_bold
|
|
)
|
|
text_y_offset += 25
|
|
|
|
fields = [
|
|
("Family:", printable_data.modelfamily, font_regular),
|
|
("Model:", printable_data.modelname, font_regular),
|
|
("Hours:", printable_data.power_on_hours, font_regular),
|
|
("Cycles:", printable_data.power_cycle, font_regular),
|
|
("Errors:", printable_data.smart_error_count, font_regular),
|
|
("Shred on:", printable_data.shred_timestamp, font_regular),
|
|
("Duration:", printable_data.shred_duration, font_regular),
|
|
]
|
|
|
|
for label, value, font in fields:
|
|
drawable.text((TEXT_X_OFFSET, text_y_offset), label, fill=0, font=font_bold)
|
|
drawable.text(
|
|
(TEXT_X_OFFSET + value_column_x_offset, text_y_offset),
|
|
value,
|
|
fill=0,
|
|
font=font,
|
|
)
|
|
text_y_offset += 25
|
|
|
|
drawable.text(
|
|
(TEXT_X_OFFSET, text_y_offset),
|
|
printable_data.capacity,
|
|
(0),
|
|
font=font_bold_bigger,
|
|
)
|
|
|
|
|
|
def draw_qr_code(image, data):
|
|
"""
|
|
Draws a QR code on the provided image at a specific location.
|
|
|
|
Parameters:
|
|
image (Image.Image): The target image.
|
|
data (str): The data to encode in the QR code.
|
|
"""
|
|
# Generate the QR code
|
|
qr_img = qrcode.make(data)
|
|
qr_img = qr_img.convert("1") # Ensure QR code is in binary (black/white)
|
|
|
|
# Remove white border
|
|
bbox = qr_img.getbbox() # Get the bounding box of the non-white area
|
|
qr_img = qr_img.crop(bbox)
|
|
|
|
# Resize to desired size
|
|
qr_img = qr_img.resize((QR_CODE_SIZE, QR_CODE_SIZE), Image.Resampling.LANCZOS)
|
|
|
|
# Paste the QR code onto the image
|
|
region = (5, 5, 5 + QR_CODE_SIZE, 5 + QR_CODE_SIZE)
|
|
image.paste(qr_img, box=region)
|
|
|
|
|
|
def draw_outline(drawable, margin, width, output_width, output_height):
|
|
"""
|
|
Draws a rectangular outline on the drawable canvas.
|
|
|
|
Parameters:
|
|
drawable (ImageDraw.Draw): The drawable canvas.
|
|
margin (int): The margin from the edges of the image.
|
|
width (int): The width of the outline.
|
|
output_width (int): The total width of the image.
|
|
output_height (int): The total height of the image.
|
|
"""
|
|
# Define the four corners of the rectangle, adjusting for line width
|
|
top_left = (margin, margin)
|
|
top_right = (output_width - margin - width, margin)
|
|
bottom_left = (margin, output_height - margin - width)
|
|
bottom_right = (output_width - margin - width, output_height - margin - width)
|
|
|
|
# Draw the outline lines with adjusted coordinates
|
|
lines = [
|
|
(top_left, top_right), # Top edge
|
|
(top_left, bottom_left), # Left edge
|
|
(top_right, bottom_right), # Right edge
|
|
(bottom_left, bottom_right), # Bottom edge
|
|
]
|
|
|
|
for line in lines:
|
|
drawable.line(line, fill=0, width=width)
|
|
|
|
|
|
def generate_image(drive, rehdd_info, output_file):
|
|
"""Generates an image containing drive data and a QR code."""
|
|
try:
|
|
qr_data = json.dumps(dataclasses.asdict(DriveDataJson(drive, rehdd_info)))
|
|
printable_data = format_to_printable(drive)
|
|
except Exception as e:
|
|
logging.error(f"Error preparing data: {e}")
|
|
return
|
|
|
|
output_image = Image.new("1", (OUTPUT_WIDTH, OUTPUT_HEIGHT), "white")
|
|
draw = ImageDraw.Draw(output_image)
|
|
|
|
font_regular = ImageFont.truetype(find_font_path(DEFAULT_FONT_REGULAR), 20)
|
|
font_bold = ImageFont.truetype(find_font_path(DEFAULT_FONT_BOLD), 20)
|
|
font_bold_bigger = ImageFont.truetype(find_font_path(DEFAULT_FONT_BOLD), 60)
|
|
|
|
draw_outline(draw, 1, 4, OUTPUT_WIDTH, OUTPUT_HEIGHT)
|
|
draw_text(draw, printable_data, font_regular, font_bold, font_bold_bigger)
|
|
draw_qr_code(output_image, qr_data)
|
|
|
|
try:
|
|
output_image.save(output_file)
|
|
logging.info(f"Image saved to {output_file}")
|
|
except Exception as e:
|
|
logging.error(f"Error saving image: {e}")
|
|
|
|
|
|
def main():
|
|
rehdd_info = ReHddInfo("https://git.mosad.xyz/localhorst/reHDD", "bV0.2.2")
|
|
|
|
temp_drive = DriveData(
|
|
drive_index=0,
|
|
drive_state="shredded",
|
|
modelfamily='Toshiba 2.5" HDD MK..65GSSX',
|
|
modelname="TOSHIBA MK3265GSDX",
|
|
capacity=343597383680,
|
|
serialnumber="YG6742U56UDRL123456789ABCDEFGJKL",
|
|
power_on_hours=7074,
|
|
power_cycle=4792,
|
|
smart_error_count=1,
|
|
shred_timestamp=datetime.datetime.now(datetime.timezone.utc).timestamp(),
|
|
shred_duration=81718,
|
|
)
|
|
|
|
generate_image(temp_drive, rehdd_info, "output.png")
|
|
|
|
if __name__ == "__main__":
|
|
main()
|