corpdoc 0.4.0__py3-none-any.whl

corpdoc/canvas.py

@@ -0,0 +1,230 @@
+"""
+Custom ReportLab canvas with corporate header and footer.
+
+Header: brand tagline (with split-color styling) on left, logo on right.
+Footer: company legal info with key/value brand-split coloring, page numbers.
+"""
+
+from reportlab.pdfgen import canvas
+from reportlab.lib.colors import HexColor
+from reportlab.lib.units import cm
+
+from corpdoc.i18n import t
+
+
+def brand_split_draw(canv, x, y, text, n, accent_hex, primary_hex, font="Helvetica", size=7):
+    """
+    Draw text on canvas with "brand split" coloring:
+    First `n` chars of each word in accent, rest in primary.
+    """
+    cursor = x
+    words = text.split()
+    for wi, word in enumerate(words):
+        if wi > 0:
+            canv.setFont(font, size)
+            canv.setFillColor(HexColor(primary_hex))
+            canv.drawString(cursor, y, " ")
+            cursor += canv.stringWidth(" ", font, size)
+
+        head, tail = word[:n], word[n:]
+        canv.setFont(font, size)
+        canv.setFillColor(HexColor(accent_hex))
+        canv.drawString(cursor, y, head)
+        cursor += canv.stringWidth(head, font, size)
+
+        if tail:
+            canv.setFillColor(HexColor(primary_hex))
+            canv.drawString(cursor, y, tail)
+            cursor += canv.stringWidth(tail, font, size)
+
+    return cursor
+
+
+def brand_split_inline(text, n, accent_hex, primary_hex):
+    """
+    Return ReportLab-compatible XML string for brand-split text
+    (use inside Paragraph).
+    """
+    words = text.split()
+    parts = []
+    for w in words:
+        if len(w) <= n:
+            parts.append(f'<font color="{accent_hex}">{w}</font>')
+        else:
+            parts.append(
+                f'<font color="{accent_hex}">{w[:n]}</font>'
+                f'<font color="{primary_hex}">{w[n:]}</font>'
+            )
+    return " ".join(parts)
+
+
+class CorpCanvas(canvas.Canvas):
+    """
+    Canvas that draws corporate header and footer on every page except
+    the cover (page 1) and version history (page 2).
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._corp = kwargs.pop("_corp", {})
+        super().__init__(*args, **kwargs)
+        self._page_states = []
+
+    def showPage(self):
+        self._page_states.append(dict(self.__dict__))
+        self._startPage()
+
+    def save(self):
+        total = len(self._page_states)
+        for state in self._page_states:
+            self.__dict__.update(state)
+            self._draw_header_footer(total)
+            canvas.Canvas.showPage(self)
+        canvas.Canvas.save(self)
+
+    def _draw_header_footer(self, total_pages):
+        pn = self._pageNumber
+        # Skip cover (page 1) and version history (page 2)
+        if pn <= 2:
+            return
+
+        corp = self._corp
+        w, h = self._pagesize
+        accent = corp.get("accent", "#b9885a")
+        primary = corp.get("primary", "#2e1e19")
+        lang = corp.get("lang", "en")
+        split_n = corp.get("brand_split", 3)
+
+        # ── HEADER ──
+        self._draw_header(w, h, corp, accent, primary, split_n)
+
+        # ── FOOTER ──
+        self._draw_footer(w, h, corp, accent, primary, split_n, pn, total_pages, lang)
+
+    def _draw_header(self, w, h, corp, accent, primary, split_n):
+        # Logo right-aligned
+        logo = corp.get("logo")
+        header_scale = corp.get("header_scale", 0.45)
+        if logo:
+            iw, ih = logo.width, logo.height
+            # Base size 170pt * scale
+            target_w = 170 * header_scale
+            sc = target_w / iw
+            dw, dh = iw * sc, ih * sc
+            try:
+                logo.draw(self, w - 2 * cm - dw, h - 0.6 * cm - dh, dw, dh)
+            except Exception:
+                pass
+
+        # Tagline (left)
+        tagline = corp.get("tagline", "")
+        if tagline:
+            # Short prefix in italic (e.g. "jes.")
+            prefix = corp.get("tagline_prefix", "")
+            x_cursor = 2 * cm
+            if prefix:
+                self.setFont("Helvetica-Oblique", 8)
+                self.setFillColor(HexColor(accent))
+                self.drawString(x_cursor, h - 1.3 * cm, prefix)
+                x_cursor += self.stringWidth(prefix, "Helvetica-Oblique", 8) + 8
+
+            brand_split_draw(
+                self, x_cursor, h - 1.3 * cm, tagline, split_n, accent, primary, "Helvetica", 7
+            )
+
+        # Header accent line
+        self.setStrokeColor(HexColor(accent))
+        self.setLineWidth(0.4)
+        self.line(2 * cm, h - 1.6 * cm, w - 2 * cm, h - 1.6 * cm)
+
+    def _draw_footer(self, w, h, corp, accent, primary, split_n, pn, total, lang):
+        footer_y = 2.6 * cm
+
+        # Footer accent line
+        self.setStrokeColor(HexColor(accent))
+        self.setLineWidth(1.0)
+        self.line(2 * cm, footer_y, w - 2 * cm, footer_y)
+
+        cx = w / 2
+
+        # Line 1: Company name (brand-split) + address
+        company_name = corp.get("company_legal", "")
+        address = corp.get("address", "")
+
+        if company_name:
+            line1 = company_name
+            if address:
+                line1 += f"    |    {address}"
+            total_w = self.stringWidth(line1, "Helvetica", 6.5)
+            start_x = cx - total_w / 2
+
+            end_x = brand_split_draw(
+                self,
+                start_x,
+                footer_y - 12,
+                company_name,
+                split_n,
+                accent,
+                primary,
+                "Helvetica",
+                6.5,
+            )
+            if address:
+                self.setFont("Helvetica", 6.5)
+                self.setFillColor(HexColor(primary))
+                self.drawString(end_x, footer_y - 12, f"    |    {address}")
+
+        # Additional fields (key/value pairs, grouped per line)
+        fields = corp.get("fields", [])
+        field_lines = self._group_fields(fields)
+
+        for li, fline in enumerate(field_lines):
+            y_pos = footer_y - 23 - (li * 11)
+            full_text = "    |    ".join(f"{f['label']}: {f['value']}" for f in fline)
+            total_w = self.stringWidth(full_text, "Helvetica", 6.5)
+            cur_x = cx - total_w / 2
+
+            for fi, fld in enumerate(fline):
+                if fi > 0:
+                    self.setFont("Helvetica", 6.5)
+                    self.setFillColor(HexColor("#999999"))
+                    sep = "    |    "
+                    self.drawString(cur_x, y_pos, sep)
+                    cur_x += self.stringWidth(sep, "Helvetica", 6.5)
+
+                # Label in accent
+                label = fld["label"] + ": "
+                self.setFont("Helvetica", 6.5)
+                self.setFillColor(HexColor(accent))
+                self.drawString(cur_x, y_pos, label)
+                cur_x += self.stringWidth(label, "Helvetica", 6.5)
+
+                # Value in primary
+                val = fld["value"]
+                self.setFillColor(HexColor(primary))
+                self.drawString(cur_x, y_pos, val)
+                cur_x += self.stringWidth(val, "Helvetica", 6.5)
+
+        # Page number (language-aware, right-aligned)
+        footer_bottom = footer_y - 23 - (len(field_lines) * 11)
+        pg = t(lang, "page")
+        of = t(lang, "of")
+
+        self.setFont("Helvetica", 7)
+        self.setFillColor(HexColor("#aaaaaa"))
+        # Page numbering accounts for cover + version page
+        self.drawRightString(w - 2 * cm, footer_bottom, f"{pg} {pn - 2} {of} {total - 2}")
+
+    @staticmethod
+    def _group_fields(fields):
+        """Group fields into lines of approx 90 chars max."""
+        lines = []
+        current = []
+        for fld in fields:
+            current.append(fld)
+            combined = "    |    ".join(f"{f['label']}: {f['value']}" for f in current)
+            if len(combined) > 90 or len(current) >= 3:
+                lines.append(current)
+                current = []
+        if current:
+            lines.append(current)
+        return lines

corpdoc/cli.py

@@ -0,0 +1,284 @@
+"""
+Command-line interface for CorpDoc.
+
+Commands:
+    corpdoc init       Create a new corpdoc.yml from a logo
+    corpdoc render     Generate PDF from markdown + config
+    corpdoc colors     Print the palette extracted from a logo
+    corpdoc new        Scaffold a new markdown document
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from corpdoc import __version__
+from corpdoc.api import CorpDoc
+from corpdoc.colors import extract_colors_from_svg, assign_roles
+
+
+# Reconfigure stdout/stderr to UTF-8 so unicode glyphs render on Windows consoles
+# that default to cp1252. Python 3.7+ exposes reconfigure(); guard for safety.
+for _stream in (sys.stdout, sys.stderr):
+    if hasattr(_stream, "reconfigure"):
+        try:
+            _stream.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, ValueError):
+            pass
+
+
+def cmd_init(args):
+    """Create a new corpdoc.yml from a logo."""
+    if not os.path.exists(args.logo):
+        sys.exit(f"Error: logo file not found: {args.logo}")
+
+    logo_path = Path(args.logo)
+    suffix = logo_path.suffix.lower()
+
+    # Extract colors for preview (SVG only — PNG palette extraction is out of scope)
+    if suffix == ".svg":
+        colors = extract_colors_from_svg(args.logo)
+        palette = assign_roles(colors)
+        print(f"Colors extracted from {args.logo}:")
+        print(f"  Primary:   {palette['primary']}")
+        print(f"  Secondary: {palette['secondary']}")
+        print(f"  Accent:    {palette['accent']}")
+
+    # Build logo section of the config depending on what the user supplied.
+    # CorpDoc accepts SVG only, PNG only, or both — whichever is available
+    # will be used at render time (PNG wins when both are present).
+    if suffix == ".svg":
+        sibling_png = logo_path.with_suffix(".png")
+        png_value = str(sibling_png) if sibling_png.exists() else ""
+        svg_value = args.logo
+    elif suffix == ".png":
+        sibling_svg = logo_path.with_suffix(".svg")
+        svg_value = str(sibling_svg) if sibling_svg.exists() else ""
+        png_value = args.logo
+    else:
+        sys.exit(f'Error: logo must be .svg or .png (got "{suffix}")')
+
+    # Build a sensible default tagline using the short name
+    short = args.name.split()[0] if args.name else "your-company"
+    default_tagline = args.tagline or f"{short.lower()} | engineering | solutions"
+
+    config = f"""# CorpDoc Configuration
+# Edit the values below to match your company identity.
+
+company:
+  legal_name: "{args.name}"
+  short_name: "{short}"
+  tagline: "{default_tagline}"
+  # Number of leading chars of each word colored in accent (brand-split effect)
+  brand_split: 3
+
+logo:
+  # CorpDoc accepts SVG, PNG, or both. SVG enables automatic color extraction;
+  # PNG is used for embedding when present. Leave a field empty to skip it.
+  svg: "{svg_value}"
+  png: "{png_value}"
+  cover_scale: 1.00          # size of logo on cover page (1.0 = default)
+  header_scale: 0.45         # size of logo in header (fraction of cover size)
+
+cover:
+  # Choose one of: classic | minimal | bold-band | split
+  #   classic   — logo top, accent band bottom with title in white
+  #   minimal   — small top-left logo, large centered title on white
+  #   bold-band — full-page primary color, white logo + title stacked center
+  #   split     — top half primary with logo, bottom half white with title
+  style: "classic"
+
+footer:
+  address: ""
+  fields:
+    - label: "Director"
+      value: ""
+    - label: "E-Mail"
+      value: ""
+    - label: "Internet"
+      value: ""
+
+defaults:
+  language: "auto"           # auto|en|es|de|fr
+  version: "1.0"
+  author: ""
+
+tables:
+  # Tables with this many columns (or more) are auto-rotated to a landscape
+  # page so the content stays readable. Raise this value to disable.
+  landscape_threshold: 8
+"""
+
+    out_path = Path(args.output)
+    out_path.write_text(config, encoding="utf-8")
+    print(f"\n✓ Configuration written to: {out_path}")
+
+    print("\nNext steps:")
+    print(f"  1. Edit {out_path} to fill in your company details")
+    print(f"  2. Run: corpdoc render your-document.md --config {out_path}")
+
+
+def cmd_render(args):
+    """Generate PDF from markdown."""
+    if not os.path.exists(args.md):
+        sys.exit(f"Error: markdown file not found: {args.md}")
+    if not os.path.exists(args.config):
+        sys.exit(f"Error: config file not found: {args.config}")
+
+    print(f"Rendering {args.md}...")
+    doc = CorpDoc(config=args.config)
+    print(f"  Primary:   {doc.colors['primary']}")
+    print(f"  Secondary: {doc.colors['secondary']}")
+
+    output = args.output or Path(args.md).with_suffix(".pdf")
+    result = doc.render(args.md, output=str(output))
+    print(f"\n✓ PDF generated: {result}")
+
+
+def cmd_colors(args):
+    """Print the palette extracted from a logo."""
+    if not os.path.exists(args.logo):
+        sys.exit(f"Error: logo file not found: {args.logo}")
+
+    raw = extract_colors_from_svg(args.logo)
+    palette = assign_roles(raw)
+
+    print(f"\nColors extracted from: {args.logo}")
+    print("─" * 60)
+    print(f"Raw colors found: {raw}")
+    print("─" * 60)
+    print("Role assignments:")
+    for role in ["primary", "secondary", "accent", "light", "lighter"]:
+        color = palette[role]
+        # ANSI color block
+        r, g, b = int(color[1:3], 16), int(color[3:5], 16), int(color[5:7], 16)
+        block = f"\033[48;2;{r};{g};{b}m      \033[0m"
+        print(f"  {block}  {color}   ({role})")
+
+
+def cmd_new(args):
+    """Scaffold a new markdown document."""
+    templates = {
+        "generic": """# {title}
+## {subtitle}
+
+Write your content here.
+
+## Section 1
+
+Your content.
+
+## Section 2
+
+More content.
+""",
+        "offer": """# {title}
+## {subtitle}
+
+Brief executive summary of the offer.
+
+## 1. Scope
+
+Describe the scope of work.
+
+## 2. Approach
+
+Describe the proposed approach.
+
+## 3. Deliverables
+
+| Item | Description | Quantity |
+|------|-------------|----------|
+| A    | ...         | 1        |
+
+## 4. Timeline
+
+Describe the timeline.
+
+## 5. Budget
+
+Describe the budget and payment terms.
+""",
+        "report": """# {title}
+## {subtitle}
+
+## 1. Executive Summary
+
+Brief summary of findings.
+
+## 2. Methodology
+
+Describe the approach.
+
+## 3. Results
+
+Present the data.
+
+## 4. Conclusions
+
+Summarize conclusions.
+
+## 5. Recommendations
+
+List recommendations.
+""",
+    }
+
+    template = templates.get(args.type, templates["generic"])
+    content = template.format(
+        title=args.title or "Document Title",
+        subtitle=args.subtitle or "Subtitle or client name",
+    )
+
+    out_path = Path(args.output)
+    out_path.write_text(content, encoding="utf-8")
+    print(f"✓ New {args.type} document created: {out_path}")
+    print(f"  Edit the file and run: corpdoc render {out_path} --config corpdoc.yml")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="corpdoc", description="CorpDoc — Professional Corporate PDF Generator"
+    )
+    parser.add_argument("-V", "--version", action="version", version=f"corpdoc {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    # init
+    p_init = sub.add_parser("init", help="Create a new corpdoc.yml from a logo")
+    p_init.add_argument(
+        "--logo",
+        required=True,
+        help="Path to your logo (.svg or .png — SVG preferred for color extraction)",
+    )
+    p_init.add_argument("--name", required=True, help="Company legal name")
+    p_init.add_argument("--tagline", default="", help="Header tagline (optional)")
+    p_init.add_argument("--output", default="corpdoc.yml", help="Output config path")
+    p_init.set_defaults(func=cmd_init)
+
+    # render
+    p_render = sub.add_parser("render", help="Generate PDF from markdown + config")
+    p_render.add_argument("md", help="Markdown file")
+    p_render.add_argument("--config", default="corpdoc.yml", help="Config YAML path")
+    p_render.add_argument("--output", default="", help="Output PDF path")
+    p_render.set_defaults(func=cmd_render)
+
+    # colors
+    p_colors = sub.add_parser("colors", help="Show palette extracted from a logo")
+    p_colors.add_argument("logo", help="SVG logo file")
+    p_colors.set_defaults(func=cmd_colors)
+
+    # new
+    p_new = sub.add_parser("new", help="Create a new document skeleton")
+    p_new.add_argument("type", choices=["generic", "offer", "report"], help="Document type")
+    p_new.add_argument("--title", default="", help="Document title")
+    p_new.add_argument("--subtitle", default="", help="Document subtitle")
+    p_new.add_argument("--output", default="document.md", help="Output .md path")
+    p_new.set_defaults(func=cmd_new)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

corpdoc/colors.py

@@ -0,0 +1,173 @@
+"""
+Color extraction and role assignment from SVG logos.
+
+Extracts hex colors from SVG files by parsing XML attributes (fill, stroke)
+and inline styles. Then assigns semantic roles (primary, secondary, accent)
+based on luminance and saturation.
+"""
+
+import re
+from xml.etree import ElementTree as ET
+from collections import Counter
+
+
+HEX_PATTERN = re.compile(r"#([0-9a-fA-F]{3,8})\b")
+RGB_PATTERN = re.compile(r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)")
+
+
+def extract_colors_from_svg(svg_path):
+    """
+    Extract all hex colors used in an SVG file, ordered by frequency.
+
+    Parses XML for fill, stroke, stop-color, and style attributes. Also
+    scans embedded <style> blocks for colors.
+
+    Args:
+        svg_path: Path to .svg file
+
+    Returns:
+        List of hex color strings (e.g. ['#1a2b3c', '#b9885a'])
+        ordered by frequency of appearance.
+    """
+    tree = ET.parse(svg_path)
+    root = tree.getroot()
+    colors = Counter()
+
+    for elem in root.iter():
+        # Direct color attributes
+        for attr in ("fill", "stroke", "stop-color", "color", "flood-color"):
+            val = elem.get(attr, "")
+            if val and val not in ("none", "transparent", "currentColor"):
+                for m in HEX_PATTERN.finditer(val):
+                    colors[_normalize_hex("#" + m.group(1))] += 1
+                for m in RGB_PATTERN.finditer(val):
+                    r, g, b = int(m.group(1)), int(m.group(2)), int(m.group(3))
+                    colors[f"#{r:02x}{g:02x}{b:02x}"] += 1
+
+        # Inline style attribute
+        style = elem.get("style", "")
+        if style:
+            for m in HEX_PATTERN.finditer(style):
+                colors[_normalize_hex("#" + m.group(1))] += 1
+
+    # Embedded <style> blocks
+    for elem in root.iter():
+        tag = elem.tag.split("}")[-1] if "}" in elem.tag else elem.tag
+        if tag == "style" and elem.text:
+            for m in HEX_PATTERN.finditer(elem.text):
+                colors[_normalize_hex("#" + m.group(1))] += 1
+
+    return [c for c, _ in sorted(colors.items(), key=lambda x: -x[1])]
+
+
+def _normalize_hex(color):
+    """Convert #RGB to #RRGGBB, lowercase."""
+    color = color.lower()
+    if len(color) == 4:
+        return f"#{color[1] * 2}{color[2] * 2}{color[3] * 2}"
+    return color
+
+
+def luminance(hex_color):
+    """Perceived brightness (0-255) using ITU-R BT.601 weighting."""
+    h = hex_color.lstrip("#")
+    r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+    return 0.299 * r + 0.587 * g + 0.114 * b
+
+
+def saturation(hex_color):
+    """HSV saturation (0.0 - 1.0)."""
+    h = hex_color.lstrip("#")
+    r = int(h[0:2], 16) / 255
+    g = int(h[2:4], 16) / 255
+    b = int(h[4:6], 16) / 255
+    mx, mn = max(r, g, b), min(r, g, b)
+    return (mx - mn) / mx if mx > 0 else 0
+
+
+def lighten(hex_color, factor):
+    """Lighten a color by mixing with white. factor: 0.0-1.0."""
+    h = hex_color.lstrip("#")
+    r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+    r = int(r + (255 - r) * factor)
+    g = int(g + (255 - g) * factor)
+    b = int(b + (255 - b) * factor)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def darken(hex_color, factor):
+    """Darken a color by mixing with black. factor: 0.0-1.0."""
+    h = hex_color.lstrip("#")
+    r, g, b = int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+    r = int(r * (1 - factor))
+    g = int(g * (1 - factor))
+    b = int(b * (1 - factor))
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def assign_roles(colors):
+    """
+    Assign semantic roles to a list of extracted colors.
+
+    Strategy:
+        - primary: darkest color (best for body text, headings)
+        - secondary: most saturated color distinct from primary (headings, text highlights)
+        - accent: next most saturated color distinct from primary and secondary
+                  (lines, cover band). Falls back to secondary if the palette
+                  only has two usable colors.
+        - highlight: a 4th tone — next darkest color distinct from the first three
+                     (H3 headings, subtle dividers). Falls back to a darkened
+                     primary when the palette doesn't offer a distinct 4th color.
+        - light: primary lightened 88% (for subtle backgrounds)
+        - lighter: secondary lightened 92% (for zebra rows)
+
+    Args:
+        colors: List of hex color strings.
+
+    Returns:
+        Dict with keys: primary, secondary, accent, highlight, light, lighter, text.
+    """
+    # Filter out near-white and near-black
+    filtered = [c for c in colors if 20 < luminance(c) < 240]
+    if not filtered:
+        filtered = colors if colors else ["#333333"]
+
+    by_lum = sorted(filtered, key=luminance)
+    by_sat = sorted(filtered, key=saturation, reverse=True)
+
+    primary = by_lum[0]
+
+    # Secondary: most saturated color that is not primary
+    secondary = next(
+        (c for c in by_sat if c != primary),
+        by_lum[1] if len(by_lum) > 1 else lighten(primary, 0.3),
+    )
+
+    # Accent: next most saturated distinct from both
+    accent = next(
+        (c for c in by_sat if c != primary and c != secondary),
+        secondary,
+    )
+
+    # Highlight: next darkest color distinct from the first three. Used for
+    # a 4th tone (H3 headings, secondary dividers). Darkened primary fallback.
+    highlight = next(
+        (c for c in by_lum if c not in (primary, secondary, accent)),
+        darken(primary, 0.25),
+    )
+
+    return {
+        "primary": primary,
+        "secondary": secondary,
+        "accent": accent,
+        "highlight": highlight,
+        "light": lighten(primary, 0.88),
+        "lighter": lighten(secondary, 0.92),
+        "text": "#333333",
+    }
+
+
+def extract_and_assign(svg_path):
+    """Convenience: extract colors and assign roles in one call."""
+    colors = extract_colors_from_svg(svg_path)
+    return assign_roles(colors)