infographics-builder 2.0.0__tar.gz

infographics_builder-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 infographics-builder 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.

infographics_builder-2.0.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: infographics-builder
+Version: 2.0.0
+Summary: CLI library for automated infographic poster generation: background removal, parallel headless rendering, color-based auto-patching and HTML asset validation.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/infographics-builder
+Project-URL: Issues, https://github.com/yourusername/infographics-builder/issues
+Keywords: infographics,poster,rendering,rembg,pillow,background-removal,headless-chrome
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Utilities
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: rembg>=2.0.0
+Provides-Extra: progress
+Requires-Dist: tqdm>=4.60.0; extra == "progress"
+Dynamic: license-file
+
+# infographics-builder
+
+> CLI Python library for automated generation of high-quality infographic posters.  
+> Background removal • Parallel headless rendering • BFS color auto-patching • Asset validation
+
+---
+
+## Features
+
+| Command | Description |
+|---------|-------------|
+| `bg` | Remove background via `rembg` and center object on transparent canvas |
+| `render` | Render HTML template to print-quality JPG (2400×3600px) via headless Brave/Chrome |
+| `batch` | Parallel batch rendering of entire folder with progress bar and build log |
+| `patch` | Surgical rectangular texture patching via linear color interpolation |
+| `autopatch` | BFS-based automatic color region detection and patching (removes flags, labels) |
+| `validate` | Pre-render validation of all local image assets in HTML template |
+
+---
+
+## Installation
+
+```bash
+pip install infographics-builder
+
+# Optional: progress bar support
+pip install infographics-builder[progress]
+```
+
+**Requirements:**
+- Python 3.10+
+- Brave Browser or Google Chrome (for `render` / `batch` commands)
+
+---
+
+## Quick Start
+
+### Remove background from image
+```bash
+infographics-builder bg input_photo.jpg output.png
+infographics-builder bg input_photo.jpg output.png --size 1024 --padding 40
+```
+
+### Render a single poster
+```bash
+infographics-builder render card.html poster.jpg
+infographics-builder render card.html poster.jpg --browser "C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe"
+```
+
+### Batch render entire folder (with skip-existing and auto log)
+```bash
+infographics-builder batch ./html_pages/ ./renders/
+infographics-builder batch ./html_pages/ ./renders/ --workers 4 --no-skip
+```
+
+### Auto-patch unwanted color regions (flags, watermarks)
+```bash
+# Remove red (255,0,0) with tolerance 40
+infographics-builder autopatch model.png 255 0 0 --tolerance 40
+
+# Remove blue flag without creating a backup
+infographics-builder autopatch model.png 0 0 200 --tolerance 30 --no-backup
+```
+
+### Manual texture patch by coordinates
+```bash
+infographics-builder patch model.png 580 620 340 380
+infographics-builder patch model.png 580 620 340 380 --no-backup
+```
+
+### Validate HTML template assets
+```bash
+infographics-builder validate card.html
+```
+
+---
+
+## Python API
+
+```python
+from infographics_builder import ImageProcessor, PosterRenderer, Validator
+
+# Remove background
+ImageProcessor.remove_background("photo.jpg", "output.png")
+
+# Render poster
+renderer = PosterRenderer()  # auto-detects Brave/Chrome
+renderer.render("card.html", "poster.jpg")
+
+# Batch render with progress bar
+renderer.render_batch(
+    html_paths=["card1.html", "card2.html"],
+    output_jpg_paths=["poster1.jpg", "poster2.jpg"],
+    skip_existing=True,   # skip already rendered
+    log_dir="./logs/"     # write build_YYYY-MM-DD.log
+)
+
+# Auto-patch by color (BFS)
+ImageProcessor.auto_patch_by_color("model.png", target_color_rgb=(255, 0, 0), tolerance=30)
+
+# Validate assets
+ok = Validator.validate_html("card.html")
+```
+
+---
+
+## Rendering Architecture
+
+The `render` command uses a Chromium-based headless browser with these flags:
+
+```
+--window-size=1200,1800 --force-device-scale-factor=2
+```
+
+This produces a **2400×3600px** screenshot (device-pixel-ratio 2x), which is then converted to JPG at 95% quality via Pillow.
+
+---
+
+## Safety Features
+
+- **Auto-backup (`.bak`)**: `patch` and `autopatch` create a `.bak` copy before modifying any file. Disable with `--no-backup`.
+- **Skip existing**: `batch` skips already-rendered JPGs by default (`--no-skip` to override).
+- **Build log**: Every `batch` run writes `build_YYYY-MM-DD.log` in the output directory.
+
+---
+
+## License
+
+MIT

infographics_builder-2.0.0/README.md

