reportsmith 0.1.0__py3-none-any.whl

reportsmith/__init__.py

@@ -0,0 +1,60 @@
+"""reportsmith — a small, dependency-free library for building reports.
+
+Build a report programmatically from typed elements (headings, paragraphs,
+tables, lists, code blocks, images, ...) and export it to Markdown or a
+standalone styled HTML document.
+
+Quick start::
+
+    from reportsmith import Report, bold, link
+
+    report = Report("Q3 Sales Report", author="Jane Doe")
+    with report.section("Overview") as s:
+        s.paragraph(["Revenue was ", bold("up 12%"), " quarter over quarter."])
+        s.table(["Region", "Revenue"], [["EMEA", "$1.2M"], ["APAC", "$0.9M"]])
+
+    report.save_markdown("report.md")
+    report.save_html("report.html")
+"""
+
+from .inline import Inline, bold, code, italic, link
+from .elements import (
+    CodeBlock,
+    Heading,
+    HorizontalRule,
+    Image,
+    ListElement,
+    Paragraph,
+    Quote,
+    Raw,
+    Section,
+    Table,
+)
+from .report import Report
+from .renderers.markdown import MarkdownRenderer
+from .renderers.html import HtmlRenderer
+from .renderers.pdf import PdfRenderer
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Report",
+    "Section",
+    "Heading",
+    "Paragraph",
+    "Table",
+    "ListElement",
+    "CodeBlock",
+    "Image",
+    "Quote",
+    "HorizontalRule",
+    "Raw",
+    "Inline",
+    "bold",
+    "italic",
+    "code",
+    "link",
+    "MarkdownRenderer",
+    "HtmlRenderer",
+    "PdfRenderer",
+]

reportsmith/elements.py

@@ -0,0 +1,190 @@
+"""Block-level report elements.
+
+Every element knows nothing about output formats; rendering lives in
+``reportsmith.renderers``. ``Section`` is a container element that also mixes in
+the builder API, so content can be added to a report or any nested section
+with the same methods.
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+from .inline import InlineContent, TextLike, normalize
+
+
+class Element:
+    """Base class for all block elements."""
+
+
+class Heading(Element):
+    def __init__(self, content: TextLike, level: int = 1):
+        if not 1 <= level <= 6:
+            raise ValueError(f"Heading level must be 1-6, got {level}")
+        self.parts: list[InlineContent] = normalize(content)
+        self.level = level
+
+
+class Paragraph(Element):
+    def __init__(self, content: TextLike):
+        self.parts: list[InlineContent] = normalize(content)
+
+
+class Quote(Element):
+    def __init__(self, content: TextLike):
+        self.parts: list[InlineContent] = normalize(content)
+
+
+class CodeBlock(Element):
+    def __init__(self, source: str, language: str = ""):
+        self.source = source
+        self.language = language
+
+
+class ListElement(Element):
+    """Bullet or numbered list. Items may be plain/inline text or nested lists."""
+
+    def __init__(self, items: Sequence, ordered: bool = False):
+        self.ordered = ordered
+        self.items: list = []
+        for item in items:
+            if isinstance(item, ListElement):
+                self.items.append(item)
+            else:
+                self.items.append(normalize(item))
+
+
+class Table(Element):
+    def __init__(
+        self,
+        headers: Sequence[TextLike],
+        rows: Sequence[Sequence[TextLike]],
+        caption: str = "",
+        align: Optional[Sequence[str]] = None,
+    ):
+        self.headers = [normalize(h) for h in headers]
+        self.rows = [[normalize(cell) for cell in row] for row in rows]
+        width = len(self.headers)
+        for i, row in enumerate(self.rows):
+            if len(row) != width:
+                raise ValueError(
+                    f"Row {i} has {len(row)} cells, expected {width}"
+                )
+        self.caption = caption
+        if align is not None:
+            if len(align) != width:
+                raise ValueError("align must have one entry per column")
+            for a in align:
+                if a not in ("left", "center", "right"):
+                    raise ValueError(f"Invalid alignment: {a!r}")
+        self.align = list(align) if align is not None else ["left"] * width
+
+
+class Image(Element):
+    def __init__(self, src: str, alt: str = "", title: str = ""):
+        self.src = src
+        self.alt = alt
+        self.title = title
+
+
+class HorizontalRule(Element):
+    pass
+
+
+class Raw(Element):
+    """Format-specific passthrough content.
+
+    Rendered verbatim when the output format matches (``"markdown"`` or
+    ``"html"``); skipped otherwise. Use ``format="both"`` to always emit.
+    """
+
+    def __init__(self, content: str, format: str = "both"):
+        if format not in ("markdown", "html", "both"):
+            raise ValueError(f"format must be 'markdown', 'html' or 'both', got {format!r}")
+        self.content = content
+        self.format = format
+
+
+class Container(Element):
+    """Mixin providing the fluent builder API shared by Report and Section."""
+
+    def __init__(self) -> None:
+        self.children: list[Element] = []
+        self._level = 0  # heading depth of this container
+
+    def add(self, element: Element) -> "Container":
+        """Append a pre-built element. Returns self for chaining."""
+        self.children.append(element)
+        return self
+
+    def section(self, title: TextLike) -> "Section":
+        """Add a nested section (usable as a context manager)."""
+        section = Section(title, level=self._level + 1)
+        self.children.append(section)
+        return section
+
+    def heading(self, content: TextLike, level: Optional[int] = None) -> "Container":
+        """Add a heading. Level defaults to one below this container's title."""
+        self.children.append(Heading(content, level or min(self._level + 1, 6)))
+        return self
+
+    def paragraph(self, content: TextLike) -> "Container":
+        self.children.append(Paragraph(content))
+        return self
+
+    def quote(self, content: TextLike) -> "Container":
+        self.children.append(Quote(content))
+        return self
+
+    def code(self, source: str, language: str = "") -> "Container":
+        self.children.append(CodeBlock(source, language))
+        return self
+
+    def bullet_list(self, items: Sequence) -> "Container":
+        self.children.append(ListElement(items, ordered=False))
+        return self
+
+    def numbered_list(self, items: Sequence) -> "Container":
+        self.children.append(ListElement(items, ordered=True))
+        return self
+
+    def table(
+        self,
+        headers: Sequence[TextLike],
+        rows: Sequence[Sequence[TextLike]],
+        caption: str = "",
+        align: Optional[Sequence[str]] = None,
+    ) -> "Container":
+        self.children.append(Table(headers, rows, caption, align))
+        return self
+
+    def image(self, src: str, alt: str = "", title: str = "") -> "Container":
+        self.children.append(Image(src, alt, title))
+        return self
+
+    def horizontal_rule(self) -> "Container":
+        self.children.append(HorizontalRule())
+        return self
+
+    def raw(self, content: str, format: str = "both") -> "Container":
+        self.children.append(Raw(content, format))
+        return self
+
+
+class Section(Container):
+    """A titled group of elements; nests to any depth.
+
+    Supports ``with`` syntax purely for readable indentation — entering and
+    exiting the context has no side effects.
+    """
+
+    def __init__(self, title: TextLike, level: int = 1):
+        super().__init__()
+        self.title_parts: list[InlineContent] = normalize(title)
+        self._level = min(level, 6)
+
+    def __enter__(self) -> "Section":
+        return self
+
+    def __exit__(self, *exc_info) -> None:
+        return None

