#!/usr/bin/env python3 """Export PPTX to PDF/PNG with DeckCraft, or PDF to PNG with PdfCraft.""" import argparse from decimal import Decimal import json import os from pathlib import Path import re import shutil import subprocess import sys import tempfile if __package__: from .progress import Progress, status else: from progress import Progress, status GHOSTSCRIPT_INSTALL_HELP = '''Ghostscript is installed as the `ghostscript` package; its command is `gs`: Debian / Ubuntu: sudo apt install ghostscript Fedora / RHEL: sudo dnf install ghostscript Arch Linux: sudo pacman -S ghostscript openSUSE: sudo zypper install ghostscript Alpine Linux: sudo apk add ghostscript macOS (Homebrew): brew install ghostscript''' def output_formats(value): formats = list(dict.fromkeys(item.strip().lower() for item in value.split(','))) if any(item not in ('pdf', 'images') for item in formats): raise argparse.ArgumentTypeError('Output must be pdf, images, or pdf,images.') return formats def positive_int(value): number = int(value) if number <= 0: raise argparse.ArgumentTypeError('Must be a positive integer.') return number def byte_size(value): match = re.fullmatch(r'\s*(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|KiB|MiB|GiB)?\s*', value, re.I) if not match: raise argparse.ArgumentTypeError('Use a positive size such as 5MB or 2.5MiB.') unit = (match[2] or 'B').upper() scale = {'B': 1, 'KB': 1000, 'MB': 1000**2, 'GB': 1000**3, 'KIB': 1024, 'MIB': 1024**2, 'GIB': 1024**3}[unit] size = int(Decimal(match[1]) * scale) if size < 1: raise argparse.ArgumentTypeError('Target size must be at least one byte.') return size def compress_pdf(source, work, quality, target_size, progress=None, requested_dpi=None): """Try bounded downsampling passes, always using the original PDF.""" original_size = source.stat().st_size if target_size and original_size < target_size: status(f'PDF already under target: {original_size:,} bytes.', 'success') return source, None gs = shutil.which('gs') if not gs: raise RuntimeError('PDF compression requires Ghostscript (`gs`).\n' + GHOSTSCRIPT_INSTALL_HELP) first_dpi = requested_dpi or {'original': 300, 'print': 300, 'email': 150, 'screen': 72}[quality] resolutions = [first_dpi] if target_size: resolutions += [dpi for dpi in (300, 150, 120, 96, 72, 50, 36) if dpi < first_dpi] if progress: progress.set(0, len(resolutions)) best, best_size, best_dpi = source, original_size, None for attempt, dpi in enumerate(resolutions, 1): status(f'Compressing PDF [{attempt}/{len(resolutions)}]: {dpi} DPI images' + (f', target < {target_size:,} bytes...' if target_size else '...')) candidate = work / f'compressed-{attempt}.pdf' command = [gs, '-sDEVICE=pdfwrite', '-dSAFER', '-dBATCH', '-dNOPAUSE', '-dPDFSETTINGS=/ebook', '-dAutoRotatePages=/None', '-dEmbedAllFonts=true', '-dSubsetFonts=true', '-dPassThroughJPEGImages=false', '-dPassThroughJPXImages=false', f'-sOutputFile={candidate}'] for kind in ('Color', 'Gray', 'Mono'): command += [f'-dDownsample{kind}Images=true', f'-d{kind}ImageResolution={dpi}', f'-d{kind}ImageDownsampleThreshold=1.0'] run([*command, '-f', source]) if not candidate.is_file() or not candidate.stat().st_size: raise RuntimeError('Ghostscript did not create a PDF.') size = candidate.stat().st_size if progress: progress.set(attempt) status(f'Compression pass: {size:,} bytes (original {original_size:,}).') if size < best_size: best, best_size, best_dpi = candidate, size, dpi if target_size and best_size < target_size: break if target_size and best_size >= target_size: raise RuntimeError(f'Could not reach target < {target_size:,} bytes; smallest result ' f'was {best_size:,} bytes' + (f' at {best_dpi} DPI' if best_dpi else ' without downsampling') + '. No output replaced. Try a larger target.') status(f'PDF size: {original_size:,} → {best_size:,} bytes.', 'success', persist=True) return best, best_dpi def run(command, **kwargs): result = subprocess.run([str(arg) for arg in command], capture_output=True, text=True, errors='replace', **kwargs) if result.returncode: detail = result.stderr.strip() or result.stdout.strip() or f'exit code {result.returncode}' raise RuntimeError(f'{Path(command[0]).name}: {detail}') if result.stderr.strip(): for line in result.stderr.strip().splitlines(): status(line, 'warning' if re.search(r'\b(warning|error)\b', line, re.I) else 'info') return result.stdout def find_cli(app, override, work): """Use PATH first, then a local AppImage's bundled CLI (no FUSE needed).""" candidate = override or os.environ.get(app.upper() + '_CLI') if candidate: path = Path(candidate).expanduser() if not path.is_file(): found = shutil.which(candidate) if not found: raise RuntimeError(f'Cannot find {app} executable: {candidate}') path = Path(found) else: found = shutil.which(f'{app}-cli') if found: path = Path(found) else: images = list((Path.home() / 'Applications').glob(f'{app}-*.AppImage')) # Natural version ordering: 0.10 follows 0.9. images.sort(key=lambda p: [int(n) for n in re.findall(r'\d+', p.name)], reverse=True) if not images: raise RuntimeError( f'{app}-cli not found. Install {app}, place its AppImage in ~/Applications, ' f'or pass --{app}-cli PATH (CLI executable or AppImage).') path = images[0] path = path.resolve() if path.suffix.lower() == '.appimage': status(f'Loading bundled {app}-cli from {path.name}...') unpack = work / app unpack.mkdir() run([path, '--appimage-extract', f'usr/bin/{app}-cli'], cwd=unpack) path = unpack / 'squashfs-root' / 'usr' / 'bin' / f'{app}-cli' if not path.is_file() or not os.access(path, os.X_OK): raise RuntimeError(f'CLI is missing or not executable: {path}') status(f'Using {app}: {path.name}') return path def export(source, formats, destination, dpi, overwrite, cli_override, progress=None, pdf_quality='original', target_size=None, pdf_dpi=None): is_deck = source.suffix.lower() == '.pptx' compression = pdf_quality != 'original' or target_size is not None or pdf_dpi is not None if not is_deck and 'pdf' in formats and not compression: status(f'Already PDF; nothing to convert: {source}', 'success', persist=True) formats = [format for format in formats if format != 'pdf'] if not formats: return pdf_target = destination / f'{source.stem}.pdf' images_target = destination / 'images' targets = ([pdf_target] if 'pdf' in formats else []) + ([images_target] if 'images' in formats else []) for target in targets: if target.is_symlink(): raise RuntimeError(f'Refusing to write through an output symlink: {target}') if target.exists() and not overwrite: raise RuntimeError(f'Output already exists: {target}. Use --overwrite to replace generated files.') if target.exists() and (target == images_target) != target.is_dir(): raise RuntimeError(f'Output has the wrong file type: {target}') if target.resolve() == source: raise RuntimeError(f'Output would replace the input: {source}') app = 'deckcraft' if is_deck else 'pdfcraft' with tempfile.TemporaryDirectory(prefix='exporter-') as temp: work = Path(temp) cli = find_cli(app, cli_override, work) if is_deck or 'images' in formats else None rendered = work / 'images' pdf = source selected_pdf_dpi = None if 'pdf' in formats: if is_deck: pdf = work / 'export.pdf' status('Exporting presentation to PDF...') run([cli, 'convert', source, pdf]) if not pdf.is_file() or not pdf.stat().st_size: raise RuntimeError('DeckCraft did not create a PDF.') if compression: pdf, selected_pdf_dpi = compress_pdf( pdf, work, pdf_quality, target_size, progress, pdf_dpi) if 'images' in formats: rendered.mkdir() if is_deck: status(f'Rendering all slides as PNG ({dpi} DPI)...') run([cli, 'render', source, '--all', '--scale', str(dpi / 72), rendered]) else: status('Reading PDF page count...') info = json.loads(run([cli, 'info', source])) pages = info.get('pages') if type(pages) is not int or pages < 1: raise RuntimeError('PdfCraft did not report a positive page count.') if progress: progress.set(0, pages) for page in range(1, pages + 1): status(f'[{page}/{pages}] Rendering page at {dpi} DPI...') run([cli, 'render', source, '--page', str(page), '--dpi', str(dpi), '--out', rendered / f'page-{page:04d}.png']) if progress: progress.set(page) images = sorted(rendered.glob('*.png')) if not images or any(image.stat().st_size == 0 for image in images): raise RuntimeError(f'{app} did not produce valid image output.') if not is_deck and len(images) != pages: raise RuntimeError('PdfCraft did not produce every requested page.') status(f'Rendered {len(images)} image(s).', 'success') # Publish only after all requested conversions succeed. destination.mkdir(parents=True, exist_ok=True) if 'pdf' in formats: shutil.copy2(pdf, pdf_target) detail = (f'{selected_pdf_dpi} DPI images; reuse with --pdf-dpi {selected_pdf_dpi}' if selected_pdf_dpi else 'original/native image resolution') status(f'PDF: {pdf_target} — {detail}', 'success', persist=True) if 'images' in formats: images_target.mkdir(exist_ok=True) if overwrite: for old in images_target.iterdir(): if re.fullmatch(r'(slide|page)-\d+\.png', old.name) and old.is_file(): old.unlink() for image in images: target = images_target / image.name if target.is_symlink(): raise RuntimeError(f'Refusing to write through an output symlink: {target}') shutil.copy2(image, target) status(f'Images: {images_target} — {dpi} DPI', 'success', persist=True) def main(argv=None): parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter, epilog='PDF compression dependency:\n' + GHOSTSCRIPT_INSTALL_HELP) parser.add_argument('file', type=Path, help='Source .pptx or .pdf') parser.add_argument('--output', required=True, type=output_formats, metavar='pdf,images', help='Comma-separated output formats: pdf, images') parser.add_argument('-d', '--output-dir', type=Path, help='Destination directory (default: _export)') parser.add_argument('--dpi', type=positive_int, default=144, help='PNG resolution (default: 144)') pdf_resolution = parser.add_mutually_exclusive_group() pdf_resolution.add_argument('--pdf-quality', choices=('original', 'print', 'email', 'screen'), default='original', help='PDF image quality: original (default), print ' '(300 DPI), email (150 DPI), screen (72 DPI). Requires Ghostscript.') pdf_resolution.add_argument('--pdf-dpi', type=positive_int, metavar='DPI', help='Exact PDF image resolution. Useful for reusing the result of ' '--target-size; requires Ghostscript.') parser.add_argument('--target-size', type=byte_size, metavar='SIZE', help='Try progressively stronger PDF compression to get below e.g. 5MB. ' 'Fails without publishing if the target cannot be reached.') parser.add_argument('--overwrite', action='store_true', help='Replace existing generated output files') parser.add_argument('--deckcraft-cli', help='DeckCraft CLI executable or AppImage') parser.add_argument('--pdfcraft-cli', help='PdfCraft CLI executable or AppImage') args = parser.parse_args(argv) if 'pdf' not in args.output and (args.pdf_quality != 'original' or args.pdf_dpi is not None or args.target_size is not None): parser.error('--pdf-quality, --pdf-dpi, and --target-size require --output pdf (or pdf,images).') source = args.file.expanduser().resolve() if source.suffix.lower() not in ('.pptx', '.pdf'): parser.error(f'Unsupported input type: {source.suffix or "(no extension)"}. Expected .pptx or .pdf.') if not source.is_file(): parser.error(f'Not a file: {source}') destination = (args.output_dir.expanduser() if args.output_dir else source.with_name(source.stem + '_export')).resolve() try: with Progress() as progress: status(f'Source: {source}') export(source, args.output, destination, args.dpi, args.overwrite, args.deckcraft_cli if source.suffix.lower() == '.pptx' else args.pdfcraft_cli, progress=progress, pdf_quality=args.pdf_quality, target_size=args.target_size, pdf_dpi=args.pdf_dpi) status('Done.', 'success', persist=True) return 0 except (OSError, RuntimeError, ValueError) as error: status(str(error), 'error') return 1 if __name__ == '__main__': sys.exit(main())