@@ -0,0 +1,129 @@
+# infographics-builder
+
+> CLI Python library for automated generation of high-quality infographic posters.  
+> Background removal • Parallel headless rendering • BFS color auto-patching • Asset validation
+
+---
+
+## Features
+
+| Command | Description |
+|---------|-------------|
+| `bg` | Remove background via `rembg` and center object on transparent canvas |
+| `render` | Render HTML template to print-quality JPG (2400×3600px) via headless Brave/Chrome |
+| `batch` | Parallel batch rendering of entire folder with progress bar and build log |
+| `patch` | Surgical rectangular texture patching via linear color interpolation |
+| `autopatch` | BFS-based automatic color region detection and patching (removes flags, labels) |
+| `validate` | Pre-render validation of all local image assets in HTML template |
+
+---
+
+## Installation
+
+```bash
+pip install infographics-builder
+
+# Optional: progress bar support
+pip install infographics-builder[progress]
+```
+
+**Requirements:**
+- Python 3.10+
+- Brave Browser or Google Chrome (for `render` / `batch` commands)
+
+---
+
+## Quick Start
+
+### Remove background from image
+```bash
+infographics-builder bg input_photo.jpg output.png
+infographics-builder bg input_photo.jpg output.png --size 1024 --padding 40
+```
+
+### Render a single poster
+```bash
+infographics-builder render card.html poster.jpg
+infographics-builder render card.html poster.jpg --browser "C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe"
+```
+
+### Batch render entire folder (with skip-existing and auto log)
+```bash
+infographics-builder batch ./html_pages/ ./renders/
+infographics-builder batch ./html_pages/ ./renders/ --workers 4 --no-skip
+```
+
+### Auto-patch unwanted color regions (flags, watermarks)
+```bash
+# Remove red (255,0,0) with tolerance 40
+infographics-builder autopatch model.png 255 0 0 --tolerance 40
+
+# Remove blue flag without creating a backup
+infographics-builder autopatch model.png 0 0 200 --tolerance 30 --no-backup
+```
+
+### Manual texture patch by coordinates
+```bash
+infographics-builder patch model.png 580 620 340 380
+infographics-builder patch model.png 580 620 340 380 --no-backup
+```
+
+### Validate HTML template assets
+```bash
+infographics-builder validate card.html
+```
+
+---
+
+## Python API
+
+```python
+from infographics_builder import ImageProcessor, PosterRenderer, Validator
+
+# Remove background
+ImageProcessor.remove_background("photo.jpg", "output.png")
+
+# Render poster
+renderer = PosterRenderer()  # auto-detects Brave/Chrome
+renderer.render("card.html", "poster.jpg")
+
+# Batch render with progress bar
+renderer.render_batch(
+    html_paths=["card1.html", "card2.html"],
+    output_jpg_paths=["poster1.jpg", "poster2.jpg"],
+    skip_existing=True,   # skip already rendered
+    log_dir="./logs/"     # write build_YYYY-MM-DD.log
+)
+
+# Auto-patch by color (BFS)
+ImageProcessor.auto_patch_by_color("model.png", target_color_rgb=(255, 0, 0), tolerance=30)
+
+# Validate assets
+ok = Validator.validate_html("card.html")
+```
+
+---
+
+## Rendering Architecture
+
+The `render` command uses a Chromium-based headless browser with these flags:
+
+```
+--window-size=1200,1800 --force-device-scale-factor=2
+```
+
+This produces a **2400×3600px** screenshot (device-pixel-ratio 2x), which is then converted to JPG at 95% quality via Pillow.
+
+---
+
+## Safety Features
+
+- **Auto-backup (`.bak`)**: `patch` and `autopatch` create a `.bak` copy before modifying any file. Disable with `--no-backup`.
+- **Skip existing**: `batch` skips already-rendered JPGs by default (`--no-skip` to override).
+- **Build log**: Every `batch` run writes `build_YYYY-MM-DD.log` in the output directory.
+
+---
+
+## License
+
+MIT

infographics_builder-2.0.0/infographics_builder/__init__.py

@@ -0,0 +1,17 @@
+"""
+infographics-builder
+====================
+CLI library for automated infographic poster generation.
+
+Provides:
+  - ImageProcessor: background removal, texture patching, BFS color auto-patch
+  - PosterRenderer: headless HTML -> JPG rendering (single & batch)
+  - Validator: pre-render HTML asset validation
+"""
+
+__version__ = "2.0.0"
+__all__ = ["ImageProcessor", "PosterRenderer", "Validator"]
+
+from infographics_builder.processor import ImageProcessor
+from infographics_builder.renderer import PosterRenderer
+from infographics_builder.validator import Validator

infographics_builder-2.0.0/infographics_builder/cli.py

