licos-dev-sdk 0.3.2__tar.gz → 0.3.4__tar.gz

{licos_dev_sdk-0.3.2 → licos_dev_sdk-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.3.2
+Version: 0.3.4
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
 Requires-Dist: beautifulsoup4>=4.12

{licos_dev_sdk-0.3.2 → licos_dev_sdk-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.3.2"
+version = "0.3.4"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [

{licos_dev_sdk-0.3.2 → licos_dev_sdk-0.3.4}/src/licos_dev_sdk/__init__.py

@@ -39,6 +39,8 @@ def __getattr__(name: str):
         "create_diagram": ("diagram", "create_diagram"),
         # presentation
         "create_pptx": ("presentation", "create_pptx"),
+        "create_pptx_deck": ("presentation", "create_pptx_deck"),
+        "inspect_pptx": ("presentation_inspect", "inspect_pptx"),
         # model catalog and model tools
         "ModelRuntime": ("model", "ModelRuntime"),
         "ModelEndpoint": ("model", "ModelEndpoint"),
@@ -96,7 +98,7 @@ __all__ = [
     "create_xlsx", "create_xlsx_workbook", "create_csv", "inspect_xlsx",
     "create_chart",
     "create_diagram",
-    "create_pptx",
+    "create_pptx", "create_pptx_deck", "inspect_pptx",
     "ModelRuntime", "ModelEndpoint", "ModelResult",
     "ApiError", "ConfigurationError",
     "LLMClient", "create_chat_openai", "VisionClient", "VisionUnderstandingClient", "ImageGenerationClient", "VideoGenerationClient",

licos_dev_sdk-0.3.4/src/licos_dev_sdk/chart.py

@@ -0,0 +1,114 @@
+"""Chart generation — bar, line, pie, scatter, heatmap via matplotlib."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+
+import matplotlib
+matplotlib.use("Agg")  # Non-interactive backend
+from matplotlib import font_manager
+import matplotlib.pyplot as plt
+import numpy as np
+
+from ._utils import resolve_output_path
+
+
+_CJK_FONT_CANDIDATES = (
+    "Noto Sans CJK SC",
+    "Noto Sans SC",
+    "Microsoft YaHei",
+    "SimHei",
+    "WenQuanYi Zen Hei",
+    "Source Han Sans CN",
+)
+
+
+@lru_cache(maxsize=1)
+def _resolve_cjk_font() -> str:
+    installed_fonts = {font.name.casefold(): font.name for font in font_manager.fontManager.ttflist}
+    for candidate in _CJK_FONT_CANDIDATES:
+        installed_name = installed_fonts.get(candidate.casefold())
+        if installed_name:
+            return installed_name
+    choices = ", ".join(_CJK_FONT_CANDIDATES)
+    raise RuntimeError(
+        "Chinese chart font is unavailable. Install a CJK font before generating charts "
+        f"(supported families: {choices})."
+    )
+
+
+def create_chart(chart_type: str, data: dict, filename: str, *,
+                 output_dir: str | None = None, format: str = "png",
+                 title: str = "", width: int = 800, height: int = 600) -> str:
+    """Generate a chart image (PNG/SVG). Returns absolute path.
+
+    Args:
+        chart_type: "bar" | "line" | "pie" | "scatter" | "heatmap"
+        data: {
+            "labels": ["A", "B", "C"],
+            "datasets": [{"label": "Series 1", "values": [10, 20, 30]}]
+        }
+        For pie: only first dataset is used.
+        For heatmap: data["matrix"] = [[1,2],[3,4]], data["x_labels"], data["y_labels"]
+    """
+    path = resolve_output_path(filename, f".{format}", output_dir)
+    dpi = 100
+    font_name = _resolve_cjk_font()
+    chart_style = {
+        "font.family": "sans-serif",
+        "font.sans-serif": [font_name],
+        "axes.unicode_minus": False,
+    }
+    with matplotlib.rc_context(chart_style):
+        fig, ax = plt.subplots(figsize=(width / dpi, height / dpi), dpi=dpi)
+
+        labels = data.get("labels", [])
+        datasets = data.get("datasets", [])
+
+        if chart_type == "bar":
+            x = np.arange(len(labels))
+            n = len(datasets)
+            bar_width = 0.8 / max(n, 1)
+            for i, ds in enumerate(datasets):
+                offset = (i - n / 2 + 0.5) * bar_width
+                ax.bar(x + offset, ds["values"], bar_width, label=ds.get("label", ""))
+            ax.set_xticks(x)
+            ax.set_xticklabels(labels)
+            if n > 1:
+                ax.legend()
+
+        elif chart_type == "line":
+            for ds in datasets:
+                ax.plot(labels, ds["values"], marker="o", label=ds.get("label", ""))
+            if len(datasets) > 1:
+                ax.legend()
+
+        elif chart_type == "pie":
+            values = datasets[0]["values"] if datasets else []
+            ax.pie(values, labels=labels, autopct="%1.1f%%", startangle=90)
+            ax.axis("equal")
+
+        elif chart_type == "scatter":
+            for ds in datasets:
+                x_vals = ds.get("x", list(range(len(ds["values"]))))
+                ax.scatter(x_vals, ds["values"], label=ds.get("label", ""), alpha=0.7)
+            if len(datasets) > 1:
+                ax.legend()
+
+        elif chart_type == "heatmap":
+            matrix = np.array(data.get("matrix", [[]]))
+            im = ax.imshow(matrix, cmap="YlOrRd", aspect="auto")
+            fig.colorbar(im, ax=ax)
+            if "x_labels" in data:
+                ax.set_xticks(range(len(data["x_labels"])))
+                ax.set_xticklabels(data["x_labels"])
+            if "y_labels" in data:
+                ax.set_yticks(range(len(data["y_labels"])))
+                ax.set_yticklabels(data["y_labels"])
+
+        if title:
+            ax.set_title(title)
+        fig.tight_layout()
+        fig.savefig(str(path), format=format, bbox_inches="tight")
+        plt.close(fig)
+    return str(path.resolve())

licos_dev_sdk-0.3.4/src/licos_dev_sdk/presentation.py

@@ -0,0 +1,645 @@
+"""PowerPoint generation from Markdown or a structured presentation spec."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from PIL import Image
+from pptx import Presentation
+from pptx.chart.data import ChartData
+from pptx.dml.color import RGBColor
+from pptx.enum.chart import XL_CHART_TYPE, XL_LEGEND_POSITION
+from pptx.enum.shapes import MSO_AUTO_SHAPE_TYPE
+from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
+from pptx.util import Inches, Pt
+
+from ._utils import resolve_output_path
+
+
+_SLIDE_WIDTH = 13.333
+_SLIDE_HEIGHT = 7.5
+_FONT = "Microsoft YaHei"
+
+
+@dataclass(frozen=True)
+class _Theme:
+    primary: str
+    secondary: str
+    accent: str
+    background: str
+    surface: str
+    text: str
+    muted: str
+    border: str
+    positive: str
+    negative: str
+    font: str = _FONT
+
+
+_THEMES: dict[str, _Theme] = {
+    "professional-blue": _Theme(
+        primary="16324F", secondary="2F6B8A", accent="20A39E",
+        background="F5F8FA", surface="FFFFFF", text="17212B",
+        muted="657786", border="D8E1E8", positive="2E8B57", negative="C84B4B",
+    ),
+    "executive-dark": _Theme(
+        primary="17202A", secondary="34495E", accent="D5A021",
+        background="F4F5F6", surface="FFFFFF", text="17202A",
+        muted="66727D", border="D5D9DD", positive="2D936C", negative="C85555",
+    ),
+    "industrial": _Theme(
+        primary="243746", secondary="3F6678", accent="E0A11B",
+        background="F3F5F4", surface="FFFFFF", text="1E2A32",
+        muted="66737B", border="D8DEDF", positive="39845B", negative="C75050",
+    ),
+    "neutral": _Theme(
+        primary="30353B", secondary="66717C", accent="2E8B8B",
+        background="F6F6F5", surface="FFFFFF", text="24282C",
+        muted="747B82", border="DADDDD", positive="3A8555", negative="BE4C4C",
+    ),
+}
+
+
+def create_pptx(
+    content: str,
+    filename: str,
+    *,
+    content_type: str = "markdown",
+    output_dir: str | None = None,
+) -> str:
+    """Generate a styled PPTX from Markdown while preserving the legacy API.
+
+    Slides are separated by a line containing ``---``. The first heading on a
+    slide is its title; remaining lines are rendered as body text or bullets.
+    """
+    if content_type not in {"markdown", "html"}:
+        raise ValueError("content_type must be 'markdown' or 'html'")
+    if content_type == "html":
+        content = re.sub(r"<[^>]+>", "", content)
+
+    slides: list[dict[str, Any]] = []
+    for raw_slide in re.split(r"\n\s*---\s*(?:\n|$)", content.strip()):
+        lines = [line.rstrip() for line in raw_slide.splitlines() if line.strip()]
+        if not lines:
+            continue
+        title = ""
+        bullets: list[dict[str, Any]] = []
+        paragraphs: list[str] = []
+        for line in lines:
+            stripped = line.strip()
+            indent = len(line) - len(line.lstrip())
+            if not title and stripped.startswith("#"):
+                title = stripped.lstrip("#").strip()
+            elif stripped.startswith(("- ", "* ")):
+                bullets.append({"text": stripped[2:].strip(), "level": 1 if indent >= 2 else 0})
+            else:
+                paragraphs.append(stripped.lstrip("#").strip())
+        items: list[Any] = bullets or paragraphs
+        slides.append({"type": "bullets", "title": title or "演示内容", "items": items})
+
+    return create_pptx_deck(
+        {"theme": "professional-blue", "slides": slides},
+        filename,
+        output_dir=output_dir,
+    )
+
+
+def create_pptx_deck(
+    spec: dict[str, Any],
+    filename: str,
+    *,
+    output_dir: str | None = None,
+    asset_base_path: str | None = None,
+) -> str:
+    """Generate a professional PPTX from a structured JSON-compatible spec.
+
+    Supported slide types are ``title``, ``section``, ``bullets``,
+    ``two_column``, ``kpi``, ``table``, ``chart``, ``image``, ``quote``, and
+    ``closing``. Unknown slide types fail fast instead of silently degrading.
+    """
+    if not isinstance(spec, dict):
+        raise TypeError("presentation spec must be an object")
+    slides = spec.get("slides")
+    if not isinstance(slides, list) or not slides:
+        raise ValueError("presentation spec must contain a non-empty slides array")
+
+    theme = _resolve_theme(spec.get("theme", "professional-blue"))
+    path = resolve_output_path(filename, ".pptx", output_dir)
+    base_path = Path(asset_base_path).expanduser().resolve() if asset_base_path else Path.cwd()
+
+    prs = Presentation()
+    prs.slide_width = Inches(_SLIDE_WIDTH)
+    prs.slide_height = Inches(_SLIDE_HEIGHT)
+    prs.core_properties.title = str(spec.get("title", ""))
+    prs.core_properties.subject = str(spec.get("subject", ""))
+    prs.core_properties.author = str(spec.get("author", "LICOS AIOS"))
+    prs.core_properties.comments = "Generated by LICOS Dev SDK"
+
+    footer = str(spec.get("footer", "")).strip()
+    for index, slide_spec in enumerate(slides, start=1):
+        if not isinstance(slide_spec, dict):
+            raise TypeError(f"slides[{index - 1}] must be an object")
+        kind = str(slide_spec.get("type", slide_spec.get("layout", "bullets"))).lower()
+        slide = prs.slides.add_slide(prs.slide_layouts[6])
+        if kind == "title":
+            _render_title_slide(slide, slide_spec, theme)
+        elif kind == "section":
+            _render_section_slide(slide, slide_spec, theme, index)
+        elif kind == "bullets":
+            _render_bullets_slide(slide, slide_spec, theme, base_path)
+        elif kind == "two_column":
+            _render_two_column_slide(slide, slide_spec, theme)
+        elif kind == "kpi":
+            _render_kpi_slide(slide, slide_spec, theme)
+        elif kind == "table":
+            _render_table_slide(slide, slide_spec, theme)
+        elif kind == "chart":
+            _render_chart_slide(slide, slide_spec, theme)
+        elif kind == "image":
+            _render_image_slide(slide, slide_spec, theme, base_path)
+        elif kind == "quote":
+            _render_quote_slide(slide, slide_spec, theme)
+        elif kind == "closing":
+            _render_closing_slide(slide, slide_spec, theme)
+        else:
+            raise ValueError(f"unsupported slide type at slides[{index - 1}]: {kind}")
+
+        if kind not in {"title", "closing"}:
+            _add_footer(slide, footer, index, theme)
+
+    prs.save(str(path))
+    return str(path.resolve())
+
+
+def _resolve_theme(raw: Any) -> _Theme:
+    if isinstance(raw, str):
+        try:
+            return _THEMES[raw]
+        except KeyError as exc:
+            raise ValueError(f"unknown presentation theme: {raw}") from exc
+    if not isinstance(raw, dict):
+        raise TypeError("theme must be a theme name or an object")
+    name = str(raw.get("name", "professional-blue"))
+    try:
+        base = _THEMES[name]
+    except KeyError as exc:
+        raise ValueError(f"unknown presentation theme: {name}") from exc
+    colors = raw.get("colors", {})
+    if not isinstance(colors, dict):
+        raise TypeError("theme.colors must be an object")
+    values = {field: getattr(base, field) for field in base.__dataclass_fields__}
+    for key, value in colors.items():
+        if key not in values or key == "font":
+            raise ValueError(f"unsupported theme color: {key}")
+        values[key] = _normalize_hex(value)
+    if raw.get("font"):
+        values["font"] = str(raw["font"])
+    return _Theme(**values)
+
+
+def _normalize_hex(value: Any) -> str:
+    text = str(value).strip().lstrip("#").upper()
+    if not re.fullmatch(r"[0-9A-F]{6}", text):
+        raise ValueError(f"invalid RGB color: {value}")
+    return text
+
+
+def _rgb(value: str) -> RGBColor:
+    return RGBColor.from_string(value)
+
+
+def _set_background(slide: Any, color: str) -> None:
+    fill = slide.background.fill
+    fill.solid()
+    fill.fore_color.rgb = _rgb(color)
+
+
+def _add_rect(
+    slide: Any,
+    left: float,
+    top: float,
+    width: float,
+    height: float,
+    fill: str,
+    *,
+    radius: bool = False,
+    line: str | None = None,
+) -> Any:
+    shape_type = MSO_AUTO_SHAPE_TYPE.ROUNDED_RECTANGLE if radius else MSO_AUTO_SHAPE_TYPE.RECTANGLE
+    shape = slide.shapes.add_shape(shape_type, Inches(left), Inches(top), Inches(width), Inches(height))
+    shape.fill.solid()
+    shape.fill.fore_color.rgb = _rgb(fill)
+    if line:
+        shape.line.color.rgb = _rgb(line)
+    else:
+        shape.line.fill.background()
+    return shape
+
+
+def _add_text(
+    slide: Any,
+    text: Any,
+    left: float,
+    top: float,
+    width: float,
+    height: float,
+    *,
+    size: float,
+    color: str,
+    theme: _Theme,
+    bold: bool = False,
+    align: PP_ALIGN = PP_ALIGN.LEFT,
+    valign: MSO_ANCHOR = MSO_ANCHOR.TOP,
+    name: str | None = None,
+    margin: float = 0,
+) -> Any:
+    box = slide.shapes.add_textbox(Inches(left), Inches(top), Inches(width), Inches(height))
+    if name:
+        box.name = name
+    frame = box.text_frame
+    frame.clear()
+    frame.word_wrap = True
+    frame.margin_left = Inches(margin)
+    frame.margin_right = Inches(margin)
+    frame.margin_top = Inches(margin)
+    frame.margin_bottom = Inches(margin)
+    frame.vertical_anchor = valign
+    paragraph = frame.paragraphs[0]
+    paragraph.text = str(text or "")
+    paragraph.alignment = align
+    paragraph.font.name = theme.font
+    paragraph.font.size = Pt(size)
+    paragraph.font.bold = bold
+    paragraph.font.color.rgb = _rgb(color)
+    return box
+
+
+def _add_standard_header(slide: Any, spec: dict[str, Any], theme: _Theme) -> None:
+    _set_background(slide, theme.background)
+    _add_rect(slide, 0, 0, 0.13, _SLIDE_HEIGHT, theme.accent)
+    _add_text(
+        slide, spec.get("title", ""), 0.72, 0.42, 11.85, 0.62,
+        size=28, color=theme.primary, theme=theme, bold=True, name="LICOS Slide Title",
+    )
+    subtitle = str(spec.get("subtitle", "")).strip()
+    if subtitle:
+        _add_text(slide, subtitle, 0.75, 1.03, 11.7, 0.35, size=11, color=theme.muted, theme=theme)
+    _add_rect(slide, 0.74, 1.36, 11.83, 0.02, theme.border)
+
+
+def _add_footer(slide: Any, footer: str, page: int, theme: _Theme) -> None:
+    _add_rect(slide, 0.74, 7.03, 11.83, 0.01, theme.border)
+    if footer:
+        _add_text(
+            slide, footer, 0.75, 7.08, 10.5, 0.22,
+            size=8, color=theme.muted, theme=theme, name="LICOS Footer",
+        )
+    _add_text(
+        slide, f"{page:02d}", 11.85, 7.06, 0.7, 0.23,
+        size=8, color=theme.muted, theme=theme, align=PP_ALIGN.RIGHT,
+        name="LICOS Page Number",
+    )
+
+
+def _render_title_slide(slide: Any, spec: dict[str, Any], theme: _Theme) -> None:
+    _set_background(slide, theme.primary)
+    _add_rect(slide, 0, 0, _SLIDE_WIDTH, 0.12, theme.accent)
+    eyebrow = str(spec.get("eyebrow", "")).strip()
+    if eyebrow:
+        _add_text(slide, eyebrow.upper(), 0.9, 0.95, 10.8, 0.35, size=11, color=theme.accent, theme=theme, bold=True)
+    _add_text(
+        slide, spec.get("title", ""), 0.9, 1.45, 11.5, 1.65,
+        size=42, color="FFFFFF", theme=theme, bold=True, valign=MSO_ANCHOR.MIDDLE,
+        name="LICOS Slide Title",
+    )
+    subtitle = str(spec.get("subtitle", "")).strip()
+    if subtitle:
+        _add_text(slide, subtitle, 0.92, 3.35, 10.8, 0.9, size=19, color="DDE7ED", theme=theme)
+    meta = "  |  ".join(str(value) for value in (spec.get("author"), spec.get("date")) if value)
+    if meta:
+        _add_text(slide, meta, 0.92, 6.52, 10.8, 0.3, size=10, color="B9C8D2", theme=theme)
+
+
+def _render_section_slide(slide: Any, spec: dict[str, Any], theme: _Theme, index: int) -> None:
+    _set_background(slide, theme.background)
+    _add_rect(slide, 0, 0, 3.0, _SLIDE_HEIGHT, theme.primary)
+    _add_text(slide, f"{index:02d}", 0.65, 2.25, 1.75, 1.0, size=42, color=theme.accent, theme=theme, bold=True)
+    _add_text(
+        slide, spec.get("title", ""), 3.65, 2.15, 8.6, 1.25,
+        size=36, color=theme.primary, theme=theme, bold=True,
+        valign=MSO_ANCHOR.MIDDLE, name="LICOS Slide Title",
+    )
+    subtitle = str(spec.get("subtitle", "")).strip()
+    if subtitle:
+        _add_text(slide, subtitle, 3.68, 3.55, 8.3, 0.8, size=16, color=theme.muted, theme=theme)
+
+
+def _render_bullets_slide(slide: Any, spec: dict[str, Any], theme: _Theme, base_path: Path) -> None:
+    _add_standard_header(slide, spec, theme)
+    image_path = spec.get("image")
+    body_width = 7.0 if image_path else 11.45
+    items = spec.get("items", spec.get("bullets", []))
+    if not isinstance(items, list):
+        raise TypeError("bullets slide items must be an array")
+    _add_bullet_list(slide, items, 0.78, 1.65, body_width, 4.95, theme)
+    if image_path:
+        image = _resolve_asset(image_path, base_path)
+        _add_picture(slide, image, 8.2, 1.72, 4.35, 4.68, str(spec.get("image_fit", "contain")))
+        caption = str(spec.get("caption", "")).strip()
+        if caption:
+            _add_text(slide, caption, 8.25, 6.47, 4.2, 0.3, size=9, color=theme.muted, theme=theme, align=PP_ALIGN.CENTER)
+    _add_summary(slide, spec.get("summary"), theme)
+
+
+def _add_bullet_list(
+    slide: Any,
+    items: list[Any],
+    left: float,
+    top: float,
+    width: float,
+    height: float,
+    theme: _Theme,
+) -> None:
+    box = slide.shapes.add_textbox(Inches(left), Inches(top), Inches(width), Inches(height))
+    frame = box.text_frame
+    frame.clear()
+    frame.word_wrap = True
+    frame.margin_left = Inches(0.08)
+    frame.margin_right = Inches(0.08)
+    for index, raw in enumerate(items):
+        if isinstance(raw, dict):
+            text = str(raw.get("text", ""))
+            level = int(raw.get("level", 0))
+            emphasis = bool(raw.get("emphasis", False))
+        else:
+            text, level, emphasis = str(raw), 0, False
+        paragraph = frame.paragraphs[0] if index == 0 else frame.add_paragraph()
+        paragraph.text = f"{'◦' if level else '•'} {text}"
+        paragraph.level = min(max(level, 0), 2)
+        paragraph.font.name = theme.font
+        paragraph.font.size = Pt(17 if level == 0 else 14)
+        paragraph.font.bold = emphasis
+        paragraph.font.color.rgb = _rgb(theme.primary if emphasis else theme.text)
+        paragraph.space_after = Pt(10 if level == 0 else 6)
+        paragraph.line_spacing = 1.12
+
+
+def _render_two_column_slide(slide: Any, spec: dict[str, Any], theme: _Theme) -> None:
+    _add_standard_header(slide, spec, theme)
+    columns = [spec.get("left", {}), spec.get("right", {})]
+    for index, column in enumerate(columns):
+        if not isinstance(column, dict):
+            raise TypeError("two_column left and right must be objects")
+        left = 0.75 + index * 6.05
+        _add_rect(slide, left, 1.65, 5.72, 4.95, theme.surface, radius=True, line=theme.border)
+        _add_rect(slide, left, 1.65, 0.08, 4.95, theme.accent if index == 0 else theme.secondary)
+        _add_text(slide, column.get("title", ""), left + 0.35, 1.93, 5.05, 0.5, size=19, color=theme.primary, theme=theme, bold=True)
+        items = column.get("items", [])
+        if not isinstance(items, list):
+            raise TypeError("two_column items must be arrays")
+        _add_bullet_list(slide, items, left + 0.3, 2.55, 5.05, 3.65, theme)
+
+
+def _render_kpi_slide(slide: Any, spec: dict[str, Any], theme: _Theme) -> None:
+    _add_standard_header(slide, spec, theme)
+    items = spec.get("items", [])
+    if not isinstance(items, list) or not items:
+        raise ValueError("kpi slide requires a non-empty items array")
+    if len(items) > 8:
+        raise ValueError("kpi slide supports at most 8 items")
+    columns = min(len(items), 4)
+    rows = 1 if len(items) <= 4 else 2
+    gap = 0.22
+    card_width = (11.8 - gap * (columns - 1)) / columns
+    card_height = 4.55 if rows == 1 else 2.15
+    for index, raw in enumerate(items):
+        if not isinstance(raw, dict):
+            raise TypeError("kpi items must be objects")
+        row, col = divmod(index, columns)
+        left = 0.75 + col * (card_width + gap)
+        top = 1.68 + row * (card_height + 0.25)
+        _add_rect(slide, left, top, card_width, card_height, theme.surface, radius=True, line=theme.border)
+        _add_rect(slide, left, top, card_width, 0.08, theme.accent if index % 2 == 0 else theme.secondary)
+        value_size = 32 if rows == 1 else 26
+        _add_text(slide, raw.get("value", ""), left + 0.25, top + 0.45, card_width - 0.5, 0.75, size=value_size, color=theme.primary, theme=theme, bold=True)
+        _add_text(slide, raw.get("label", ""), left + 0.25, top + 1.28, card_width - 0.5, 0.45, size=13, color=theme.text, theme=theme, bold=True)
+        change = str(raw.get("change", "")).strip()
+        if change:
+            change_color = theme.negative if change.startswith("-") else theme.positive
+            _add_text(slide, change, left + 0.25, top + 1.82, card_width - 0.5, 0.32, size=11, color=change_color, theme=theme, bold=True)
+        note = str(raw.get("note", "")).strip()
+        if note:
+            _add_text(slide, note, left + 0.25, top + card_height - 0.75, card_width - 0.5, 0.48, size=9, color=theme.muted, theme=theme)
+
+
+def _render_table_slide(slide: Any, spec: dict[str, Any], theme: _Theme) -> None:
+    _add_standard_header(slide, spec, theme)
+    columns = spec.get("columns", [])
+    rows = spec.get("rows", [])
+    if not isinstance(columns, list) or not columns:
+        raise ValueError("table slide requires a non-empty columns array")
+    if not isinstance(rows, list):
+        raise TypeError("table slide rows must be an array")
+    if len(columns) > 10 or len(rows) > 16:
+        raise ValueError("table slide supports at most 10 columns and 16 data rows")
+    table_height = 4.92 if not spec.get("note") else 4.4
+    table = slide.shapes.add_table(
+        len(rows) + 1, len(columns), Inches(0.75), Inches(1.65), Inches(11.8), Inches(table_height)
+    ).table
+    widths = spec.get("column_widths")
+    if widths is not None:
+        if not isinstance(widths, list) or len(widths) != len(columns):
+            raise ValueError("column_widths length must match columns")
+        total = sum(float(value) for value in widths)
+        for index, value in enumerate(widths):
+            table.columns[index].width = Inches(11.8 * float(value) / total)
+
+    for col, value in enumerate(columns):
+        _style_table_cell(table.cell(0, col), value, theme.primary, "FFFFFF", theme, True)
+    for row_index, row in enumerate(rows, start=1):
+        values = row if isinstance(row, list) else [row.get(str(column), row.get(column, "")) for column in columns] if isinstance(row, dict) else [row]
+        if len(values) != len(columns):
+            raise ValueError(f"table row {row_index} length does not match columns")
+        fill = theme.surface if row_index % 2 else theme.background
+        for col, value in enumerate(values):
+            _style_table_cell(table.cell(row_index, col), value, fill, theme.text, theme, False)
+    if spec.get("note"):
+        _add_text(slide, spec["note"], 0.8, 6.22, 11.55, 0.45, size=9, color=theme.muted, theme=theme)
+
+
+def _style_table_cell(cell: Any, value: Any, fill: str, color: str, theme: _Theme, bold: bool) -> None:
+    cell.fill.solid()
+    cell.fill.fore_color.rgb = _rgb(fill)
+    cell.margin_left = Inches(0.08)
+    cell.margin_right = Inches(0.08)
+    cell.margin_top = Inches(0.04)
+    cell.margin_bottom = Inches(0.04)
+    frame = cell.text_frame
+    frame.clear()
+    frame.word_wrap = True
+    frame.vertical_anchor = MSO_ANCHOR.MIDDLE
+    paragraph = frame.paragraphs[0]
+    paragraph.text = str(value if value is not None else "")
+    paragraph.font.name = theme.font
+    paragraph.font.size = Pt(10)
+    paragraph.font.bold = bold
+    paragraph.font.color.rgb = _rgb(color)
+    paragraph.alignment = PP_ALIGN.CENTER
+
+
+def _render_chart_slide(slide: Any, spec: dict[str, Any], theme: _Theme) -> None:
+    _add_standard_header(slide, spec, theme)
+    categories = spec.get("categories", [])
+    series = spec.get("series", [])
+    if not isinstance(categories, list) or not categories:
+        raise ValueError("chart slide requires a non-empty categories array")
+    if not isinstance(series, list) or not series:
+        raise ValueError("chart slide requires a non-empty series array")
+    data = ChartData()
+    data.categories = [str(value) for value in categories]
+    for index, item in enumerate(series):
+        if not isinstance(item, dict) or not isinstance(item.get("values"), list):
+            raise TypeError("chart series items require name and values")
+        if len(item["values"]) != len(categories):
+            raise ValueError(f"chart series {index} value count must match categories")
+        data.add_series(str(item.get("name", f"系列 {index + 1}")), item["values"])
+
+    chart_type_name = str(spec.get("chart_type", "column")).lower()
+    chart_types = {
+        "column": XL_CHART_TYPE.COLUMN_CLUSTERED,
+        "bar": XL_CHART_TYPE.BAR_CLUSTERED,
+        "line": XL_CHART_TYPE.LINE_MARKERS,
+        "pie": XL_CHART_TYPE.PIE,
+        "doughnut": XL_CHART_TYPE.DOUGHNUT,
+        "area": XL_CHART_TYPE.AREA,
+    }
+    if chart_type_name not in chart_types:
+        raise ValueError(f"unsupported chart_type: {chart_type_name}")
+    chart_width = 8.55 if spec.get("insight") else 11.75
+    chart = slide.shapes.add_chart(
+        chart_types[chart_type_name], Inches(0.75), Inches(1.65), Inches(chart_width), Inches(4.95), data
+    ).chart
+    chart.has_title = False
+    chart.has_legend = len(series) > 1 or chart_type_name in {"pie", "doughnut"}
+    if chart.has_legend:
+        chart.legend.position = XL_LEGEND_POSITION.BOTTOM
+        chart.legend.include_in_layout = False
+        chart.legend.font.name = theme.font
+        chart.legend.font.size = Pt(9)
+    palette = [theme.accent, theme.secondary, "D5A021", "7A6FA8", theme.positive, theme.negative]
+    for index, chart_series in enumerate(chart.series):
+        color = _rgb(palette[index % len(palette)])
+        if chart_type_name == "line":
+            chart_series.format.line.color.rgb = color
+            chart_series.format.line.width = Pt(2.25)
+        else:
+            chart_series.format.fill.solid()
+            chart_series.format.fill.fore_color.rgb = color
+    if chart_type_name not in {"pie", "doughnut"}:
+        chart.value_axis.has_major_gridlines = True
+        chart.value_axis.major_gridlines.format.line.color.rgb = _rgb(theme.border)
+        chart.value_axis.tick_labels.font.name = theme.font
+        chart.value_axis.tick_labels.font.size = Pt(9)
+        chart.category_axis.tick_labels.font.name = theme.font
+        chart.category_axis.tick_labels.font.size = Pt(9)
+    insight = str(spec.get("insight", "")).strip()
+    if insight:
+        _add_rect(slide, 9.58, 1.65, 2.97, 4.95, theme.surface, radius=True, line=theme.border)
+        _add_text(slide, "关键洞察", 9.88, 1.95, 2.35, 0.45, size=16, color=theme.primary, theme=theme, bold=True)
+        _add_text(slide, insight, 9.88, 2.55, 2.35, 3.55, size=12, color=theme.text, theme=theme)
+
+
+def _render_image_slide(slide: Any, spec: dict[str, Any], theme: _Theme, base_path: Path) -> None:
+    _add_standard_header(slide, spec, theme)
+    if not spec.get("image"):
+        raise ValueError("image slide requires image")
+    image = _resolve_asset(spec["image"], base_path)
+    caption = str(spec.get("caption", "")).strip()
+    height = 4.65 if caption else 5.05
+    _add_picture(slide, image, 0.75, 1.62, 11.8, height, str(spec.get("fit", "contain")))
+    if caption:
+        _add_text(slide, caption, 0.9, 6.42, 11.5, 0.35, size=10, color=theme.muted, theme=theme, align=PP_ALIGN.CENTER)
+
+
+def _resolve_asset(value: Any, base_path: Path) -> Path:
+    raw = str(value).strip()
+    if raw.startswith(("http://", "https://")):
+        raise ValueError("remote image URLs are not supported; download the image and use a local path")
+    path = Path(raw).expanduser()
+    if not path.is_absolute():
+        path = base_path / path
+    path = path.resolve()
+    if not path.is_file():
+        raise FileNotFoundError(f"presentation image not found: {path}")
+    return path
+
+
+def _add_picture(slide: Any, path: Path, left: float, top: float, width: float, height: float, fit: str) -> Any:
+    fit = fit.lower()
+    if fit not in {"contain", "cover"}:
+        raise ValueError("image fit must be 'contain' or 'cover'")
+    with Image.open(path) as image:
+        image_width, image_height = image.size
+    image_ratio = image_width / image_height
+    box_ratio = width / height
+    if fit == "contain":
+        if image_ratio > box_ratio:
+            rendered_width, rendered_height = width, width / image_ratio
+        else:
+            rendered_width, rendered_height = height * image_ratio, height
+        rendered_left = left + (width - rendered_width) / 2
+        rendered_top = top + (height - rendered_height) / 2
+        return slide.shapes.add_picture(
+            str(path), Inches(rendered_left), Inches(rendered_top), Inches(rendered_width), Inches(rendered_height)
+        )
+    picture = slide.shapes.add_picture(str(path), Inches(left), Inches(top), Inches(width), Inches(height))
+    if image_ratio > box_ratio:
+        crop = (1 - box_ratio / image_ratio) / 2
+        picture.crop_left = crop
+        picture.crop_right = crop
+    else:
+        crop = (1 - image_ratio / box_ratio) / 2
+        picture.crop_top = crop
+        picture.crop_bottom = crop
+    return picture
+
+
+def _render_quote_slide(slide: Any, spec: dict[str, Any], theme: _Theme) -> None:
+    _set_background(slide, theme.background)
+    _add_rect(slide, 0, 0, 0.14, _SLIDE_HEIGHT, theme.accent)
+    _add_text(slide, "“", 0.8, 0.72, 1.0, 1.0, size=58, color=theme.accent, theme=theme, bold=True)
+    _add_text(
+        slide, spec.get("quote", spec.get("title", "")), 1.4, 1.45, 10.7, 2.9,
+        size=29, color=theme.primary, theme=theme, bold=True, valign=MSO_ANCHOR.MIDDLE,
+        name="LICOS Slide Title",
+    )
+    attribution = str(spec.get("attribution", "")).strip()
+    if attribution:
+        _add_text(slide, f"— {attribution}", 1.45, 4.85, 9.8, 0.45, size=13, color=theme.muted, theme=theme)
+
+
+def _render_closing_slide(slide: Any, spec: dict[str, Any], theme: _Theme) -> None:
+    _set_background(slide, theme.primary)
+    _add_rect(slide, 0, 7.38, _SLIDE_WIDTH, 0.12, theme.accent)
+    _add_text(
+        slide, spec.get("title", "谢谢"), 1.0, 2.05, 11.3, 1.2,
+        size=42, color="FFFFFF", theme=theme, bold=True,
+        align=PP_ALIGN.CENTER, valign=MSO_ANCHOR.MIDDLE, name="LICOS Slide Title",
+    )
+    subtitle = str(spec.get("subtitle", "")).strip()
+    if subtitle:
+        _add_text(slide, subtitle, 1.2, 3.55, 10.9, 0.65, size=17, color="DDE7ED", theme=theme, align=PP_ALIGN.CENTER)
+    contact = str(spec.get("contact", "")).strip()
+    if contact:
+        _add_text(slide, contact, 1.2, 5.85, 10.9, 0.35, size=10, color="B9C8D2", theme=theme, align=PP_ALIGN.CENTER)
+
+
+def _add_summary(slide: Any, value: Any, theme: _Theme) -> None:
+    text = str(value or "").strip()
+    if not text:
+        return
+    _add_rect(slide, 0.78, 6.25, 11.7, 0.48, theme.surface, radius=True, line=theme.border)
+    _add_text(slide, text, 1.0, 6.34, 11.2, 0.27, size=10, color=theme.primary, theme=theme, bold=True)

licos_dev_sdk-0.3.4/src/licos_dev_sdk/presentation_inspect.py

@@ -0,0 +1,107 @@
+"""Structural and visual-density checks for generated PPTX files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pptx import Presentation
+
+
+def inspect_pptx(
+    path: str | Path,
+    *,
+    min_slides: int | None = None,
+    max_slides: int | None = None,
+) -> dict[str, Any]:
+    """Inspect a PPTX and return a machine-readable quality report."""
+    presentation_path = Path(path).expanduser().resolve()
+    if not presentation_path.is_file():
+        raise FileNotFoundError(f"PPTX file not found: {presentation_path}")
+    if min_slides is not None and min_slides < 1:
+        raise ValueError("min_slides must be at least 1")
+    if max_slides is not None and max_slides < 1:
+        raise ValueError("max_slides must be at least 1")
+    if min_slides is not None and max_slides is not None and min_slides > max_slides:
+        raise ValueError("min_slides cannot exceed max_slides")
+
+    deck = Presentation(str(presentation_path))
+    slides: list[dict[str, Any]] = []
+    blank_slides: list[int] = []
+    titleless_slides: list[int] = []
+    crowded_slides: list[int] = []
+    totals = {"text_characters": 0, "pictures": 0, "tables": 0, "charts": 0, "shapes": 0}
+
+    for index, slide in enumerate(deck.slides, start=1):
+        texts: list[str] = []
+        title = ""
+        has_named_title = False
+        pictures = tables = charts = 0
+        for shape in slide.shapes:
+            if getattr(shape, "has_text_frame", False):
+                text = shape.text.strip()
+                if shape.name == "LICOS Slide Title":
+                    has_named_title = True
+                    title = text
+                if text and shape.name not in {"LICOS Footer", "LICOS Page Number"}:
+                    texts.append(text)
+            if getattr(shape, "has_table", False):
+                tables += 1
+            if getattr(shape, "has_chart", False):
+                charts += 1
+            if getattr(shape, "shape_type", None) == 13:
+                pictures += 1
+        if not has_named_title and texts:
+            title = texts[0].splitlines()[0]
+        character_count = sum(len(text) for text in texts)
+        shape_count = len(slide.shapes)
+        if character_count == 0 and pictures == 0 and tables == 0 and charts == 0:
+            blank_slides.append(index)
+        if not title:
+            titleless_slides.append(index)
+        if character_count > 1200 or shape_count > 24:
+            crowded_slides.append(index)
+
+        slide_report = {
+            "number": index,
+            "title": title,
+            "text_characters": character_count,
+            "shape_count": shape_count,
+            "picture_count": pictures,
+            "table_count": tables,
+            "chart_count": charts,
+        }
+        slides.append(slide_report)
+        totals["text_characters"] += character_count
+        totals["pictures"] += pictures
+        totals["tables"] += tables
+        totals["charts"] += charts
+        totals["shapes"] += shape_count
+
+    slide_count = len(slides)
+    issues: list[str] = []
+    if slide_count == 0:
+        issues.append("presentation contains no slides")
+    if min_slides is not None and slide_count < min_slides:
+        issues.append(f"slide count {slide_count} is below minimum {min_slides}")
+    if max_slides is not None and slide_count > max_slides:
+        issues.append(f"slide count {slide_count} exceeds maximum {max_slides}")
+    if blank_slides:
+        issues.append(f"blank slides: {blank_slides}")
+    if titleless_slides:
+        issues.append(f"slides without detectable titles: {titleless_slides}")
+    if crowded_slides:
+        issues.append(f"potentially crowded slides: {crowded_slides}")
+
+    return {
+        "path": str(presentation_path),
+        "size_bytes": presentation_path.stat().st_size,
+        "slide_count": slide_count,
+        "quality_passed": not issues,
+        "quality_issues": issues,
+        "blank_slides": blank_slides,
+        "titleless_slides": titleless_slides,
+        "crowded_slides": crowded_slides,
+        "totals": totals,
+        "slides": slides,
+    }

{licos_dev_sdk-0.3.2 → licos_dev_sdk-0.3.4}/tests/test_document_spreadsheet.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import sys
 import tempfile
 import unittest
+import warnings
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
@@ -11,10 +12,36 @@ from docx import Document
 from openpyxl import load_workbook
 from PIL import Image
 
-from licos_dev_sdk import create_docx, create_docx_from_template, create_xlsx_workbook
+from licos_dev_sdk import create_chart, create_docx, create_docx_from_template, create_xlsx_workbook
 
 
 class DocumentSpreadsheetTests(unittest.TestCase):
+    def test_create_chart_renders_chinese_text_without_missing_glyphs(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp, warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always")
+            output = create_chart(
+                "bar",
+                {
+                    "labels": ["华东地区", "华中地区", "华南地区"],
+                    "datasets": [
+                        {"label": "预计收入（万元）", "values": [4800, 3200, 2600]},
+                        {"label": "项目ROI（%）", "values": [18, 23, 16]},
+                    ],
+                },
+                "chinese-chart",
+                output_dir=tmp,
+                title="重点行业客户投资回报分析",
+            )
+
+            self.assertTrue(Path(output).is_file())
+            self.assertGreater(Path(output).stat().st_size, 10_000)
+            missing_glyph_warnings = [
+                str(item.message)
+                for item in caught
+                if "Glyph" in str(item.message) and "missing from font" in str(item.message)
+            ]
+            self.assertEqual(missing_glyph_warnings, [])
+
     def test_create_docx_resolves_assets_from_explicit_base_path(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             tmp_path = Path(tmp)

licos_dev_sdk-0.3.4/tests/test_presentation.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from PIL import Image
+from pptx import Presentation
+
+from licos_dev_sdk import create_pptx, create_pptx_deck, inspect_pptx
+
+
+class PresentationTests(unittest.TestCase):
+    def test_create_structured_deck_with_editable_visuals(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            Image.new("RGB", (640, 360), "#20A39E").save(root / "factory.png")
+            output = create_pptx_deck(
+                {
+                    "title": "智能制造经营分析",
+                    "author": "经营管理部",
+                    "footer": "内部资料",
+                    "theme": "industrial",
+                    "slides": [
+                        {
+                            "type": "title",
+                            "eyebrow": "MANAGEMENT REVIEW",
+                            "title": "智能制造经营分析",
+                            "subtitle": "经营质量、交付效率与行动计划",
+                            "date": "2026-08",
+                        },
+                        {
+                            "type": "bullets",
+                            "title": "经营摘要",
+                            "items": [
+                                {"text": "核心业务保持增长", "emphasis": True},
+                                "重点客户交付周期持续缩短",
+                                "供应链波动仍需关注",
+                            ],
+                            "image": "factory.png",
+                            "caption": "智能工厂示意",
+                            "summary": "下一阶段重点是规模化复制标准方案。",
+                        },
+                        {
+                            "type": "kpi",
+                            "title": "核心经营指标",
+                            "items": [
+                                {"label": "营业收入", "value": "8.6 亿元", "change": "+18.2%"},
+                                {"label": "毛利率", "value": "36.4%", "change": "+2.1pct"},
+                                {"label": "准时交付率", "value": "94.8%", "change": "+5.3pct"},
+                            ],
+                        },
+                        {
+                            "type": "chart",
+                            "title": "季度收入趋势",
+                            "chart_type": "column",
+                            "categories": ["Q1", "Q2", "Q3", "Q4"],
+                            "series": [
+                                {"name": "收入", "values": [1.6, 1.9, 2.2, 2.9]},
+                                {"name": "目标", "values": [1.5, 1.8, 2.1, 2.6]},
+                            ],
+                            "insight": "实际收入连续四个季度高于目标，Q4 增长最明显。",
+                        },
+                        {
+                            "type": "table",
+                            "title": "重点行动计划",
+                            "columns": ["行动", "负责人", "时间", "目标"],
+                            "rows": [
+                                ["优化重点客户交付", "交付中心", "Q3", "周期缩短 15%"],
+                                ["提升标准模块复用", "产品中心", "Q4", "复用率达到 70%"],
+                            ],
+                        },
+                        {"type": "closing", "title": "聚焦执行，持续增长", "subtitle": "谢谢"},
+                    ],
+                },
+                "management-review",
+                output_dir=str(root),
+                asset_base_path=str(root),
+            )
+
+            deck = Presentation(output)
+            self.assertEqual(len(deck.slides), 6)
+            report = inspect_pptx(output, min_slides=6, max_slides=8)
+            self.assertTrue(report["quality_passed"], report["quality_issues"])
+            self.assertGreaterEqual(report["totals"]["pictures"], 1)
+            self.assertEqual(report["totals"]["charts"], 1)
+            self.assertEqual(report["totals"]["tables"], 1)
+
+    def test_markdown_api_remains_supported(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            output = create_pptx(
+                "# 项目概览\n- 目标明确\n- 进展正常\n---\n# 下一步\n- 完成验收",
+                "legacy-deck",
+                output_dir=tmp,
+            )
+            report = inspect_pptx(output, min_slides=2, max_slides=2)
+            self.assertTrue(report["quality_passed"], report["quality_issues"])
+
+    def test_unknown_slide_type_fails_fast(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            with self.assertRaisesRegex(ValueError, "unsupported slide type"):
+                create_pptx_deck(
+                    {"slides": [{"type": "unknown", "title": "无效页面"}]},
+                    "invalid-deck",
+                    output_dir=tmp,
+                )
+
+    def test_inspector_reports_slide_count_violation(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            output = create_pptx("# 唯一页面\n内容", "one-slide", output_dir=tmp)
+            report = inspect_pptx(output, min_slides=2)
+            self.assertFalse(report["quality_passed"])
+            self.assertIn("below minimum", report["quality_issues"][0])
+
+    def test_inspector_ignores_footer_when_detecting_blank_slide(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            output = create_pptx_deck(
+                {"footer": "内部资料", "slides": [{"type": "bullets", "title": "", "items": []}]},
+                "blank-slide",
+                output_dir=tmp,
+            )
+            report = inspect_pptx(output)
+            self.assertEqual(report["blank_slides"], [1])
+            self.assertEqual(report["titleless_slides"], [1])
+            self.assertFalse(report["quality_passed"])
+
+
+if __name__ == "__main__":
+    unittest.main()

licos_dev_sdk-0.3.2/src/licos_dev_sdk/chart.py

@@ -1,80 +0,0 @@
-"""Chart generation — bar, line, pie, scatter, heatmap via matplotlib."""
-
-from __future__ import annotations
-
-import matplotlib
-matplotlib.use("Agg")  # Non-interactive backend
-import matplotlib.pyplot as plt
-import numpy as np
-
-from ._utils import resolve_output_path
-
-
-def create_chart(chart_type: str, data: dict, filename: str, *,
-                 output_dir: str | None = None, format: str = "png",
-                 title: str = "", width: int = 800, height: int = 600) -> str:
-    """Generate a chart image (PNG/SVG). Returns absolute path.
-
-    Args:
-        chart_type: "bar" | "line" | "pie" | "scatter" | "heatmap"
-        data: {
-            "labels": ["A", "B", "C"],
-            "datasets": [{"label": "Series 1", "values": [10, 20, 30]}]
-        }
-        For pie: only first dataset is used.
-        For heatmap: data["matrix"] = [[1,2],[3,4]], data["x_labels"], data["y_labels"]
-    """
-    path = resolve_output_path(filename, f".{format}", output_dir)
-    dpi = 100
-    fig, ax = plt.subplots(figsize=(width / dpi, height / dpi), dpi=dpi)
-
-    labels = data.get("labels", [])
-    datasets = data.get("datasets", [])
-
-    if chart_type == "bar":
-        x = np.arange(len(labels))
-        n = len(datasets)
-        bar_width = 0.8 / max(n, 1)
-        for i, ds in enumerate(datasets):
-            offset = (i - n / 2 + 0.5) * bar_width
-            ax.bar(x + offset, ds["values"], bar_width, label=ds.get("label", ""))
-        ax.set_xticks(x)
-        ax.set_xticklabels(labels)
-        if n > 1:
-            ax.legend()
-
-    elif chart_type == "line":
-        for ds in datasets:
-            ax.plot(labels, ds["values"], marker="o", label=ds.get("label", ""))
-        if len(datasets) > 1:
-            ax.legend()
-
-    elif chart_type == "pie":
-        values = datasets[0]["values"] if datasets else []
-        ax.pie(values, labels=labels, autopct="%1.1f%%", startangle=90)
-        ax.axis("equal")
-
-    elif chart_type == "scatter":
-        for ds in datasets:
-            x_vals = ds.get("x", list(range(len(ds["values"]))))
-            ax.scatter(x_vals, ds["values"], label=ds.get("label", ""), alpha=0.7)
-        if len(datasets) > 1:
-            ax.legend()
-
-    elif chart_type == "heatmap":
-        matrix = np.array(data.get("matrix", [[]]))
-        im = ax.imshow(matrix, cmap="YlOrRd", aspect="auto")
-        fig.colorbar(im, ax=ax)
-        if "x_labels" in data:
-            ax.set_xticks(range(len(data["x_labels"])))
-            ax.set_xticklabels(data["x_labels"])
-        if "y_labels" in data:
-            ax.set_yticks(range(len(data["y_labels"])))
-            ax.set_yticklabels(data["y_labels"])
-
-    if title:
-        ax.set_title(title)
-    fig.tight_layout()
-    fig.savefig(str(path), format=format, bbox_inches="tight")
-    plt.close(fig)
-    return str(path.resolve())

licos_dev_sdk-0.3.2/src/licos_dev_sdk/presentation.py

@@ -1,103 +0,0 @@
-"""Presentation generation — PPTX from Markdown."""
-
-from __future__ import annotations
-
-from pptx import Presentation
-from pptx.util import Inches, Pt, Emu
-from pptx.dml.color import RGBColor
-from pptx.enum.text import PP_ALIGN
-
-from ._utils import resolve_output_path
-
-
-def create_pptx(content: str, filename: str, *, content_type: str = "markdown",
-                output_dir: str | None = None) -> str:
-    """Generate a PPTX file from Markdown. Returns absolute path.
-
-    Slides are separated by `---` in Markdown.
-    First `#` heading becomes the slide title; remaining content becomes bullet points.
-    """
-    path = resolve_output_path(filename, ".pptx", output_dir)
-    prs = Presentation()
-    prs.slide_width = Inches(13.333)
-    prs.slide_height = Inches(7.5)
-
-    if content_type == "html":
-        # Strip tags for simple conversion
-        import re
-        content = re.sub(r"<[^>]+>", "", content)
-
-    slides_text = content.split("\n---\n") if "\n---\n" in content else content.split("\n---")
-
-    for slide_md in slides_text:
-        lines = [l for l in slide_md.strip().split("\n") if l.strip()]
-        if not lines:
-            continue
-
-        slide = prs.slides.add_slide(prs.slide_layouts[6])  # Blank layout
-
-        # Extract title (first # heading)
-        title_text = ""
-        body_lines = []
-        for line in lines:
-            stripped = line.strip()
-            if not title_text and stripped.startswith("#"):
-                title_text = stripped.lstrip("#").strip()
-            else:
-                body_lines.append(stripped)
-
-        # Add title
-        if title_text:
-            left = Inches(0.8)
-            top = Inches(0.5)
-            width = Inches(11.7)
-            height = Inches(1.2)
-            txBox = slide.shapes.add_textbox(left, top, width, height)
-            tf = txBox.text_frame
-            tf.word_wrap = True
-            p = tf.paragraphs[0]
-            p.text = title_text
-            p.font.size = Pt(36)
-            p.font.bold = True
-            p.font.color.rgb = RGBColor(0x1C, 0x28, 0x33)
-
-        # Add body content
-        if body_lines:
-            left = Inches(0.8)
-            top = Inches(2.0)
-            width = Inches(11.7)
-            height = Inches(4.5)
-            txBox = slide.shapes.add_textbox(left, top, width, height)
-            tf = txBox.text_frame
-            tf.word_wrap = True
-
-            for i, line in enumerate(body_lines):
-                if i == 0:
-                    p = tf.paragraphs[0]
-                else:
-                    p = tf.add_paragraph()
-
-                # Bullet points
-                if line.startswith("- ") or line.startswith("* "):
-                    p.text = line[2:]
-                    p.level = 0
-                    p.space_before = Pt(6)
-                elif line.startswith("  - ") or line.startswith("  * "):
-                    p.text = line[4:]
-                    p.level = 1
-                    p.space_before = Pt(4)
-                # Sub-headings
-                elif line.startswith("##"):
-                    p.text = line.lstrip("#").strip()
-                    p.font.size = Pt(24)
-                    p.font.bold = True
-                    p.space_before = Pt(12)
-                    continue
-                else:
-                    p.text = line
-
-                p.font.size = Pt(18)
-                p.font.color.rgb = RGBColor(0x33, 0x33, 0x33)
-
-    prs.save(str(path))
-    return str(path.resolve())