reportsmith/inline.py

@@ -0,0 +1,59 @@
+"""Inline (span-level) content: bold, italic, code, links.
+
+Block elements accept either a plain string or a list mixing strings and
+:class:`Inline` objects, so the same content renders correctly in both
+Markdown and HTML.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable, Sequence, Union
+
+InlineContent = Union[str, "Inline"]
+# What users may pass wherever inline text is expected.
+TextLike = Union[str, "Inline", Sequence[InlineContent]]
+
+
+@dataclass(frozen=True)
+class Inline:
+    """A span of text with a style: 'bold', 'italic', 'code', or 'link'."""
+
+    style: str
+    text: str
+    href: str = ""
+
+
+def bold(text: str) -> Inline:
+    """Bold text span."""
+    return Inline("bold", text)
+
+
+def italic(text: str) -> Inline:
+    """Italic text span."""
+    return Inline("italic", text)
+
+
+def code(text: str) -> Inline:
+    """Inline code span."""
+    return Inline("code", text)
+
+
+def link(text: str, href: str) -> Inline:
+    """Hyperlink span."""
+    return Inline("link", text, href)
+
+
+def normalize(content: TextLike) -> list[InlineContent]:
+    """Coerce any accepted text input into a flat list of str/Inline parts."""
+    if isinstance(content, (str, Inline)):
+        return [content]
+    if isinstance(content, Iterable):
+        parts: list[InlineContent] = []
+        for item in content:
+            if isinstance(item, (str, Inline)):
+                parts.append(item)
+            else:
+                parts.append(str(item))
+        return parts
+    return [str(content)]

reportsmith/renderers/__init__.py

@@ -0,0 +1,5 @@
+from .markdown import MarkdownRenderer
+from .html import HtmlRenderer
+from .pdf import PdfRenderer
+
+__all__ = ["MarkdownRenderer", "HtmlRenderer", "PdfRenderer"]

reportsmith/renderers/html.py

@@ -0,0 +1,203 @@
+"""HTML renderer — produces a standalone styled document or a body fragment."""
+
+from __future__ import annotations
+
+from html import escape
+from typing import TYPE_CHECKING, Optional
+
+from ..elements import (
+    CodeBlock,
+    Element,
+    Heading,
+    HorizontalRule,
+    Image,
+    ListElement,
+    Paragraph,
+    Quote,
+    Raw,
+    Section,
+    Table,
+)
+from ..inline import Inline, InlineContent
+
+if TYPE_CHECKING:
+    from ..report import Report
+
+DEFAULT_CSS = """\
+:root {
+  --text: #1f2933;
+  --muted: #6b7280;
+  --border: #d7dbe0;
+  --accent: #1d4ed8;
+  --code-bg: #f3f4f6;
+  --bg: #ffffff;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #e5e7eb;
+    --muted: #9ca3af;
+    --border: #374151;
+    --accent: #60a5fa;
+    --code-bg: #1f2937;
+    --bg: #111827;
+  }
+}
+body {
+  margin: 0 auto;
+  max-width: 52rem;
+  padding: 2rem 1.5rem 4rem;
+  font-family: -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  line-height: 1.6;
+  color: var(--text);
+  background: var(--bg);
+}
+h1, h2, h3, h4, h5, h6 { line-height: 1.25; margin: 1.6em 0 0.5em; }
+h1 { font-size: 1.9rem; margin-top: 0; }
+h2 { font-size: 1.4rem; border-bottom: 1px solid var(--border); padding-bottom: 0.25em; }
+h3 { font-size: 1.15rem; }
+a { color: var(--accent); }
+.report-meta { color: var(--muted); font-size: 0.9rem; margin-bottom: 2rem; }
+.report-meta .subtitle { font-size: 1.05rem; font-style: italic; }
+table { border-collapse: collapse; margin: 1em 0; width: 100%; }
+th, td { border: 1px solid var(--border); padding: 0.45em 0.7em; text-align: left; }
+th { background: var(--code-bg); }
+caption { caption-side: bottom; color: var(--muted); font-size: 0.85rem; padding-top: 0.4em; }
+code { background: var(--code-bg); border-radius: 4px; padding: 0.15em 0.35em; font-size: 0.9em; }
+pre { background: var(--code-bg); border-radius: 8px; padding: 1em; overflow-x: auto; }
+pre code { background: none; padding: 0; }
+blockquote { border-left: 4px solid var(--border); color: var(--muted); margin: 1em 0; padding: 0.1em 1em; }
+img { max-width: 100%; }
+hr { border: none; border-top: 1px solid var(--border); margin: 2em 0; }
+"""
+
+
+class HtmlRenderer:
+    """Renders a Report to HTML.
+
+    With ``full_document=True`` output is a complete standalone page with the
+    stylesheet embedded; otherwise only the body markup is produced.
+    """
+
+    def __init__(self, full_document: bool = True, css: Optional[str] = None):
+        self.full_document = full_document
+        self.css = DEFAULT_CSS if css is None else css
+
+    def render(self, report: "Report") -> str:
+        body = self._body(report)
+        if not self.full_document:
+            return body
+        return (
+            "<!DOCTYPE html>\n"
+            '<html lang="en">\n<head>\n'
+            '<meta charset="utf-8">\n'
+            '<meta name="viewport" content="width=device-width, initial-scale=1">\n'
+            f"<title>{escape(report.title)}</title>\n"
+            f"<style>\n{self.css}</style>\n"
+            "</head>\n<body>\n"
+            f"{body}"
+            "</body>\n</html>\n"
+        )
+
+    def _body(self, report: "Report") -> str:
+        parts = [f"<h1>{escape(report.title)}</h1>\n"]
+        meta = []
+        if report.subtitle:
+            meta.append(f'<div class="subtitle">{escape(report.subtitle)}</div>')
+        if report.author:
+            meta.append(f"<div><strong>Author:</strong> {escape(report.author)}</div>")
+        if report.date:
+            meta.append(f"<div><strong>Date:</strong> {escape(report.date)}</div>")
+        if meta:
+            parts.append('<div class="report-meta">\n' + "\n".join(meta) + "\n</div>\n")
+        for child in report.children:
+            parts.append(self._render_element(child))
+        return "".join(parts)
+
+    # -- elements --------------------------------------------------------
+
+    def _render_element(self, el: Element) -> str:
+        if isinstance(el, Section):
+            level = el._level
+            out = [f"<h{level}>{self._inline(el.title_parts)}</h{level}>\n"]
+            out.extend(self._render_element(child) for child in el.children)
+            return "".join(out)
+        if isinstance(el, Heading):
+            return f"<h{el.level}>{self._inline(el.parts)}</h{el.level}>\n"
+        if isinstance(el, Paragraph):
+            return f"<p>{self._inline(el.parts)}</p>\n"
+        if isinstance(el, Quote):
+            return f"<blockquote><p>{self._inline(el.parts)}</p></blockquote>\n"
+        if isinstance(el, CodeBlock):
+            cls = f' class="language-{escape(el.language, quote=True)}"' if el.language else ""
+            return f"<pre><code{cls}>{escape(el.source)}</code></pre>\n"
+        if isinstance(el, ListElement):
+            return self._list(el)
+        if isinstance(el, Table):
+            return self._table(el)
+        if isinstance(el, Image):
+            title = f' title="{escape(el.title, quote=True)}"' if el.title else ""
+            return (
+                f'<img src="{escape(el.src, quote=True)}" '
+                f'alt="{escape(el.alt, quote=True)}"{title}>\n'
+            )
+        if isinstance(el, HorizontalRule):
+            return "<hr>\n"
+        if isinstance(el, Raw):
+            return el.content + "\n" if el.format in ("html", "both") else ""
+        raise TypeError(f"Cannot render element of type {type(el).__name__}")
+
+    def _list(self, el: ListElement) -> str:
+        tag = "ol" if el.ordered else "ul"
+        out = [f"<{tag}>\n"]
+        for item in el.items:
+            if isinstance(item, ListElement):
+                # Nested list lives inside the preceding <li> per HTML spec;
+                # emit as its own item if there is no preceding one.
+                nested = self._list(item)
+                if out[-1].endswith("</li>\n"):
+                    out[-1] = out[-1][: -len("</li>\n")] + "\n" + nested + "</li>\n"
+                else:
+                    out.append(f"<li>{nested}</li>\n")
+            else:
+                out.append(f"<li>{self._inline(item)}</li>\n")
+        out.append(f"</{tag}>\n")
+        return "".join(out)
+
+    def _table(self, el: Table) -> str:
+        out = ["<table>\n"]
+        if el.caption:
+            out.append(f"<caption>{escape(el.caption)}</caption>\n")
+        out.append("<thead>\n<tr>")
+        for header, align in zip(el.headers, el.align):
+            out.append(f'<th style="text-align:{align}">{self._inline(header)}</th>')
+        out.append("</tr>\n</thead>\n<tbody>\n")
+        for row in el.rows:
+            out.append("<tr>")
+            for cell, align in zip(row, el.align):
+                out.append(f'<td style="text-align:{align}">{self._inline(cell)}</td>')
+            out.append("</tr>\n")
+        out.append("</tbody>\n</table>\n")
+        return "".join(out)
+
+    # -- inline ----------------------------------------------------------
+
+    def _inline(self, parts: list[InlineContent]) -> str:
+        out = []
+        for part in parts:
+            if isinstance(part, Inline):
+                out.append(self._span(part))
+            else:
+                out.append(escape(str(part)))
+        return "".join(out)
+
+    def _span(self, span: Inline) -> str:
+        text = escape(span.text)
+        if span.style == "bold":
+            return f"<strong>{text}</strong>"
+        if span.style == "italic":
+            return f"<em>{text}</em>"
+        if span.style == "code":
+            return f"<code>{text}</code>"
+        if span.style == "link":
+            return f'<a href="{escape(span.href, quote=True)}">{text}</a>'
+        return text

reportsmith/renderers/markdown.py

@@ -0,0 +1,131 @@
+"""Markdown renderer."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..elements import (
+    CodeBlock,
+    Element,
+    Heading,
+    HorizontalRule,
+    Image,
+    ListElement,
+    Paragraph,
+    Quote,
+    Raw,
+    Section,
+    Table,
+)
+from ..inline import Inline, InlineContent
+
+if TYPE_CHECKING:
+    from ..report import Report
+
+_ALIGN_MARKERS = {"left": ":---", "center": ":---:", "right": "---:"}
+
+
+class MarkdownRenderer:
+    """Renders a Report to GitHub-flavored Markdown."""
+
+    def render(self, report: "Report") -> str:
+        blocks: list[str] = [f"# {report.title}"]
+        meta = self._metadata_lines(report)
+        if meta:
+            blocks.append("\n".join(meta))
+        for child in report.children:
+            blocks.extend(self._render_element(child))
+        return "\n\n".join(blocks) + "\n"
+
+    def _metadata_lines(self, report: "Report") -> list[str]:
+        lines = []
+        if report.subtitle:
+            lines.append(f"*{report.subtitle}*  ")
+        if report.author:
+            lines.append(f"**Author:** {report.author}  ")
+        if report.date:
+            lines.append(f"**Date:** {report.date}  ")
+        return lines
+
+    # -- elements --------------------------------------------------------
+
+    def _render_element(self, el: Element) -> list[str]:
+        if isinstance(el, Section):
+            blocks = [f"{'#' * el._level} {self._inline(el.title_parts)}"]
+            for child in el.children:
+                blocks.extend(self._render_element(child))
+            return blocks
+        if isinstance(el, Heading):
+            return [f"{'#' * el.level} {self._inline(el.parts)}"]
+        if isinstance(el, Paragraph):
+            return [self._inline(el.parts)]
+        if isinstance(el, Quote):
+            text = self._inline(el.parts)
+            return ["\n".join(f"> {line}" for line in text.splitlines() or [""])]
+        if isinstance(el, CodeBlock):
+            fence = "```"
+            # Widen the fence if the source itself contains backtick fences.
+            while fence in el.source:
+                fence += "`"
+            return [f"{fence}{el.language}\n{el.source}\n{fence}"]
+        if isinstance(el, ListElement):
+            return ["\n".join(self._list_lines(el, indent=0))]
+        if isinstance(el, Table):
+            return [self._table(el)]
+        if isinstance(el, Image):
+            title = f' "{el.title}"' if el.title else ""
+            return [f"![{el.alt}]({el.src}{title})"]
+        if isinstance(el, HorizontalRule):
+            return ["---"]
+        if isinstance(el, Raw):
+            return [el.content] if el.format in ("markdown", "both") else []
+        raise TypeError(f"Cannot render element of type {type(el).__name__}")
+
+    def _list_lines(self, el: ListElement, indent: int) -> list[str]:
+        lines: list[str] = []
+        pad = "  " * indent
+        counter = 0
+        for item in el.items:
+            if isinstance(item, ListElement):
+                lines.extend(self._list_lines(item, indent + 1))
+            else:
+                counter += 1
+                marker = f"{counter}." if el.ordered else "-"
+                lines.append(f"{pad}{marker} {self._inline(item)}")
+        return lines
+
+    def _table(self, el: Table) -> str:
+        def cell(parts: list[InlineContent]) -> str:
+            # Pipes break table syntax; newlines become <br> inside cells.
+            return self._inline(parts).replace("|", "\\|").replace("\n", "<br>")
+
+        lines = ["| " + " | ".join(cell(h) for h in el.headers) + " |"]
+        lines.append("| " + " | ".join(_ALIGN_MARKERS[a] for a in el.align) + " |")
+        for row in el.rows:
+            lines.append("| " + " | ".join(cell(c) for c in row) + " |")
+        table = "\n".join(lines)
+        if el.caption:
+            table += f"\n\n*{el.caption}*"
+        return table
+
+    # -- inline ----------------------------------------------------------
+
+    def _inline(self, parts: list[InlineContent]) -> str:
+        out = []
+        for part in parts:
+            if isinstance(part, Inline):
+                out.append(self._span(part))
+            else:
+                out.append(str(part))
+        return "".join(out)
+
+    def _span(self, span: Inline) -> str:
+        if span.style == "bold":
+            return f"**{span.text}**"
+        if span.style == "italic":
+            return f"*{span.text}*"
+        if span.style == "code":
+            return f"`{span.text}`"
+        if span.style == "link":
+            return f"[{span.text}]({span.href})"
+        return span.text