@@ -0,0 +1,155 @@
+"""
+infographics-builder CLI entry point.
+"""
+
+import os
+import sys
+import logging
+import argparse
+
+from infographics_builder.processor import ImageProcessor
+from infographics_builder.renderer import PosterRenderer
+from infographics_builder.validator import Validator
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(levelname)s] %(message)s",
+    stream=sys.stdout,
+)
+
+_DESCRIPTION = """
+infographics-builder v2.0.0 — Automated infographic poster generation.
+
+Commands:
+  bg          Remove background and center image on transparent canvas
+  render      Render HTML template to high-res JPG poster (headless browser)
+  batch       Parallel batch rendering of entire folder with progress + log
+  patch       Surgical rectangular texture patching by coordinates
+  autopatch   BFS auto-patch by color (flags, watermarks, labels)
+  validate    Validate all local image assets in HTML template
+
+Examples:
+  infographics-builder bg photo.jpg output.png
+  infographics-builder render card.html poster.jpg
+  infographics-builder batch ./html_pages/ ./renders/
+  infographics-builder autopatch model.png 255 0 0 --tolerance 40
+  infographics-builder validate card.html
+"""
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="infographics-builder",
+        description="infographics-builder v2.0.0 — Automated infographic poster generation",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="Per-command help: infographics-builder <command> --help",
+    )
+    subparsers = parser.add_subparsers(dest="command", metavar="command")
+
+    # --- bg ---
+    p = subparsers.add_parser("bg", help="Remove background and center image")
+    p.add_argument("input", help="Source image path (PNG/JPG/WEBP)")
+    p.add_argument("output", help="Output PNG path")
+    p.add_argument("--size", type=int, default=1024, metavar="PX",
+                   help="Canvas size in pixels (default: 1024)")
+    p.add_argument("--padding", type=int, default=40,
+                   help="Edge padding in pixels (default: 40)")
+
+    # --- render ---
+    p = subparsers.add_parser("render", help="Render HTML template to JPG poster")
+    p.add_argument("html", help="HTML template path")
+    p.add_argument("output", help="Output JPG path")
+    p.add_argument("--browser", default=None,
+                   help="Explicit browser executable path (auto-detected if omitted)")
+
+    # --- batch ---
+    p = subparsers.add_parser("batch", help="Parallel batch rendering: HTML folder -> JPG folder")
+    p.add_argument("html_dir", help="Directory containing HTML templates")
+    p.add_argument("output_dir", help="Directory for output JPG files")
+    p.add_argument("--workers", type=int, default=None,
+                   help="Parallel thread count (default: auto, max 4)")
+    p.add_argument("--no-skip", action="store_true",
+                   help="Re-render already existing JPG files")
+    p.add_argument("--browser", default=None,
+                   help="Explicit browser executable path")
+
+    # --- patch ---
+    p = subparsers.add_parser("patch", help="Surgical texture patch by coordinates")
+    p.add_argument("image", help="Image path (modified in place)")
+    p.add_argument("x_start", type=int)
+    p.add_argument("x_end", type=int)
+    p.add_argument("y_start", type=int)
+    p.add_argument("y_end", type=int)
+    p.add_argument("--no-backup", action="store_true",
+                   help="Skip .bak backup creation")
+
+    # --- autopatch ---
+    p = subparsers.add_parser("autopatch", help="BFS auto-patch by color (removes flags, labels)")
+    p.add_argument("image", help="Image path (modified in place)")
+    p.add_argument("r", type=int, help="Target color Red (0-255)")
+    p.add_argument("g", type=int, help="Target color Green (0-255)")
+    p.add_argument("b", type=int, help="Target color Blue (0-255)")
+    p.add_argument("--tolerance", type=int, default=30,
+                   help="Color match tolerance (default: 30)")
+    p.add_argument("--no-backup", action="store_true",
+                   help="Skip .bak backup creation")
+
+    # --- validate ---
+    p = subparsers.add_parser("validate", help="Validate local image assets in HTML template")
+    p.add_argument("html", help="HTML file path")
+
+    args = parser.parse_args()
+
+    if args.command == "bg":
+        ImageProcessor.remove_background(
+            args.input, args.output,
+            target_size=(args.size, args.size),
+            padding=args.padding,
+        )
+
+    elif args.command == "render":
+        renderer = PosterRenderer(browser_path=args.browser)
+        renderer.render(args.html, args.output)
+
+    elif args.command == "batch":
+        renderer = PosterRenderer(browser_path=args.browser)
+        html_files = sorted(
+            os.path.join(args.html_dir, f)
+            for f in os.listdir(args.html_dir) if f.endswith(".html")
+        )
+        jpg_files = [
+            os.path.join(args.output_dir, os.path.splitext(os.path.basename(f))[0] + ".jpg")
+            for f in html_files
+        ]
+        renderer.render_batch(
+            html_files, jpg_files,
+            max_workers=args.workers,
+            skip_existing=not args.no_skip,
+            log_dir=args.output_dir,
+        )
+
+    elif args.command == "patch":
+        ImageProcessor.patch_texture(
+            args.image, args.x_start, args.x_end, args.y_start, args.y_end,
+            backup=not args.no_backup,
+        )
+
+    elif args.command == "autopatch":
+        ImageProcessor.auto_patch_by_color(
+            args.image, (args.r, args.g, args.b),
+            tolerance=args.tolerance,
+            backup=not args.no_backup,
+        )
+
+    elif args.command == "validate":
+        ok = Validator.validate_html(args.html)
+        sys.exit(0 if ok else 1)
+
+    else:
+        print(_DESCRIPTION)
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

