pptx-lint 0.1.0__tar.gz

pptx_lint-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pptx-lint contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pptx_lint-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: pptx-lint
+Version: 0.1.0
+Summary: Lint / quality checker for python-pptx presentations — detects overflow, overlap, fake tables, small fonts, and empty slides
+License: MIT
+Keywords: pptx,powerpoint,lint,quality,python-pptx,presentation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-pptx>=0.6.21
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# pptx-lint
+
+**Lint / quality checker for python-pptx presentations.**
+
+[![PyPI](https://img.shields.io/pypi/v/pptx-lint)](https://pypi.org/project/pptx-lint/)
+[![Python](https://img.shields.io/pypi/pyversions/pptx-lint)](https://pypi.org/project/pptx-lint/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![CI](https://github.com/LeppardWang/pptx-lint/actions/workflows/test.yml/badge.svg)](https://github.com/LeppardWang/pptx-lint/actions/workflows/test.yml)
+
+---
+
+## Why?
+
+If you generate PowerPoint files with [python-pptx](https://python-pptx.readthedocs.io/),
+you've probably run into these problems:
+
+- 🔴 **Overflow** — Text boxes or tables exceeding slide boundaries
+- 🟡 **Overlap** — Shapes covering each other because of hard-coded coordinates
+- 🟡 **Fake tables** — Multiple text boxes trying (and failing) to look like a table
+- ℹ️ **Small fonts** — Text too small to read
+- 🔴 **Empty slides** — Slides without any content
+
+**pptx-lint** automatically detects all of these, giving you a clear report
+so you can fix them *before* presenting.
+
+---
+
+## Quick start
+
+```bash
+pip install pptx-lint
+
+# Check a single file
+pptx-lint presentation.pptx
+
+# Check all files in a directory
+pptx-lint ./output/
+```
+
+---
+
+## Example output
+
+```
+======================================================================
+  pptx-lint report
+  File: my_presentation.pptx
+======================================================================
+  Slides: 12  |  Empty: 0
+  Errors: 3  |  Warnings: 5  |  Infos: 2
+======================================================================
+
+[Slide 4]
+  Content: Performance Metrics | Results
+  ✗ [Overflow] Shape#3 (Performance table): right overflow (r=12.80" > 10.00")
+  ▲ [FakeTable] 6 text boxes form a grid (e.g.: Precision, Recall)
+
+[Slide 7]
+  Content: System Architecture Overview
+  ▲ [Overlap] Shape#2 overlaps Shape#4 — overlap area: 2.30 sq.in.
+
+[Slide 9]
+  Content: References
+  i [SmallFont] Shape#1: 'Acknowledgements' font = 7pt (< 8pt)
+```
+
+---
+
+## Checks
+
+| Rule | Severity | What it detects |
+|------|----------|-----------------|
+| **Overflow** | 🔴 Error | Shapes whose `left`/`top` < 0 or `right`/`bottom` > slide dimensions |
+| **Empty slide** | 🔴 Error | Slides with zero shapes |
+| **Overlap** | 🟡 Warning | Two shapes overlapping > 50% of the smaller shape's area |
+| **Fake table** | 🟡 Warning | ≥4 text boxes arranged in a ≥2×2 grid (should use `add_table()`) |
+| **Small font** | ℹ️ Info | Text smaller than 8 pt |
+
+---
+
+## Use as a library
+
+```python
+from pptx_lint.checker import check_pptx
+
+results, filename = check_pptx("my_slides.pptx")
+for slide in results:
+    for err in slide['errors']:
+        print(f"Slide {slide['slide_num']}: {err['detail']}")
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/LeppardWang/pptx-lint.git
+cd pptx-lint
+pip install -e ".[dev]"
+pytest
+```
+
+---
+
+## Related
+
+- [python-pptx](https://python-pptx.readthedocs.io/) — the library that creates `.pptx` files
+- [python-pptx-table](https://pypi.org/project/python-pptx-table/) — helpers for Table objects
+
+---
+
+## License
+
+MIT

pptx_lint-0.1.0/README.md

@@ -0,0 +1,114 @@
+# pptx-lint
+
+**Lint / quality checker for python-pptx presentations.**
+
+[![PyPI](https://img.shields.io/pypi/v/pptx-lint)](https://pypi.org/project/pptx-lint/)
+[![Python](https://img.shields.io/pypi/pyversions/pptx-lint)](https://pypi.org/project/pptx-lint/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![CI](https://github.com/LeppardWang/pptx-lint/actions/workflows/test.yml/badge.svg)](https://github.com/LeppardWang/pptx-lint/actions/workflows/test.yml)
+
+---
+
+## Why?
+
+If you generate PowerPoint files with [python-pptx](https://python-pptx.readthedocs.io/),
+you've probably run into these problems:
+
+- 🔴 **Overflow** — Text boxes or tables exceeding slide boundaries
+- 🟡 **Overlap** — Shapes covering each other because of hard-coded coordinates
+- 🟡 **Fake tables** — Multiple text boxes trying (and failing) to look like a table
+- ℹ️ **Small fonts** — Text too small to read
+- 🔴 **Empty slides** — Slides without any content
+
+**pptx-lint** automatically detects all of these, giving you a clear report
+so you can fix them *before* presenting.
+
+---
+
+## Quick start
+
+```bash
+pip install pptx-lint
+
+# Check a single file
+pptx-lint presentation.pptx
+
+# Check all files in a directory
+pptx-lint ./output/
+```
+
+---
+
+## Example output
+
+```
+======================================================================
+  pptx-lint report
+  File: my_presentation.pptx
+======================================================================
+  Slides: 12  |  Empty: 0
+  Errors: 3  |  Warnings: 5  |  Infos: 2
+======================================================================
+
+[Slide 4]
+  Content: Performance Metrics | Results
+  ✗ [Overflow] Shape#3 (Performance table): right overflow (r=12.80" > 10.00")
+  ▲ [FakeTable] 6 text boxes form a grid (e.g.: Precision, Recall)
+
+[Slide 7]
+  Content: System Architecture Overview
+  ▲ [Overlap] Shape#2 overlaps Shape#4 — overlap area: 2.30 sq.in.
+
+[Slide 9]
+  Content: References
+  i [SmallFont] Shape#1: 'Acknowledgements' font = 7pt (< 8pt)
+```
+
+---
+
+## Checks
+
+| Rule | Severity | What it detects |
+|------|----------|-----------------|
+| **Overflow** | 🔴 Error | Shapes whose `left`/`top` < 0 or `right`/`bottom` > slide dimensions |
+| **Empty slide** | 🔴 Error | Slides with zero shapes |
+| **Overlap** | 🟡 Warning | Two shapes overlapping > 50% of the smaller shape's area |
+| **Fake table** | 🟡 Warning | ≥4 text boxes arranged in a ≥2×2 grid (should use `add_table()`) |
+| **Small font** | ℹ️ Info | Text smaller than 8 pt |
+
+---
+
+## Use as a library
+
+```python
+from pptx_lint.checker import check_pptx
+
+results, filename = check_pptx("my_slides.pptx")
+for slide in results:
+    for err in slide['errors']:
+        print(f"Slide {slide['slide_num']}: {err['detail']}")
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/LeppardWang/pptx-lint.git
+cd pptx-lint
+pip install -e ".[dev]"
+pytest
+```
+
+---
+
+## Related
+
+- [python-pptx](https://python-pptx.readthedocs.io/) — the library that creates `.pptx` files
+- [python-pptx-table](https://pypi.org/project/python-pptx-table/) — helpers for Table objects
+
+---
+
+## License
+
+MIT

pptx_lint-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pptx-lint"
+version = "0.1.0"
+description = "Lint / quality checker for python-pptx presentations — detects overflow, overlap, fake tables, small fonts, and empty slides"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+dependencies = [
+    "python-pptx>=0.6.21",
+]
+keywords = ["pptx", "powerpoint", "lint", "quality", "python-pptx", "presentation"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.1.0",
+]
+
+[project.scripts]
+pptx-lint = "pptx_lint.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

pptx_lint-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pptx_lint-0.1.0/src/pptx_lint/__init__.py

@@ -0,0 +1,7 @@
+"""pptx-lint: Quality checker for python-pptx presentations."""
+
+__version__ = "0.1.0"
+__description__ = (
+    "Detects overflow, overlap, fake tables, small fonts, "
+    "and empty slides in python-pptx generated presentations."
+)

pptx_lint-0.1.0/src/pptx_lint/checker.py

@@ -0,0 +1,163 @@
+"""Core checker: orchestrate all lint rules against one or more PPTX files."""
+
+import os
+from pptx import Presentation
+
+from .utils import emu_to_inches, emu_to_pt
+from . import rules
+
+
+def get_shape_bounds(shape):
+    """Return (left, top, width, height, right, bottom) in inches."""
+    try:
+        left = emu_to_inches(shape.left)
+        top = emu_to_inches(shape.top)
+        w = emu_to_inches(shape.width)
+        h = emu_to_inches(shape.height)
+        return left, top, w, h, left + w, top + h
+    except Exception:
+        return None
+
+
+def get_shape_texts(shape):
+    """Extract plain text from a shape (text-frame or table)."""
+    texts = []
+    if shape.has_text_frame:
+        for p in shape.text_frame.paragraphs:
+            t = p.text.strip()
+            if t:
+                texts.append(t)
+    if shape.has_table:
+        table = shape.table
+        for row in table.rows:
+            parts = []
+            for cell in row.cells:
+                t = cell.text.strip()
+                if t:
+                    parts.append(t)
+            if parts:
+                texts.append(' | '.join(parts))
+    return texts
+
+
+def collect_shapes_info(slide):
+    """Return list of shape info dicts for a single slide."""
+    infos = []
+    for idx, shape in enumerate(slide.shapes):
+        bounds = get_shape_bounds(shape)
+        if bounds is None:
+            continue
+
+        texts = get_shape_texts(shape)
+
+        font_info = []
+        if shape.has_text_frame:
+            for p in shape.text_frame.paragraphs:
+                if p.text.strip():
+                    sz = p.font.size
+                    font_info.append({
+                        'text': p.text.strip(),
+                        'size': emu_to_pt(sz) if sz else None,
+                    })
+
+        infos.append({
+            'idx': idx,
+            'bounds': bounds,
+            'texts': texts,
+            'font_info': font_info,
+            'type': str(shape.shape_type),
+        })
+    return infos
+
+
+def check_slide(slide, slide_num, sw, sh):
+    """Run all lint rules against one slide.
+
+    Returns a dict with keys:
+        slide_num, errors, warnings, infos, text_content, is_empty
+    """
+    result = {
+        'slide_num': slide_num,
+        'total_shapes': len(slide.shapes),
+        'errors': [],
+        'warnings': [],
+        'infos': [],
+        'text_content': [],
+        'is_empty': True,
+    }
+
+    shapes_info = collect_shapes_info(slide)
+    for info in shapes_info:
+        result['text_content'].extend(info['texts'])
+    result['is_empty'] = len(result['text_content']) == 0
+
+    # ── overflow (error) ──
+    for issue in rules.overflow.check(sw, sh, shapes_info):
+        result['errors'].append({
+            'type': 'Overflow',
+            'detail': (
+                f"Shape#{issue['shape_idx']} ({issue['shape_name']}): "
+                f"{' | '.join(issue['issues'])}"
+            ),
+            'bounds': (
+                f"({issue['bounds'][0]:.2f}, {issue['bounds'][1]:.2f}, "
+                f"{issue['bounds'][2]:.2f}, {issue['bounds'][3]:.2f})"
+            ),
+        })
+
+    # ── empty slide (error) ──
+    if result['total_shapes'] == 0:
+        result['errors'].append({
+            'type': 'EmptySlide',
+            'detail': 'Slide has no shapes at all.',
+        })
+
+    # ── overlap (warning) ──
+    for issue in rules.overlap.check(shapes_info):
+        result['warnings'].append({
+            'type': 'Overlap',
+            'detail': (
+                f"Shape#{issue['shapes'][0]} ({issue['names'][0]}) "
+                f"overlaps Shape#{issue['shapes'][1]} ({issue['names'][1]}) "
+                f"— overlap area: {issue['overlap_area']}"
+            ),
+        })
+
+    # ── fake table (warning) ──
+    for issue in rules.fake_table.check(shapes_info):
+        samples = ', '.join(issue['sample_texts'])
+        result['warnings'].append({
+            'type': 'FakeTable',
+            'detail': (
+                f"{issue['shape_count']} text boxes form a grid-like layout "
+                f"(e.g.: {samples}) — consider using ``add_table()`` instead."
+            ),
+        })
+
+    # ── small font (info) ──
+    for issue in rules.font_size.check(shapes_info):
+        result['infos'].append({
+            'type': 'SmallFont',
+            'detail': (
+                f"Shape#{issue['shape_idx']}: '{issue['text']}' "
+                f"font size = {issue['font_size']:.0f}pt "
+                f"(< {rules.font_size.MIN_FONT_SIZE}pt)"
+            ),
+        })
+
+    return result
+
+
+def check_pptx(filepath):
+    """Run all checks on a single .pptx file.
+
+    Returns list of slide-level result dicts.
+    """
+    prs = Presentation(filepath)
+    sw = emu_to_inches(prs.slide_width)
+    sh = emu_to_inches(prs.slide_height)
+
+    all_results = []
+    for si, slide in enumerate(prs.slides):
+        all_results.append(check_slide(slide, si + 1, sw, sh))
+    return all_results, os.path.basename(filepath)

pptx_lint-0.1.0/src/pptx_lint/cli.py

@@ -0,0 +1,72 @@
+"""Command-line interface for pptx-lint."""
+
+import sys
+import os
+
+from . import __version__
+from .checker import check_pptx
+from .reporters.console import print_report
+
+
+def collect_targets(args):
+    """Resolve CLI args to a list of .pptx file paths."""
+    files = []
+    for arg in args:
+        if os.path.isdir(arg):
+            for f in os.listdir(arg):
+                if f.endswith('.pptx'):
+                    files.append(os.path.join(arg, f))
+        elif os.path.isfile(arg) and arg.endswith('.pptx'):
+            files.append(arg)
+        else:
+            print(f"[pptx-lint] Skipping: {arg} (not a .pptx file)")
+    return files
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(f"pptx-lint v{__version__}")
+        print()
+        print("Usage:  pptx-lint <file.pptx> [file.pptx ...]")
+        print("        pptx-lint <directory>")
+        print()
+        print("Examples:")
+        print("  pptx-lint my_presentation.pptx")
+        print("  pptx-lint ./output/")
+        sys.exit(1)
+
+    targets = collect_targets(sys.argv[1:])
+    if not targets:
+        print("[pptx-lint] No .pptx files found.")
+        sys.exit(1)
+
+    print(f"\n{'=' * 70}")
+    print(f"  pptx-lint v{__version__}  —  {len(targets)} file(s)")
+    print(f"{'=' * 70}")
+
+    grand_total = {'errors': 0, 'warnings': 0, 'infos': 0}
+
+    for fpath in targets:
+        results, name = check_pptx(fpath)
+        total_e = sum(len(r['errors']) for r in results)
+        total_w = sum(len(r['warnings']) for r in results)
+        total_i = sum(len(r['infos']) for r in results)
+        grand_total['errors'] += total_e
+        grand_total['warnings'] += total_w
+        grand_total['infos'] += total_i
+
+        print_report(results, name)
+
+    print(f"{'=' * 70}")
+    print(f"  Grand total across all files:")
+    print(f"    🔴  {grand_total['errors']} errors")
+    print(f"    🟡  {grand_total['warnings']} warnings")
+    print(f"    ℹ️   {grand_total['infos']} infos")
+    print(f"{'=' * 70}\n")
+
+    if grand_total['errors'] > 0:
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

pptx_lint-0.1.0/src/pptx_lint/reporters/__init__.py

@@ -0,0 +1 @@
+"""Reporters for pptx-lint (pluggable output formats)."""

pptx_lint-0.1.0/src/pptx_lint/reporters/console.py

@@ -0,0 +1,58 @@
+"""Console (terminal) reporter for pptx-lint."""
+
+from ..utils import red, yellow, cyan, blue, green, bold
+
+
+def print_report(all_results, filename):
+    """Print a colourised per-file report to stdout."""
+    total_e = sum(len(r['errors']) for r in all_results)
+    total_w = sum(len(r['warnings']) for r in all_results)
+    total_i = sum(len(r['infos']) for r in all_results)
+    total_slides = len(all_results)
+    empty = sum(1 for r in all_results if r['is_empty'])
+
+    print(f"\n{'=' * 70}")
+    print(f"  {bold('pptx-lint report')}")
+    print(f"  File: {blue(filename)}")
+    print(f"{'=' * 70}")
+    print(f"  Slides: {total_slides}  |  Empty: {empty}")
+    print(f"  {red(f'Errors: {total_e}')}  "
+          f"{yellow(f'Warnings: {total_w}')}  "
+          f"{cyan(f'Infos: {total_i}')}")
+    print(f"{'=' * 70}")
+
+    for result in all_results:
+        sn = result['slide_num']
+        if not (result['errors'] or result['warnings'] or result['infos']):
+            continue
+
+        label = f'[Slide {sn}]'
+        empty_label = ' (EMPTY)' if result['is_empty'] else ''
+        print(f"\n{green(label)}{empty_label}")
+
+        if result['text_content']:
+            preview = ' | '.join(result['text_content'][:2])
+            if len(preview) > 80:
+                preview = preview[:80] + '...'
+            print(f"  {blue('Content:')} {preview}")
+
+        for e in result['errors']:
+            et = e['type']
+            print(f"  {red('  ✗ [' + et + ']')} {e['detail']}")
+
+        for w in result['warnings']:
+            wt = w['type']
+            print(f"  {yellow('  ▲ [' + wt + ']')} {w['detail']}")
+
+        for i in result['infos']:
+            it = i['type']
+            print(f"  {cyan('  i [' + it + ']')} {i['detail']}")
+
+    # Summary line
+    if total_e == 0 and total_w == 0:
+        print(f"\n  {green('✓ No issues found!')}")
+    elif total_e == 0:
+        print(f"\n  {yellow('⚠ Warnings only, no errors.')}")
+    else:
+        print(f"\n  {red('✗ Errors detected — review above.')}")
+    print()

pptx_lint-0.1.0/src/pptx_lint/rules/__init__.py

@@ -0,0 +1,8 @@
+"""Lint rules for pptx-lint."""
+
+from . import overflow
+from . import overlap
+from . import fake_table
+from . import font_size
+
+__all__ = ['overflow', 'overlap', 'fake_table', 'font_size']

pptx_lint-0.1.0/src/pptx_lint/rules/fake_table.py

@@ -0,0 +1,65 @@
+"""Fake-table rule: detect multiple text boxes arranged as a grid
+that should probably be a proper ``Table`` object instead.
+"""
+
+EPSILON = 0.25  # inches — alignment tolerance
+
+
+def check(shapes_info):
+    """Return list of fake-table issues (warning severity).
+
+    Detection criteria:
+    * at least 4 text-carrying shapes
+    * shapes can be grouped into ≥2 rows (by Y-centre)
+    * at least 2 of those rows have ≥2 shapes each
+    """
+    text_shapes = []
+    for info in shapes_info:
+        l, t, w, h, r, b = info['bounds']
+        if w > 0.3 and h > 0.2 and info['texts'] and l >= 0 and t >= 0:
+            text_shapes.append({
+                'idx': info['idx'],
+                'left': l, 'top': t, 'w': w, 'h': h,
+                'cx': l + w / 2, 'cy': t + h / 2,
+                'texts': info['texts'],
+            })
+
+    if len(text_shapes) < 4:
+        return []
+
+    # Group by row (similar Y-centre)
+    rows = []
+    used = set()
+    for ts in text_shapes:
+        if ts['idx'] in used:
+            continue
+        row = [ts]
+        used.add(ts['idx'])
+        for ts2 in text_shapes:
+            if ts2['idx'] in used:
+                continue
+            if abs(ts2['cy'] - ts['cy']) < EPSILON:
+                row.append(ts2)
+                used.add(ts2['idx'])
+        rows.append(row)
+
+    if len(rows) < 2:
+        return []
+
+    multi_col = [r for r in rows if len(r) >= 2]
+    if len(multi_col) < 2:
+        return []
+
+    total = sum(len(r) for r in multi_col)
+    samples = []
+    for r in multi_col[:2]:
+        for ts in r[:2]:
+            if ts['texts']:
+                samples.append(ts['texts'][0][:30])
+
+    return [{
+        'shape_count': total,
+        'rows': len(multi_col),
+        'sample_texts': samples[:3],
+        'severity': 'WARN',
+    }]

pptx_lint-0.1.0/src/pptx_lint/rules/font_size.py

@@ -0,0 +1,18 @@
+"""Font-size rule: detect text smaller than a minimum threshold."""
+
+MIN_FONT_SIZE = 8  # points
+
+
+def check(shapes_info):
+    """Return list of font-size issues (info severity)."""
+    issues = []
+    for info in shapes_info:
+        for fi in info.get('font_info', []):
+            if fi['size'] is not None and fi['size'] < MIN_FONT_SIZE:
+                issues.append({
+                    'shape_idx': info['idx'],
+                    'text': fi['text'][:40],
+                    'font_size': fi['size'],
+                    'severity': 'INFO',
+                })
+    return issues

pptx_lint-0.1.0/src/pptx_lint/rules/overflow.py

@@ -0,0 +1,45 @@
+"""Overflow rule: detect shapes that exceed slide boundaries."""
+
+from ..utils import emu_to_inches
+
+
+def check(slide_width, slide_height, shapes_info):
+    """Return list of overflow issues.
+
+    Each issue dict:
+        shape_idx, shape_name, bounds, issues (list of str), texts
+    """
+    issues = []
+    sw = slide_width   # already in inches
+    sh = slide_height
+
+    TOLERANCE = 0.05  # inches, small positive margin
+
+    for info in shapes_info:
+        left, top, width, height, right, bottom = info['bounds']
+        name = (info['texts'][0] if info['texts']
+                else f"Shape {info['idx']}")
+
+        overflow_msgs = []
+        if left < 0:
+            overflow_msgs.append(f"left overflow ({left:.2f}\")")
+        if top < 0:
+            overflow_msgs.append(f"top overflow ({top:.2f}\")")
+        if right > sw + TOLERANCE:
+            overflow_msgs.append(
+                f"right overflow (r={right:.2f}\" > {sw:.2f}\")")
+        if bottom > sh + TOLERANCE:
+            overflow_msgs.append(
+                f"bottom overflow (b={bottom:.2f}\" > {sh:.2f}\")")
+
+        if overflow_msgs:
+            issues.append({
+                'shape_idx': info['idx'],
+                'shape_name': name,
+                'bounds': (left, top, width, height),
+                'issues': overflow_msgs,
+                'severity': 'ERROR',
+                'texts': info['texts'],
+            })
+
+    return issues

pptx_lint-0.1.0/src/pptx_lint/rules/overlap.py

@@ -0,0 +1,48 @@
+"""Overlap rule: detect shapes that overlap each other."""
+
+
+def check(shapes_info):
+    """Return list of overlap issues (warning severity)."""
+    issues = []
+    rects = []
+
+    for info in shapes_info:
+        l, t, w, h, r, b = info['bounds']
+        if w == 0 or h == 0:
+            continue
+        rects.append((info['idx'], l, t, r, b, info['texts'], w * h))
+
+    if not rects:
+        return issues
+
+    max_area = max(a for (_, _, _, _, _, _, a) in rects)
+
+    for i in range(len(rects)):
+        for j in range(i + 1, len(rects)):
+            idx1, l1, t1, r1, b1, t1s, a1 = rects[i]
+            idx2, l2, t2, r2, b2, t2s, a2 = rects[j]
+
+            # Skip full-slide background shapes (no text, huge area)
+            if a1 > max_area * 0.8 and not t1s:
+                continue
+            if a2 > max_area * 0.8 and not t2s:
+                continue
+
+            ox = max(0.0, min(r1, r2) - max(l1, l2))
+            oy = max(0.0, min(b1, b2) - max(t1, t2))
+
+            if ox > 0 and oy > 0:
+                oa = ox * oy
+                threshold = min(a1, a2) * 0.5
+                if oa > threshold:
+                    name1 = t1s[0] if t1s else f"Shape {idx1}"
+                    name2 = t2s[0] if t2s else f"Shape {idx2}"
+                    issues.append({
+                        'shapes': (idx1, idx2),
+                        'names': (name1, name2),
+                        'overlap_area': f"{oa:.2f} sq.in.",
+                        'severity': 'WARN',
+                        'texts': (t1s, t2s),
+                    })
+
+    return issues

pptx_lint-0.1.0/src/pptx_lint/utils.py

@@ -0,0 +1,44 @@
+"""Shared utilities for pptx-lint."""
+
+from pptx.util import Emu, Pt
+
+
+def emu_to_inches(emu):
+    """Convert EMU (English Metric Unit) to inches."""
+    if emu is None:
+        return 0.0
+    return emu / 914400
+
+
+def emu_to_pt(emu):
+    """Convert EMU to points (font size)."""
+    if emu is None:
+        return None
+    return emu / 12700
+
+
+def inches(x):
+    """Alias: convert inches to EMU via python-pptx helper."""  # noqa
+    # We keep the emu_to_inches path for readability.
+    # Actual inches-to-EMU is done by pptx.util.Inches downstream.
+    return x
+
+
+# ── Terminal colours ──────────────────────────────────────────
+
+class Colors:
+    RED = '\033[91m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    RESET = '\033[0m'
+    BOLD = '\033[1m'
+
+
+def red(s): return f"{Colors.RED}{s}{Colors.RESET}"
+def yellow(s): return f"{Colors.YELLOW}{s}{Colors.RESET}"
+def blue(s): return f"{Colors.BLUE}{s}{Colors.RESET}"
+def cyan(s): return f"{Colors.CYAN}{s}{Colors.RESET}"
+def green(s): return f"{Colors.GREEN}{s}{Colors.RESET}"
+def bold(s): return f"{Colors.BOLD}{s}{Colors.RESET}"

pptx_lint-0.1.0/src/pptx_lint.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: pptx-lint
+Version: 0.1.0
+Summary: Lint / quality checker for python-pptx presentations — detects overflow, overlap, fake tables, small fonts, and empty slides
+License: MIT
+Keywords: pptx,powerpoint,lint,quality,python-pptx,presentation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-pptx>=0.6.21
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# pptx-lint
+
+**Lint / quality checker for python-pptx presentations.**
+
+[![PyPI](https://img.shields.io/pypi/v/pptx-lint)](https://pypi.org/project/pptx-lint/)
+[![Python](https://img.shields.io/pypi/pyversions/pptx-lint)](https://pypi.org/project/pptx-lint/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![CI](https://github.com/LeppardWang/pptx-lint/actions/workflows/test.yml/badge.svg)](https://github.com/LeppardWang/pptx-lint/actions/workflows/test.yml)
+
+---
+
+## Why?
+
+If you generate PowerPoint files with [python-pptx](https://python-pptx.readthedocs.io/),
+you've probably run into these problems:
+
+- 🔴 **Overflow** — Text boxes or tables exceeding slide boundaries
+- 🟡 **Overlap** — Shapes covering each other because of hard-coded coordinates
+- 🟡 **Fake tables** — Multiple text boxes trying (and failing) to look like a table
+- ℹ️ **Small fonts** — Text too small to read
+- 🔴 **Empty slides** — Slides without any content
+
+**pptx-lint** automatically detects all of these, giving you a clear report
+so you can fix them *before* presenting.
+
+---
+
+## Quick start
+
+```bash
+pip install pptx-lint
+
+# Check a single file
+pptx-lint presentation.pptx
+
+# Check all files in a directory
+pptx-lint ./output/
+```
+
+---
+
+## Example output
+
+```
+======================================================================
+  pptx-lint report
+  File: my_presentation.pptx
+======================================================================
+  Slides: 12  |  Empty: 0
+  Errors: 3  |  Warnings: 5  |  Infos: 2
+======================================================================
+
+[Slide 4]
+  Content: Performance Metrics | Results
+  ✗ [Overflow] Shape#3 (Performance table): right overflow (r=12.80" > 10.00")
+  ▲ [FakeTable] 6 text boxes form a grid (e.g.: Precision, Recall)
+
+[Slide 7]
+  Content: System Architecture Overview
+  ▲ [Overlap] Shape#2 overlaps Shape#4 — overlap area: 2.30 sq.in.
+
+[Slide 9]
+  Content: References
+  i [SmallFont] Shape#1: 'Acknowledgements' font = 7pt (< 8pt)
+```
+
+---
+
+## Checks
+
+| Rule | Severity | What it detects |
+|------|----------|-----------------|
+| **Overflow** | 🔴 Error | Shapes whose `left`/`top` < 0 or `right`/`bottom` > slide dimensions |
+| **Empty slide** | 🔴 Error | Slides with zero shapes |
+| **Overlap** | 🟡 Warning | Two shapes overlapping > 50% of the smaller shape's area |
+| **Fake table** | 🟡 Warning | ≥4 text boxes arranged in a ≥2×2 grid (should use `add_table()`) |
+| **Small font** | ℹ️ Info | Text smaller than 8 pt |
+
+---
+
+## Use as a library
+
+```python
+from pptx_lint.checker import check_pptx
+
+results, filename = check_pptx("my_slides.pptx")
+for slide in results:
+    for err in slide['errors']:
+        print(f"Slide {slide['slide_num']}: {err['detail']}")
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/LeppardWang/pptx-lint.git
+cd pptx-lint
+pip install -e ".[dev]"
+pytest
+```
+
+---
+
+## Related
+
+- [python-pptx](https://python-pptx.readthedocs.io/) — the library that creates `.pptx` files
+- [python-pptx-table](https://pypi.org/project/python-pptx-table/) — helpers for Table objects
+
+---
+
+## License
+
+MIT

pptx_lint-0.1.0/src/pptx_lint.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+src/pptx_lint/__init__.py
+src/pptx_lint/checker.py
+src/pptx_lint/cli.py
+src/pptx_lint/utils.py
+src/pptx_lint.egg-info/PKG-INFO
+src/pptx_lint.egg-info/SOURCES.txt
+src/pptx_lint.egg-info/dependency_links.txt
+src/pptx_lint.egg-info/entry_points.txt
+src/pptx_lint.egg-info/requires.txt
+src/pptx_lint.egg-info/top_level.txt
+src/pptx_lint/reporters/__init__.py
+src/pptx_lint/reporters/console.py
+src/pptx_lint/rules/__init__.py
+src/pptx_lint/rules/fake_table.py
+src/pptx_lint/rules/font_size.py
+src/pptx_lint/rules/overflow.py
+src/pptx_lint/rules/overlap.py
+tests/test_checker.py

pptx_lint-0.1.0/src/pptx_lint.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pptx_lint-0.1.0/src/pptx_lint.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pptx-lint = pptx_lint.cli:main

pptx_lint-0.1.0/src/pptx_lint.egg-info/requires.txt

@@ -0,0 +1,5 @@
+python-pptx>=0.6.21
+
+[dev]
+pytest>=7.0
+ruff>=0.1.0

pptx_lint-0.1.0/src/pptx_lint.egg-info/top_level.txt

@@ -0,0 +1 @@
+pptx_lint

pptx_lint-0.1.0/tests/test_checker.py

@@ -0,0 +1,155 @@
+"""Basic tests for pptx-lint rules."""
+
+from pptx import Presentation
+from pptx.util import Inches
+
+from pptx_lint.utils import emu_to_inches
+from pptx_lint import rules
+
+
+def _make_dummy_shapes_info():
+    """Return a shapes_info list with two non-overlapping text boxes."""
+    return [
+        {
+            'idx': 0,
+            'bounds': (0.5, 0.5, 4.0, 0.5, 4.5, 1.0),
+            'texts': ['Left box'],
+            'font_info': [{'text': 'Left box', 'size': 14}],
+            'type': 'TEXT_BOX',
+        },
+        {
+            'idx': 1,
+            'bounds': (5.0, 0.5, 4.0, 0.5, 9.0, 1.0),
+            'texts': ['Right box'],
+            'font_info': [{'text': 'Right box', 'size': 14}],
+            'type': 'TEXT_BOX',
+        },
+    ]
+
+
+# ── overflow ──────────────────────────────────────────────────
+
+def test_overflow_no_error():
+    infos = _make_dummy_shapes_info()
+    issues = rules.overflow.check(10.0, 7.5, infos)
+    assert len(issues) == 0
+
+
+def test_overflow_right_edge():
+    infos = _make_dummy_shapes_info()
+    infos[0]['bounds'] = (0.5, 0.5, 10.0, 0.5, 10.5, 1.0)  # 10.5 > 10.0
+    issues = rules.overflow.check(10.0, 7.5, infos)
+    assert len(issues) == 1
+    assert 'right' in issues[0]['issues'][0]
+
+
+def test_overflow_bottom_edge():
+    infos = _make_dummy_shapes_info()
+    infos[0]['bounds'] = (0.5, 7.6, 4.0, 0.5, 4.5, 8.1)  # 8.1 > 7.5
+    issues = rules.overflow.check(10.0, 7.5, infos)
+    assert len(issues) == 1
+    assert 'bottom' in issues[0]['issues'][0]
+
+
+# ── overlap ───────────────────────────────────────────────────
+
+def test_overlap_none():
+    infos = _make_dummy_shapes_info()
+    issues = rules.overlap.check(infos)
+    assert len(issues) == 0
+
+
+def test_overlap_detected():
+    # Two boxes at the exact same position
+    infos = _make_dummy_shapes_info()
+    infos.append({
+        'idx': 2,
+        'bounds': (0.5, 0.5, 4.0, 0.5, 4.5, 1.0),
+        'texts': ['Overlapping'],
+        'font_info': [],
+        'type': 'TEXT_BOX',
+    })
+    issues = rules.overlap.check(infos)
+    assert len(issues) >= 1
+
+
+# ── fake table ────────────────────────────────────────────────
+
+def test_fake_table_none_for_list():
+    """A vertical list (same column, many rows) is NOT a fake table."""
+    infos = []
+    for i in range(6):
+        infos.append({
+            'idx': i,
+            'bounds': (0.5, 1.0 + i * 0.5, 4.0, 0.4, 4.5, 1.4 + i * 0.5),
+            'texts': [f'Item {i}'],
+            'font_info': [],
+            'type': 'TEXT_BOX',
+        })
+    issues = rules.fake_table.check(infos)
+    assert len(issues) == 0
+
+
+def test_fake_table_detected_for_grid():
+    """A 2×2 grid IS a fake table."""
+    infos = []
+    for row in range(2):
+        for col in range(2):
+            infos.append({
+                'idx': row * 2 + col,
+                'bounds': (
+                    0.5 + col * 4.5,
+                    1.0 + row * 0.6,
+                    4.0,
+                    0.5,
+                    4.5 + col * 4.5,
+                    1.5 + row * 0.6,
+                ),
+                'texts': [f'R{row}C{col}'],
+                'font_info': [],
+                'type': 'TEXT_BOX',
+            })
+    issues = rules.fake_table.check(infos)
+    assert len(issues) == 1
+
+
+# ── font size ─────────────────────────────────────────────────
+
+def test_small_font_detected():
+    infos = _make_dummy_shapes_info()
+    infos[0]['font_info'] = [{'text': 'tiny', 'size': 6}]  # 6pt < 8pt
+    issues = rules.font_size.check(infos)
+    assert len(issues) == 1
+    assert issues[0]['font_size'] == 6
+
+
+# ── end-to-end via checker ────────────────────────────────────
+
+def _create_minimal_pptx(tmp_path):
+    """Create a minimal .pptx for integration testing."""
+    from pptx import Presentation
+    prs = Presentation()
+    prs.slide_width = Inches(10)
+    prs.slide_height = Inches(7.5)
+    slide = prs.slides.add_slide(prs.slide_layouts[6])
+    from pptx.util import Pt
+    from pptx.enum.text import PP_ALIGN
+    txBox = slide.shapes.add_textbox(Inches(0.5), Inches(0.5),
+                                      Inches(9.0), Inches(0.5))
+    tf = txBox.text_frame
+    p = tf.paragraphs[0]
+    p.text = "Hello pptx-lint"
+    p.font.size = Pt(14)
+    path = tmp_path / "test.pptx"
+    prs.save(str(path))
+    return str(path)
+
+
+def test_end_to_end(tmp_path):
+    path = _create_minimal_pptx(tmp_path)
+    from pptx_lint.checker import check_pptx
+    results, name = check_pptx(path)
+    assert len(results) == 1
+    assert 'Hello' in results[0]['text_content'][0]
+    # No errors expected for this well-formed slide
+    assert len(results[0]['errors']) == 0