reportsmith/renderers/pdf.py

@@ -0,0 +1,323 @@
+"""PDF renderer — renders a Report to PDF via the optional fpdf2 dependency.
+
+fpdf2 is imported lazily inside :meth:`PdfRenderer.render`, so importing this
+module (and the reportsmith package) works without it; only actually rendering
+a PDF requires ``pip install reportsmith[pdf]``.
+
+Unicode: the PDF core fonts (Helvetica/Courier) only cover Latin-1, so the
+renderer probes for a system TrueType family (Arial/Segoe UI on Windows,
+DejaVu on Linux, Arial on macOS) and embeds it when found. Without one,
+unsupported characters degrade to ``?`` instead of crashing. Pass explicit
+font paths to control the typeface.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import TYPE_CHECKING, Optional, Sequence
+
+from ..elements import (
+    CodeBlock,
+    Element,
+    Heading,
+    HorizontalRule,
+    Image,
+    ListElement,
+    Paragraph,
+    Quote,
+    Raw,
+    Section,
+    Table,
+)
+from ..inline import Inline, InlineContent
+
+if TYPE_CHECKING:
+    from ..report import Report
+
+PAGE_MARGIN = 18  # mm
+BODY_SIZE = 11
+_HEADING_SIZES = {1: 20, 2: 16, 3: 13.5, 4: 12, 5: 11, 6: 10.5}
+
+_TEXT = (31, 41, 55)
+_MUTED = (107, 114, 128)
+_ACCENT = (29, 78, 216)
+_BORDER = (183, 189, 196)
+_CODE_BG = (243, 244, 246)
+
+_WIN_FONTS = os.path.join(os.environ.get("WINDIR", r"C:\Windows"), "Fonts")
+_MAC_FONTS = "/System/Library/Fonts/Supplemental"
+_DEJAVU = "/usr/share/fonts/truetype/dejavu"
+
+# (regular, bold, italic, bold-italic) quadruples, first complete one wins.
+_BODY_FONT_CANDIDATES = [
+    tuple(os.path.join(_WIN_FONTS, f) for f in ("arial.ttf", "arialbd.ttf", "ariali.ttf", "arialbi.ttf")),
+    tuple(os.path.join(_WIN_FONTS, f) for f in ("segoeui.ttf", "segoeuib.ttf", "segoeuii.ttf", "segoeuiz.ttf")),
+    tuple(os.path.join(_DEJAVU, f) for f in ("DejaVuSans.ttf", "DejaVuSans-Bold.ttf", "DejaVuSans-Oblique.ttf", "DejaVuSans-BoldOblique.ttf")),
+    tuple(os.path.join(_MAC_FONTS, f) for f in ("Arial.ttf", "Arial Bold.ttf", "Arial Italic.ttf", "Arial Bold Italic.ttf")),
+]
+_MONO_FONT_CANDIDATES = [
+    tuple(os.path.join(_WIN_FONTS, f) for f in ("consola.ttf", "consolab.ttf", "consolai.ttf", "consolaz.ttf")),
+    tuple(os.path.join(_DEJAVU, f) for f in ("DejaVuSansMono.ttf", "DejaVuSansMono-Bold.ttf", "DejaVuSansMono-Oblique.ttf", "DejaVuSansMono-BoldOblique.ttf")),
+    tuple(os.path.join(_MAC_FONTS, f) for f in ("Courier New.ttf", "Courier New Bold.ttf", "Courier New Italic.ttf", "Courier New Bold Italic.ttf")),
+]
+
+
+def _find_fonts(candidates, override) -> Optional[tuple]:
+    if override is not None:
+        return tuple(override) if override else None
+    for quad in candidates:
+        if all(os.path.isfile(p) for p in quad):
+            return quad
+    return None
+
+
+class PdfRenderer:
+    """Renders a Report to a PDF document (A4).
+
+    :param fonts: optional (regular, bold, italic, bold-italic) TTF paths for
+        body text; ``None`` auto-detects a system family, ``()`` forces the
+        Latin-1 core Helvetica.
+    :param mono_fonts: same, for code; falls back to core Courier.
+    """
+
+    def __init__(
+        self,
+        fonts: Optional[Sequence[str]] = None,
+        mono_fonts: Optional[Sequence[str]] = None,
+    ):
+        self._fonts = fonts
+        self._mono_fonts = mono_fonts
+        self.unicode = False
+        self.body_family = "helvetica"
+        self.mono_family = "courier"
+
+    def render(self, report: "Report") -> bytes:
+        try:
+            from fpdf import FPDF
+        except ImportError:
+            raise ImportError(
+                "PDF export requires the optional dependency fpdf2. "
+                "Install it with: pip install reportsmith[pdf]"
+            ) from None
+
+        pdf = FPDF(format="A4")
+        pdf.set_margins(PAGE_MARGIN, PAGE_MARGIN)
+        pdf.set_auto_page_break(True, margin=PAGE_MARGIN)
+        self._setup_fonts(pdf)
+        pdf.add_page()
+        pdf.set_title(report.title)
+        if report.author:
+            pdf.set_author(report.author)
+        self._title_block(pdf, report)
+        for child in report.children:
+            self._element(pdf, child)
+        return bytes(pdf.output())
+
+    # -- setup -----------------------------------------------------------
+
+    def _setup_fonts(self, pdf) -> None:
+        # fontTools logs a benign warning per unsupported table when
+        # subsetting system fonts (e.g. Arial's MERG table); silence it.
+        logging.getLogger("fontTools.subset").setLevel(logging.ERROR)
+        body = _find_fonts(_BODY_FONT_CANDIDATES, self._fonts)
+        if body:
+            for style, path in zip(("", "B", "I", "BI"), body):
+                pdf.add_font("rsbody", style, path)
+            self.body_family, self.unicode = "rsbody", True
+        mono = _find_fonts(_MONO_FONT_CANDIDATES, self._mono_fonts)
+        if mono:
+            for style, path in zip(("", "B", "I", "BI"), mono):
+                pdf.add_font("rsmono", style, path)
+            self.mono_family = "rsmono"
+
+    def _t(self, text: str) -> str:
+        # Core fonts are Latin-1 only; degrade unsupported chars to '?'.
+        if self.unicode:
+            return text
+        return text.encode("latin-1", "replace").decode("latin-1")
+
+    def _title_block(self, pdf, report: "Report") -> None:
+        pdf.set_text_color(*_TEXT)
+        pdf.set_font(self.body_family, "B", 22)
+        pdf.multi_cell(0, 10, self._t(report.title), new_x="LMARGIN", new_y="NEXT")
+        if report.subtitle:
+            pdf.set_font(self.body_family, "I", 12)
+            pdf.set_text_color(*_MUTED)
+            pdf.multi_cell(0, 7, self._t(report.subtitle), new_x="LMARGIN", new_y="NEXT")
+        meta = " · ".join(x for x in (report.author, report.date) if x)
+        if meta:
+            pdf.set_font(self.body_family, "", 10)
+            pdf.set_text_color(*_MUTED)
+            pdf.multi_cell(0, 6, self._t(meta), new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(2)
+        pdf.set_draw_color(*_BORDER)
+        pdf.line(pdf.l_margin, pdf.get_y(), pdf.w - pdf.r_margin, pdf.get_y())
+        pdf.ln(6)
+
+    # -- elements --------------------------------------------------------
+
+    def _element(self, pdf, el: Element) -> None:
+        if isinstance(el, Section):
+            self._keep_with_next(pdf)
+            # PDF outline (bookmarks): top-level sections at outline level 0.
+            pdf.start_section(self._t(self._plain(el.title_parts)), level=el._level - 2)
+            self._heading(pdf, el.title_parts, el._level)
+            for child in el.children:
+                self._element(pdf, child)
+        elif isinstance(el, Heading):
+            self._keep_with_next(pdf)
+            self._heading(pdf, el.parts, el.level)
+        elif isinstance(el, Paragraph):
+            self._write_parts(pdf, el.parts, BODY_SIZE)
+            pdf.ln(BODY_SIZE * 0.55)
+            pdf.ln(1.5)
+        elif isinstance(el, Quote):
+            self._quote(pdf, el)
+        elif isinstance(el, CodeBlock):
+            pdf.set_font(self.mono_family, "", 9.5)
+            pdf.set_text_color(*_TEXT)
+            pdf.set_fill_color(*_CODE_BG)
+            pdf.multi_cell(0, 5, self._t(el.source), fill=True, new_x="LMARGIN", new_y="NEXT")
+            pdf.ln(2.5)
+        elif isinstance(el, ListElement):
+            root = pdf.l_margin
+            self._list_items(pdf, el, root, 0)
+            pdf.set_left_margin(root)
+            pdf.ln(1.5)
+        elif isinstance(el, Table):
+            self._table(pdf, el)
+        elif isinstance(el, Image):
+            self._image(pdf, el)
+        elif isinstance(el, HorizontalRule):
+            pdf.ln(2)
+            pdf.set_draw_color(*_BORDER)
+            pdf.line(pdf.l_margin, pdf.get_y(), pdf.w - pdf.r_margin, pdf.get_y())
+            pdf.ln(4)
+        elif isinstance(el, Raw):
+            pass  # format-specific passthrough has no meaning in PDF
+        else:
+            raise TypeError(f"Cannot render element of type {type(el).__name__}")
+
+    def _keep_with_next(self, pdf) -> None:
+        # Avoid a heading orphaned at the bottom of a page.
+        if pdf.get_y() > pdf.h - PAGE_MARGIN - 30:
+            pdf.add_page()
+
+    def _heading(self, pdf, parts: list[InlineContent], level: int) -> None:
+        size = _HEADING_SIZES[level]
+        pdf.ln(2.5)
+        self._write_parts(pdf, parts, size, base_style="B")
+        pdf.ln(size * 0.55)
+        pdf.ln(2)
+
+    def _quote(self, pdf, el: Quote) -> None:
+        root = pdf.l_margin
+        pdf.set_left_margin(root + 6)
+        pdf.set_x(root + 6)
+        page_before, y_before = pdf.page_no(), pdf.get_y()
+        self._write_parts(pdf, el.parts, BODY_SIZE, base_style="I", color=_MUTED)
+        pdf.ln(BODY_SIZE * 0.55)
+        if pdf.page_no() == page_before:
+            pdf.set_draw_color(*_BORDER)
+            pdf.set_line_width(0.8)
+            pdf.line(root + 2, y_before, root + 2, pdf.get_y())
+            pdf.set_line_width(0.2)
+        pdf.set_left_margin(root)
+        pdf.ln(1.5)
+
+    def _list_items(self, pdf, el: ListElement, root: float, depth: int) -> None:
+        counter = 0
+        for item in el.items:
+            if isinstance(item, ListElement):
+                self._list_items(pdf, item, root, depth + 1)
+            else:
+                counter += 1
+                bullet = "\u2022" if self.unicode else "-"
+                marker = f"{counter}." if el.ordered else bullet
+                pdf.set_left_margin(root + 6 * depth)
+                pdf.set_x(root + 6 * depth)
+                pdf.set_font(self.body_family, "", BODY_SIZE)
+                pdf.set_text_color(*_TEXT)
+                pdf.write(BODY_SIZE * 0.55, f"{marker} ")
+                self._write_parts(pdf, item, BODY_SIZE)
+                pdf.ln(BODY_SIZE * 0.55)
+
+    def _table(self, pdf, el: Table) -> None:
+        pdf.set_font(self.body_family, "", 10)
+        pdf.set_text_color(*_TEXT)
+        pdf.set_draw_color(*_BORDER)
+        aligns = tuple(a.upper() for a in el.align)
+        with pdf.table(text_align=aligns, line_height=6) as table:
+            header = table.row()
+            for parts in el.headers:
+                header.cell(self._t(self._plain(parts)))
+            for row_parts in el.rows:
+                row = table.row()
+                for parts in row_parts:
+                    row.cell(self._t(self._plain(parts)))
+        if el.caption:
+            pdf.ln(1)
+            pdf.set_font(self.body_family, "I", 9)
+            pdf.set_text_color(*_MUTED)
+            pdf.multi_cell(0, 5, self._t(el.caption), new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(2.5)
+
+    def _image(self, pdf, el: Image) -> None:
+        try:
+            pdf.image(el.src, w=pdf.epw)
+        except Exception:
+            # Missing/remote/unreadable file: render a placeholder, keep going.
+            pdf.set_font(self.body_family, "I", 10)
+            pdf.set_text_color(*_MUTED)
+            pdf.multi_cell(0, 6, self._t(f"[Image: {el.alt or el.src}]"), new_x="LMARGIN", new_y="NEXT")
+        else:
+            if el.title:
+                pdf.set_font(self.body_family, "I", 9)
+                pdf.set_text_color(*_MUTED)
+                pdf.multi_cell(0, 5, self._t(el.title), new_x="LMARGIN", new_y="NEXT")
+        pdf.ln(2)
+
+    # -- inline ----------------------------------------------------------
+
+    def _write_parts(
+        self,
+        pdf,
+        parts: list[InlineContent],
+        size: float,
+        base_style: str = "",
+        color: tuple = _TEXT,
+    ) -> None:
+        h = size * 0.55
+        pdf.set_text_color(*color)
+        for part in parts:
+            if isinstance(part, Inline):
+                text = self._t(part.text)
+                if part.style == "bold":
+                    pdf.set_font(self.body_family, self._merge(base_style, "B"), size)
+                    pdf.write(h, text)
+                elif part.style == "italic":
+                    pdf.set_font(self.body_family, self._merge(base_style, "I"), size)
+                    pdf.write(h, text)
+                elif part.style == "code":
+                    pdf.set_font(self.mono_family, base_style, size * 0.92)
+                    pdf.write(h, text)
+                elif part.style == "link":
+                    pdf.set_font(self.body_family, self._merge(base_style, "U"), size)
+                    pdf.set_text_color(*_ACCENT)
+                    pdf.write(h, text, link=part.href)
+                    pdf.set_text_color(*color)
+                else:
+                    pdf.set_font(self.body_family, base_style, size)
+                    pdf.write(h, text)
+            else:
+                pdf.set_font(self.body_family, base_style, size)
+                pdf.write(h, self._t(str(part)))
+
+    @staticmethod
+    def _merge(base: str, extra: str) -> str:
+        return "".join(s for s in ("B", "I", "U") if s in base or s in extra)
+
+    @staticmethod
+    def _plain(parts: list[InlineContent]) -> str:
+        return "".join(p.text if isinstance(p, Inline) else str(p) for p in parts)

reportsmith/report.py

@@ -0,0 +1,98 @@
+"""The Report — top-level container plus export entry points."""
+
+from __future__ import annotations
+
+import datetime as _dt
+from pathlib import Path
+from typing import Optional, Sequence, Union
+
+from .elements import Container
+
+
+class Report(Container):
+    """A report document.
+
+    Content is added through the fluent builder methods inherited from
+    :class:`~reportsmith.elements.Container` (``paragraph``, ``table``,
+    ``section``, ...) and exported with :meth:`to_markdown` /
+    :meth:`to_html` or saved with :meth:`save_markdown` / :meth:`save_html`.
+    """
+
+    def __init__(
+        self,
+        title: str,
+        author: str = "",
+        date: Optional[Union[str, _dt.date, _dt.datetime]] = None,
+        subtitle: str = "",
+    ):
+        super().__init__()
+        self.title = title
+        self.author = author
+        self.subtitle = subtitle
+        if date is None:
+            self.date = _dt.date.today().isoformat()
+        elif isinstance(date, (_dt.date, _dt.datetime)):
+            self.date = date.isoformat()
+        else:
+            self.date = str(date)
+        self._level = 1  # report title is <h1>, top-level sections are <h2>
+
+    # -- export ----------------------------------------------------------
+
+    def to_markdown(self) -> str:
+        """Render the report as a Markdown string."""
+        from .renderers.markdown import MarkdownRenderer
+
+        return MarkdownRenderer().render(self)
+
+    def to_html(self, full_document: bool = True, css: Optional[str] = None) -> str:
+        """Render the report as HTML.
+
+        ``full_document=True`` (default) produces a standalone page with
+        embedded CSS; ``False`` produces only the body fragment. Pass ``css``
+        to replace the built-in stylesheet.
+        """
+        from .renderers.html import HtmlRenderer
+
+        return HtmlRenderer(full_document=full_document, css=css).render(self)
+
+    def to_pdf(
+        self,
+        fonts: Optional[Sequence[str]] = None,
+        mono_fonts: Optional[Sequence[str]] = None,
+    ) -> bytes:
+        """Render the report as PDF bytes.
+
+        Requires the optional ``fpdf2`` dependency (``pip install
+        reportsmith[pdf]``). ``fonts`` / ``mono_fonts`` are optional
+        (regular, bold, italic, bold-italic) TTF path quadruples; by default
+        a Unicode-capable system font family is auto-detected.
+        """
+        from .renderers.pdf import PdfRenderer
+
+        return PdfRenderer(fonts=fonts, mono_fonts=mono_fonts).render(self)
+
+    def save_markdown(self, path: Union[str, Path]) -> Path:
+        """Write the Markdown export to ``path`` and return it."""
+        path = Path(path)
+        path.write_text(self.to_markdown(), encoding="utf-8")
+        return path
+
+    def save_html(
+        self, path: Union[str, Path], full_document: bool = True, css: Optional[str] = None
+    ) -> Path:
+        """Write the HTML export to ``path`` and return it."""
+        path = Path(path)
+        path.write_text(self.to_html(full_document=full_document, css=css), encoding="utf-8")
+        return path
+
+    def save_pdf(
+        self,
+        path: Union[str, Path],
+        fonts: Optional[Sequence[str]] = None,
+        mono_fonts: Optional[Sequence[str]] = None,
+    ) -> Path:
+        """Write the PDF export to ``path`` and return it (requires fpdf2)."""
+        path = Path(path)
+        path.write_bytes(self.to_pdf(fonts=fonts, mono_fonts=mono_fonts))
+        return path

reportsmith-0.1.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: reportsmith
+Version: 0.1.0
+Summary: A small, dependency-free library for building reports and exporting them to Markdown and HTML
+Author: Michal Stojke
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mstojke/reportsmith
+Project-URL: Documentation, https://github.com/mstojke/reportsmith/blob/main/docs/user-guide.md
+Project-URL: Changelog, https://github.com/mstojke/reportsmith/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/mstojke/reportsmith/issues
+Keywords: report,markdown,html,export,document
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: pdf
+Requires-Dist: fpdf2; extra == "pdf"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: fpdf2; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Dynamic: license-file
+
+# reportsmith
+
+A small, dependency-free Python library for building reports programmatically and exporting them to **Markdown**, a **standalone styled HTML** document, or (optionally) **PDF**.
+
+## Features
+
+- Fluent builder API with chainable methods and nested sections (`with report.section(...)`)
+- Elements: headings, paragraphs, tables (with alignment and captions), bullet/numbered lists (nestable), code blocks, block quotes, images, horizontal rules, and format-specific raw passthrough
+- Inline formatting helpers: `bold()`, `italic()`, `code()`, `link()` — render correctly in both formats
+- Correct escaping everywhere: HTML entities, Markdown table pipes, code fences that widen when the source contains ` ``` `
+- HTML export ships with a clean embedded stylesheet (light/dark aware) that you can replace with your own CSS
+- Optional PDF export (`pip install reportsmith[pdf]`, via fpdf2): matching styling, PDF bookmarks from sections, clickable links, auto-detected Unicode system fonts
+- No required dependencies; Python 3.9+
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or just copy the `reportsmith/` package into your project — it has no dependencies.
+
+## Quick start
+
+```python
+from reportsmith import Report, bold, link
+
+report = Report("Q3 Sales Report", author="Jane Doe", subtitle="Quarterly summary")
+
+with report.section("Overview") as s:
+    s.paragraph(["Revenue was ", bold("up 12%"), " quarter over quarter."])
+    s.table(
+        ["Region", "Revenue"],
+        [["EMEA", "$1.2M"], ["APAC", "$0.9M"]],
+        caption="Revenue by region",
+        align=["left", "right"],
+    )
+
+with report.section("Next steps") as s:
+    s.numbered_list([
+        "Expand APAC sales team",
+        ["Review ", link("pricing proposal", "https://example.com/pricing")],
+    ])
+
+print(report.to_markdown())          # Markdown string
+print(report.to_html())              # standalone HTML page
+report.save_markdown("report.md")
+report.save_html("report.html")
+```
+
+Run `python example.py` for a fuller demo that writes `example_report.md` and `example_report.html`.
+
+## Documentation
+
+- **[User Guide](https://github.com/mstojke/reportsmith/blob/main/docs/user-guide.md)** — a walkthrough of every feature with examples: sections, inline formatting, tables, lists, raw passthrough, HTML customization, and escaping behavior.
+- **[API Reference](https://github.com/mstojke/reportsmith/blob/main/docs/api-reference.rst)** — signatures, parameters, and exceptions for every public class and function (reStructuredText, Sphinx-ready).
+
+The docs are also a buildable Sphinx site:
+
+```bash
+pip install -e .[docs]
+```
+
+```bash
+python -m sphinx -b html docs docs/_build/html
+```
+
+Then open `docs/_build/html/index.html`.
+
+## API overview
+
+### `Report(title, author="", date=None, subtitle="")`
+
+`date` accepts a string, `datetime.date`, or `datetime.datetime`; it defaults to today.
+
+Builder methods (all chainable, also available on sections):
+
+| Method | Adds |
+| --- | --- |
+| `section(title)` | Nested section; heading level tracks nesting depth. Usable as a context manager. |
+| `heading(text, level=None)` | Explicit heading (level defaults to the container's depth + 1) |
+| `paragraph(content)` | Paragraph |
+| `quote(content)` | Block quote |
+| `code(source, language="")` | Fenced/`<pre>` code block |
+| `bullet_list(items)` / `numbered_list(items)` | List; items may be text or a nested `ListElement` |
+| `table(headers, rows, caption="", align=None)` | Table; `align` entries are `"left"`, `"center"`, `"right"` |
+| `image(src, alt="", title="")` | Image |
+| `horizontal_rule()` | Rule |
+| `raw(content, format="both")` | Verbatim content for `"markdown"`, `"html"`, or `"both"` |
+| `add(element)` | Any pre-built element |
+
+Anywhere text is accepted you may pass a plain string or a list mixing strings with `bold()`, `italic()`, `code()`, and `link(text, href)` spans.
+
+### Export
+
+- `report.to_markdown()` → GitHub-flavored Markdown string
+- `report.to_html(full_document=True, css=None)` → HTML string; `full_document=False` returns just the body fragment, `css=` replaces the default stylesheet
+- `report.to_pdf(fonts=None, mono_fonts=None)` → PDF bytes (requires the `pdf` extra); pass TTF path quadruples to control typefaces
+- `report.save_markdown(path)` / `report.save_html(path, ...)` / `report.save_pdf(path, ...)` → write to a file, return the `Path`
+
+## Running tests
+
+The test suite (93 tests, 100% line coverage) lives in `tests/`:
+
+```bash
+python -m pytest
+```
+
+With a coverage report (requires `pytest-cov`):
+
+```bash
+python -m pytest --cov=reportsmith --cov-report=term-missing
+```
+
+## Changelog
+
+See [CHANGELOG.md](https://github.com/mstojke/reportsmith/blob/main/CHANGELOG.md) — the format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## License
+
+MIT

reportsmith-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+reportsmith/__init__.py,sha256=4Yv1dSfD4luoVKfmUsDVvJboTQo-gLaVMGe6RssyCY0,1362
+reportsmith/elements.py,sha256=-v_gy9ruvzxzdvdKTZWZq0rnMYiq_AHIa31YamPyudE,6093
+reportsmith/inline.py,sha256=H_5SzKg36BfYTBidn759Dx2-nxvtcaI6N-HuOAgYTcU,1549
+reportsmith/report.py,sha256=R8EKPg5Z8dNODDQuUNidf5BWL2NVRXIR0vpjb8nriOU,3449
+reportsmith/renderers/__init__.py,sha256=sGmD7bLiAWTPIVRyZW3ggM1ZZB-7E6v4YGf1_P5hZvE,162
+reportsmith/renderers/html.py,sha256=oBUM77arNPlR4z9kFlCMrnZMsxOMBbVrLwutD6frB88,7564
+reportsmith/renderers/markdown.py,sha256=eBJUpGdECyhW2oM5AjLOleR6hlfZeOifnb8Ors6-y2w,4587
+reportsmith/renderers/pdf.py,sha256=qJSFHjyEATY3Lm2p4oaoZWa9t_0-CMH7inFUGh8elLg,12914
+reportsmith-0.1.0.dist-info/licenses/LICENSE,sha256=rNTE3I7bCthKnr3bZbc9AVBMm18zFeskOwYAvWqU3qk,1070
+reportsmith-0.1.0.dist-info/METADATA,sha256=mlUPqmPjy2thOhF1uuouRvl61hiG6ikZrS1nv9JTFKc,6159
+reportsmith-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+reportsmith-0.1.0.dist-info/top_level.txt,sha256=mXd4L_SxomNhM6hHlj5yYUfWH7JMp3TYtZpwzxh-6Ws,12
+reportsmith-0.1.0.dist-info/RECORD,,

reportsmith-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

reportsmith-0.1.0.dist-info/licenses/LICENSE

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

reportsmith-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+reportsmith