infographics_builder-2.0.0/infographics_builder/processor.py

@@ -0,0 +1,226 @@
+"""
+ImageProcessor — background removal, texture patching, BFS color auto-patching.
+"""
+
+import os
+import sys
+import shutil
+import logging
+import subprocess
+from io import BytesIO
+
+from PIL import Image
+
+log = logging.getLogger("infographics_builder")
+
+
+def _create_backup(image_path: str) -> str:
+    """Creates a .bak backup copy of the file before modification."""
+    bak_path = image_path + ".bak"
+    shutil.copy2(image_path, bak_path)
+    log.info(f"Backup created: {bak_path}")
+    return bak_path
+
+
+class ImageProcessor:
+    """
+    Image processing utilities: background removal, scaling,
+    centering and surgical texture patching.
+    """
+
+    @staticmethod
+    def remove_background(
+        input_path: str,
+        output_path: str,
+        target_size: tuple = (1024, 1024),
+        padding: int = 40,
+    ) -> None:
+        """
+        Remove image background using rembg, auto-crop to object bounds,
+        scale with preserved aspect ratio (Lanczos) and center on transparent canvas.
+
+        Args:
+            input_path:  Source image path (PNG/JPG/WEBP).
+            output_path: Output PNG path.
+            target_size: Canvas size in pixels, default (1024, 1024).
+            padding:     Canvas edge padding in pixels, default 40.
+        """
+        try:
+            from rembg import remove  # type: ignore
+        except ImportError:
+            log.warning("rembg not found. Installing...")
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "rembg"])
+            from rembg import remove  # type: ignore
+
+        log.info(f"Removing background: {input_path}")
+        with open(input_path, "rb") as f:
+            img_data = f.read()
+
+        subject_data = remove(img_data)
+        img = Image.open(BytesIO(subject_data))
+
+        bbox = img.getbbox()
+        if not bbox:
+            raise ValueError(f"Image is empty after background removal: {input_path}")
+
+        cropped = img.crop(bbox)
+        width, height = cropped.size
+        max_dim = max(target_size) - (padding * 2)
+
+        if width >= height:
+            new_width = max_dim
+            new_height = int(height * (max_dim / width))
+        else:
+            new_height = max_dim
+            new_width = int(width * (max_dim / height))
+
+        resized = cropped.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        final_img = Image.new("RGBA", target_size, (0, 0, 0, 0))
+        paste_x = (target_size[0] - new_width) // 2
+        paste_y = (target_size[1] - new_height) // 2
+        final_img.paste(resized, (paste_x, paste_y), resized)
+
+        os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
+        final_img.save(output_path, "PNG")
+        log.info(f"Saved: {output_path}")
+
+    @staticmethod
+    def patch_texture(
+        image_path: str,
+        x_start: int,
+        x_end: int,
+        y_start: int,
+        y_end: int,
+        left_anchor_x: int = None,
+        right_anchor_x: int = None,
+        backup: bool = True,
+    ) -> None:
+        """
+        Surgical rectangular zone patching with linear horizontal gradient
+        of color and alpha sampled from anchor pixels outside the zone.
+
+        Args:
+            image_path:     Image path (OVERWRITTEN in place).
+            x_start/x_end:  Horizontal boundaries of the patch zone.
+            y_start/y_end:  Vertical boundaries of the patch zone.
+            left_anchor_x:  X of left color anchor (default: x_start - 3).
+            right_anchor_x: X of right color anchor (default: x_end + 3).
+            backup:         If True, creates .bak backup before modification.
+        """
+        if backup:
+            _create_backup(image_path)
+
+        img = Image.open(image_path)
+        width, _ = img.size
+        pixels = img.load()
+
+        if left_anchor_x is None:
+            left_anchor_x = max(0, x_start - 3)
+        if right_anchor_x is None:
+            right_anchor_x = min(width - 1, x_end + 3)
+
+        total_width = right_anchor_x - left_anchor_x
+        if total_width == 0:
+            log.warning("Anchors coincide, patching impossible.")
+            return
+
+        for y in range(y_start, y_end + 1):
+            left_color = pixels[left_anchor_x, y]
+            right_color = pixels[right_anchor_x, y]
+            for x in range(x_start, x_end + 1):
+                t = (x - left_anchor_x) / total_width
+                r = int(left_color[0] * (1 - t) + right_color[0] * t)
+                g = int(left_color[1] * (1 - t) + right_color[1] * t)
+                b = int(left_color[2] * (1 - t) + right_color[2] * t)
+                if len(left_color) > 3:
+                    a = int(left_color[3] * (1 - t) + right_color[3] * t)
+                    pixels[x, y] = (r, g, b, a)
+                else:
+                    pixels[x, y] = (r, g, b)
+
+        img.save(image_path)
+        log.info(f"Patched zone [{x_start}:{x_end}, {y_start}:{y_end}]")
+
+    @staticmethod
+    def auto_patch_by_color(
+        image_path: str,
+        target_color_rgb: tuple,
+        tolerance: int = 30,
+        min_area_size: int = 4,
+        padding: int = 2,
+        backup: bool = True,
+    ) -> None:
+        """
+        BFS scan of connected color regions matching target_color_rgb and
+        automatic texture patching of each found region.
+
+        Args:
+            image_path:       Image path (OVERWRITTEN in place).
+            target_color_rgb: Target color as (R, G, B).
+            tolerance:        Max Euclidean RGB distance from target color.
+            min_area_size:    Minimum connected region size (pixels) to patch.
+            padding:          Extra pixels to extend patch zone around region.
+            backup:           If True, creates .bak backup before modification.
+        """
+        if backup:
+            _create_backup(image_path)
+
+        log.info(f"Auto-patch by color {target_color_rgb} (tolerance={tolerance}): {image_path}")
+        img = Image.open(image_path)
+        width, height = img.size
+        pixels = img.load()
+
+        visited: set = set()
+        regions: list = []
+
+        def is_target(pixel):
+            r, g, b = pixel[:3]
+            tr, tg, tb = target_color_rgb
+            return ((r - tr) ** 2 + (g - tg) ** 2 + (b - tb) ** 2) ** 0.5 <= tolerance
+
+        for x in range(width):
+            for y in range(height):
+                if (x, y) in visited:
+                    continue
+                px = pixels[x, y]
+                if len(px) > 3 and px[3] < 50:
+                    continue
+                if is_target(px):
+                    queue = [(x, y)]
+                    visited.add((x, y))
+                    region = []
+                    while queue:
+                        cx, cy = queue.pop(0)
+                        region.append((cx, cy))
+                        for nx, ny in [(cx - 1, cy), (cx + 1, cy), (cx, cy - 1), (cx, cy + 1)]:
+                            if 0 <= nx < width and 0 <= ny < height and (nx, ny) not in visited:
+                                npx = pixels[nx, ny]
+                                if len(npx) > 3 and npx[3] < 50:
+                                    continue
+                                if is_target(npx):
+                                    visited.add((nx, ny))
+                                    queue.append((nx, ny))
+                    if len(region) >= min_area_size:
+                        regions.append(region)
+
+        log.info(f"Regions found: {len(regions)}")
+        if not regions:
+            return
+
+        for idx, region in enumerate(regions):
+            xs = [p[0] for p in region]
+            ys = [p[1] for p in region]
+            min_x, max_x = min(xs), max(xs)
+            min_y, max_y = min(ys), max(ys)
+
+            x_s = max(0, min_x - padding)
+            x_e = min(width - 1, max_x + padding)
+            y_s = max(0, min_y - padding)
+            y_e = min(height - 1, max_y + padding)
+            left_anc = max(0, x_s - 3)
+            right_anc = min(width - 1, x_e + 3)
+
+            log.info(f"  Region #{idx + 1}: X({min_x}..{max_x}), Y({min_y}..{max_y})")
+            ImageProcessor.patch_texture(image_path, x_s, x_e, y_s, y_e, left_anc, right_anc, backup=False)
+
+        log.info("Auto-patch complete.")

