Spaces:
Sleeping
Sleeping
| # app.py | |
| import tempfile | |
| from pathlib import Path | |
| from typing import Tuple | |
| import gradio as gr | |
| from docx import Document | |
| from docx.shared import Inches | |
| from pypdf import PdfReader | |
| from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak | |
| from reportlab.lib.styles import getSampleStyleSheet | |
| from reportlab.lib.pagesizes import inch | |
| from reportlab.pdfbase import pdfmetrics | |
| from reportlab.pdfbase.ttfonts import TTFont | |
| # Register a standard font (optional) | |
| # pdfmetrics.registerFont(TTFont('DejaVu', 'DejaVuSans.ttf')) | |
| # --- KDP Constants --- | |
| TRIM_SIZES_INCHES = { | |
| "5\" × 8\"": (5.0, 8.0), | |
| "5.5\" × 8.5\"": (5.5, 8.5), | |
| "6\" × 9\" (Most Popular)": (6.0, 9.0), | |
| "7\" × 10\"": (7.0, 10.0), | |
| "8.5\" × 11\"": (8.5, 11.0), | |
| } | |
| GUTTER_MARGINS_INCHES = [ | |
| (150, 0.375), | |
| (300, 0.5), | |
| (500, 0.625), | |
| (700, 0.75), | |
| (828, 0.875), | |
| ] | |
| def extract_text_from_docx(docx_path: str) -> list: | |
| """Extract paragraphs from DOCX.""" | |
| doc = Document(docx_path) | |
| return [para.text for para in doc.paragraphs if para.text.strip()] | |
| def extract_text_from_pdf(pdf_path: str) -> list: | |
| """Extract text from PDF (simple).""" | |
| reader = PdfReader(pdf_path) | |
| text = [] | |
| for page in reader.pages: | |
| page_text = page.extract_text() | |
| if page_text: | |
| text.extend([line for line in page_text.split("\n") if line.strip()]) | |
| return text | |
| def apply_kdp_to_docx(docx_path: str, trim_w: float, trim_h: float, page_count: int, has_bleed: bool) -> str: | |
| doc = Document(docx_path) | |
| section = doc.sections[0] | |
| section.page_width = Inches(trim_w) | |
| section.page_height = Inches(trim_h) | |
| outside = 0.375 if has_bleed else 0.25 | |
| gutter = 0.375 | |
| for max_p, g in GUTTER_MARGINS_INCHES: | |
| if page_count <= max_p: | |
| gutter = g | |
| break | |
| section.top_margin = Inches(outside) | |
| section.bottom_margin = Inches(outside) | |
| section.left_margin = Inches(gutter) | |
| section.right_margin = Inches(outside) | |
| output_path = Path(tempfile.gettempdir()) / f"KDP_formatted_{Path(docx_path).stem}.docx" | |
| doc.save(output_path) | |
| return str(output_path) | |
| def create_pdf_from_text(text_lines: list, output_path: str, trim_w: float, trim_h: float, has_bleed: bool): | |
| """Create a simple PDF from text lines.""" | |
| page_size = (trim_w * inch, trim_h * inch) | |
| outside_margin = 0.375 if has_bleed else 0.25 | |
| doc = SimpleDocTemplate( | |
| output_path, | |
| pagesize=page_size, | |
| leftMargin=gutter_to_inch(len(text_lines)) * inch, # Approximate | |
| rightMargin=outside_margin * inch, | |
| topMargin=outside_margin * inch, | |
| bottomMargin=outside_margin * inch | |
| ) | |
| styles = getSampleStyleSheet() | |
| story = [] | |
| for line in text_lines: | |
| story.append(Paragraph(line, styles['Normal'])) | |
| story.append(Spacer(1, 6)) | |
| doc.build(story) | |
| def gutter_to_inch(page_count: int) -> float: | |
| gutter = 0.375 | |
| for max_p, g in GUTTER_MARGINS_INCHES: | |
| if page_count <= max_p: | |
| gutter = g | |
| break | |
| return gutter | |
| def process_file( | |
| input_file: str, | |
| trim_size: str, | |
| has_bleed: bool, | |
| page_count: int, | |
| ) -> Tuple[str, str, str]: | |
| file_path = Path(input_file) | |
| trim_w, trim_h = TRIM_SIZES_INCHES[trim_size] | |
| # Step 1: Extract text and get a working DOCX | |
| if file_path.suffix.lower() == ".pdf": | |
| text_lines = extract_text_from_pdf(str(file_path)) | |
| # Create a new DOCX from text | |
| temp_doc = Document() | |
| for line in text_lines: | |
| temp_doc.add_paragraph(line) | |
| docx_path = Path(tempfile.gettempdir()) / "temp_from_pdf.docx" | |
| temp_doc.save(docx_path) | |
| else: | |
| text_lines = extract_text_from_docx(str(file_path)) | |
| docx_path = file_path | |
| # Step 2: Format DOCX | |
| formatted_docx = apply_kdp_to_docx(str(docx_path), trim_w, trim_h, page_count, has_bleed) | |
| # Step 3: Create PDF from text | |
| formatted_pdf = Path(tempfile.gettempdir()) / f"KDP_formatted_{file_path.stem}.pdf" | |
| create_pdf_from_text(text_lines, str(formatted_pdf), trim_w, trim_h, has_bleed) | |
| info = f"Page Count Used: {page_count}\n⚠️ PDF is text-only (no images/formatting)." | |
| return formatted_docx, str(formatted_pdf), info | |
| # --- UI --- | |
| with gr.Blocks() as demo: | |
| gr.Markdown("# 📚 KDP Formatter (HF Spaces Compatible)") | |
| gr.Markdown("Upload `.docx` or `.pdf`. **PDF output is text-only** due to platform limits.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| input_file = gr.File(file_types=[".docx", ".pdf"]) | |
| trim_size = gr.Dropdown(choices=list(TRIM_SIZES_INCHES.keys()), value="6\" × 9\" (Most Popular)") | |
| page_count = gr.Number(value=300, minimum=24, maximum=828, label="Page Count") | |
| has_bleed = gr.Checkbox(label="Include Bleed") | |
| submit = gr.Button("Format") | |
| with gr.Column(): | |
| out_docx = gr.File(label="Formatted DOCX") | |
| out_pdf = gr.File(label="Formatted PDF (Text Only)") | |
| info = gr.Textbox(label="Info") | |
| submit.click( | |
| process_file, | |
| [input_file, trim_size, has_bleed, page_count], | |
| [out_docx, out_pdf, info] | |
| ) | |
| gr.Markdown("💡 For full PDF formatting, run this app locally with LibreOffice installed.") | |
| if __name__ == "__main__": | |
| demo.launch() |