infographics_builder-2.0.0/infographics_builder/renderer.py

@@ -0,0 +1,185 @@
+"""
+PosterRenderer — headless HTML-to-JPG rendering (single & parallel batch).
+"""
+
+import os
+import sys
+import logging
+import subprocess
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from PIL import Image
+
+log = logging.getLogger("infographics_builder")
+
+
+class PosterRenderer:
+    """
+    Renders HTML templates into print-quality JPG posters (2400x3600px)
+    via headless Brave or Chrome browser.
+    """
+
+    def __init__(self, browser_path: str = None):
+        """
+        Args:
+            browser_path: Explicit path to browser executable.
+                          If not provided, auto-detected from standard locations.
+        """
+        self.browser_path = browser_path or self._find_browser()
+        if not self.browser_path:
+            raise FileNotFoundError(
+                "Brave or Chrome not found. Specify manually: PosterRenderer(browser_path=...)"
+            )
+
+    def _find_browser(self) -> str | None:
+        """Auto-detect Brave or Chrome on Windows and macOS."""
+        candidates = [
+            # Windows — Brave
+            r"C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe",
+            r"C:\Program Files (x86)\BraveSoftware\Brave-Browser\Application\brave.exe",
+            os.path.expandvars(r"%LOCALAPPDATA%\BraveSoftware\Brave-Browser\Application\brave.exe"),
+            # Windows — Chrome
+            r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+            r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+            os.path.expandvars(r"%LOCALAPPDATA%\Google\Chrome\Application\chrome.exe"),
+            # macOS
+            "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        ]
+        for p in candidates:
+            if os.path.exists(p):
+                return p
+        return None
+
+    def render(self, html_path: str, output_jpg_path: str) -> None:
+        """
+        Render a single HTML template to a 2400x3600px JPG poster.
+
+        Uses headless browser with:
+          --window-size=1200,1800 --force-device-scale-factor=2
+        producing a 2x DPR screenshot = 2400x3600px.
+
+        Args:
+            html_path:       Path to the HTML template file.
+            output_jpg_path: Path for the output JPG.
+        """
+        if not os.path.exists(html_path):
+            raise FileNotFoundError(f"HTML template not found: {html_path}")
+
+        temp_png = output_jpg_path.replace(".jpg", "_temp.png")
+        os.makedirs(os.path.dirname(os.path.abspath(output_jpg_path)), exist_ok=True)
+
+        file_url = f"file:///{os.path.abspath(html_path).replace(os.sep, '/')}"
+        cmd = [
+            self.browser_path,
+            "--headless",
+            "--disable-gpu",
+            f"--screenshot={temp_png}",
+            "--window-size=1200,1800",
+            "--force-device-scale-factor=2",
+            "--hide-scrollbars",
+            "--run-all-compositor-stages-before-draw",
+            file_url,
+        ]
+        subprocess.run(cmd, check=True, capture_output=True)
+
+        if not os.path.exists(temp_png):
+            raise RuntimeError(f"Browser did not produce screenshot: {temp_png}")
+
+        img = Image.open(temp_png)
+        img.convert("RGB").save(output_jpg_path, "JPEG", quality=95)
+        os.remove(temp_png)
+        log.info(f"Rendered: {os.path.basename(output_jpg_path)}")
+
+    def render_batch(
+        self,
+        html_paths: list,
+        output_jpg_paths: list,
+        max_workers: int = None,
+        skip_existing: bool = True,
+        log_dir: str = None,
+    ) -> dict:
+        """
+        Parallel batch rendering of multiple posters with progress bar (tqdm)
+        and automatic build log file.
+
+        Args:
+            html_paths:       List of HTML template paths.
+            output_jpg_paths: List of output JPG paths (1:1 with html_paths).
+            max_workers:      Thread pool size. Default: min(4, cpu_count // 2).
+            skip_existing:    Skip already-rendered JPG files. Default: True.
+            log_dir:          Directory for build_YYYY-MM-DD.log file.
+                              Default: directory of first output JPG.
+
+        Returns:
+            dict with keys "ok" (list) and "failed" (list).
+        """
+        if len(html_paths) != len(output_jpg_paths):
+            raise ValueError("html_paths and output_jpg_paths must have the same length.")
+
+        if not max_workers:
+            max_workers = max(1, min(4, (os.cpu_count() or 2) // 2))
+
+        if log_dir is None:
+            log_dir = os.path.dirname(os.path.abspath(output_jpg_paths[0]))
+        os.makedirs(log_dir, exist_ok=True)
+
+        log_path = os.path.join(log_dir, f"build_{datetime.now().strftime('%Y-%m-%d')}.log")
+        file_handler = logging.FileHandler(log_path, encoding="utf-8")
+        file_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+        log.addHandler(file_handler)
+        log.info(f"=== Batch render | workers={max_workers} | total={len(html_paths)} ===")
+
+        tasks = []
+        skipped = 0
+        for html, jpg in zip(html_paths, output_jpg_paths):
+            if skip_existing and os.path.exists(jpg):
+                log.info(f"[SKIP] {os.path.basename(jpg)}")
+                skipped += 1
+            else:
+                tasks.append((html, jpg))
+
+        if skipped:
+            log.info(f"Skipped (already exist): {skipped}")
+
+        results = {"ok": [], "failed": []}
+
+        if not tasks:
+            log.info("No tasks to render.")
+            log.removeHandler(file_handler)
+            return results
+
+        try:
+            from tqdm import tqdm  # type: ignore
+            progress = tqdm(total=len(tasks), unit="poster", desc="Rendering")
+            use_tqdm = True
+        except ImportError:
+            log.warning("tqdm not installed (pip install tqdm). Text progress only.")
+            use_tqdm = False
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = {
+                executor.submit(self.render, html, jpg): (html, jpg)
+                for html, jpg in tasks
+            }
+            for future in as_completed(futures):
+                html, jpg = futures[future]
+                try:
+                    future.result()
+                    results["ok"].append(jpg)
+                    log.info(f"[OK] {os.path.basename(jpg)}")
+                except Exception as exc:
+                    results["failed"].append(jpg)
+                    log.error(f"[FAIL] {os.path.basename(html)}: {exc}")
+                finally:
+                    if use_tqdm:
+                        progress.update(1)
+
+        if use_tqdm:
+            progress.close()
+
+        log.info(f"=== Done | ok={len(results['ok'])} | failed={len(results['failed'])} ===")
+        log.info(f"Log saved: {log_path}")
+        log.removeHandler(file_handler)
+        return results

infographics_builder-2.0.0/infographics_builder/validator.py

@@ -0,0 +1,59 @@
+"""
+Validator — pre-render HTML asset validation.
+"""
+
+import os
+import re
+import logging
+
+log = logging.getLogger("infographics_builder")
+
+
+class Validator:
+    """Pre-render validation of HTML template local assets."""
+
+    @staticmethod
+    def validate_html(html_path: str) -> bool:
+        """
+        Check that all local images referenced in the HTML file exist on disk.
+
+        Args:
+            html_path: Path to the HTML file to validate.
+
+        Returns:
+            True if all local assets exist, False otherwise.
+        """
+        if not os.path.exists(html_path):
+            log.error(f"File does not exist: {html_path}")
+            return False
+
+        log.info(f"Validating: {html_path}")
+        html_dir = os.path.dirname(os.path.abspath(html_path))
+
+        with open(html_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        sources = re.findall(r'src=["\']([^"\']+)["\']', content)
+        all_ok = True
+
+        for src in sources:
+            if src.startswith(("http://", "https://", "data:")):
+                continue
+            clean_src = src.replace("../", "").replace("file:///", "")
+            paths_to_check = [
+                os.path.join(html_dir, src),
+                os.path.join(html_dir, clean_src),
+                os.path.join(os.path.dirname(html_dir), clean_src),
+            ]
+            found = any(os.path.exists(p) for p in paths_to_check)
+            if found:
+                log.info(f"  [OK] {src}")
+            else:
+                log.error(f"  [MISSING] {src}")
+                all_ok = False
+
+        if all_ok:
+            log.info("[SUCCESS] All local assets found.")
+        else:
+            log.warning("[INCOMPLETE] Some assets are missing.")
+        return all_ok

infographics_builder-2.0.0/infographics_builder.egg-info/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: infographics-builder
+Version: 2.0.0
+Summary: CLI library for automated infographic poster generation: background removal, parallel headless rendering, color-based auto-patching and HTML asset validation.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/infographics-builder
+Project-URL: Issues, https://github.com/yourusername/infographics-builder/issues
+Keywords: infographics,poster,rendering,rembg,pillow,background-removal,headless-chrome
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Utilities
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: rembg>=2.0.0
+Provides-Extra: progress
+Requires-Dist: tqdm>=4.60.0; extra == "progress"
+Dynamic: license-file
+
+# infographics-builder
+
+> CLI Python library for automated generation of high-quality infographic posters.  
+> Background removal • Parallel headless rendering • BFS color auto-patching • Asset validation
+
+---
+
+## Features
+
+| Command | Description |
+|---------|-------------|
+| `bg` | Remove background via `rembg` and center object on transparent canvas |
+| `render` | Render HTML template to print-quality JPG (2400×3600px) via headless Brave/Chrome |
+| `batch` | Parallel batch rendering of entire folder with progress bar and build log |
+| `patch` | Surgical rectangular texture patching via linear color interpolation |
+| `autopatch` | BFS-based automatic color region detection and patching (removes flags, labels) |
+| `validate` | Pre-render validation of all local image assets in HTML template |
+
+---
+
+## Installation
+
+```bash
+pip install infographics-builder
+
+# Optional: progress bar support
+pip install infographics-builder[progress]
+```
+
+**Requirements:**
+- Python 3.10+
+- Brave Browser or Google Chrome (for `render` / `batch` commands)
+
+---
+
+## Quick Start
+
+### Remove background from image
+```bash
+infographics-builder bg input_photo.jpg output.png
+infographics-builder bg input_photo.jpg output.png --size 1024 --padding 40
+```
+
+### Render a single poster
+```bash
+infographics-builder render card.html poster.jpg
+infographics-builder render card.html poster.jpg --browser "C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe"
+```
+
+### Batch render entire folder (with skip-existing and auto log)
+```bash
+infographics-builder batch ./html_pages/ ./renders/
+infographics-builder batch ./html_pages/ ./renders/ --workers 4 --no-skip
+```
+
+### Auto-patch unwanted color regions (flags, watermarks)
+```bash
+# Remove red (255,0,0) with tolerance 40
+infographics-builder autopatch model.png 255 0 0 --tolerance 40
+
+# Remove blue flag without creating a backup
+infographics-builder autopatch model.png 0 0 200 --tolerance 30 --no-backup
+```
+
+### Manual texture patch by coordinates
+```bash
+infographics-builder patch model.png 580 620 340 380
+infographics-builder patch model.png 580 620 340 380 --no-backup
+```
+
+### Validate HTML template assets
+```bash
+infographics-builder validate card.html
+```
+
+---
+
+## Python API
+
+```python
+from infographics_builder import ImageProcessor, PosterRenderer, Validator
+
+# Remove background
+ImageProcessor.remove_background("photo.jpg", "output.png")
+
+# Render poster
+renderer = PosterRenderer()  # auto-detects Brave/Chrome
+renderer.render("card.html", "poster.jpg")
+
+# Batch render with progress bar
+renderer.render_batch(
+    html_paths=["card1.html", "card2.html"],
+    output_jpg_paths=["poster1.jpg", "poster2.jpg"],
+    skip_existing=True,   # skip already rendered
+    log_dir="./logs/"     # write build_YYYY-MM-DD.log
+)
+
+# Auto-patch by color (BFS)
+ImageProcessor.auto_patch_by_color("model.png", target_color_rgb=(255, 0, 0), tolerance=30)
+
+# Validate assets
+ok = Validator.validate_html("card.html")
+```
+
+---
+
+## Rendering Architecture
+
+The `render` command uses a Chromium-based headless browser with these flags:
+
+```
+--window-size=1200,1800 --force-device-scale-factor=2
+```
+
+This produces a **2400×3600px** screenshot (device-pixel-ratio 2x), which is then converted to JPG at 95% quality via Pillow.
+
+---
+
+## Safety Features
+
+- **Auto-backup (`.bak`)**: `patch` and `autopatch` create a `.bak` copy before modifying any file. Disable with `--no-backup`.
+- **Skip existing**: `batch` skips already-rendered JPGs by default (`--no-skip` to override).
+- **Build log**: Every `batch` run writes `build_YYYY-MM-DD.log` in the output directory.
+
+---
+
+## License
+
+MIT

infographics_builder-2.0.0/infographics_builder.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+infographics_builder/__init__.py
+infographics_builder/cli.py
+infographics_builder/processor.py
+infographics_builder/renderer.py
+infographics_builder/validator.py
+infographics_builder.egg-info/PKG-INFO
+infographics_builder.egg-info/SOURCES.txt
+infographics_builder.egg-info/dependency_links.txt
+infographics_builder.egg-info/entry_points.txt
+infographics_builder.egg-info/requires.txt
+infographics_builder.egg-info/top_level.txt

infographics_builder-2.0.0/infographics_builder.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

infographics_builder-2.0.0/infographics_builder.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+infographics-builder = infographics_builder.cli:main

infographics_builder-2.0.0/infographics_builder.egg-info/requires.txt

@@ -0,0 +1,5 @@
+Pillow>=10.0.0
+rembg>=2.0.0
+
+[progress]
+tqdm>=4.60.0

infographics_builder-2.0.0/infographics_builder.egg-info/top_level.txt

@@ -0,0 +1 @@
+infographics_builder

infographics_builder-2.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "infographics-builder"
+version = "2.0.0"
+description = "CLI library for automated infographic poster generation: background removal, parallel headless rendering, color-based auto-patching and HTML asset validation."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+keywords = ["infographics", "poster", "rendering", "rembg", "pillow", "background-removal", "headless-chrome"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Graphics",
+    "Topic :: Utilities",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+]
+dependencies = [
+    "Pillow>=10.0.0",
+    "rembg>=2.0.0",
+]
+
+[project.optional-dependencies]
+progress = ["tqdm>=4.60.0"]
+
+[project.scripts]
+infographics-builder = "infographics_builder.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/yourusername/infographics-builder"
+Issues = "https://github.com/yourusername/infographics-builder/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["infographics_builder*"]

infographics_builder-2.0.0/setup.cfg

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