licos-dev-sdk 0.2.7__tar.gz → 0.2.8__tar.gz

{licos_dev_sdk-0.2.7 → licos_dev_sdk-0.2.8}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.2.7
+Version: 0.2.8
 Summary: LICOS Dev SDK - file generation and model capability clients
 Requires-Python: >=3.10
+Requires-Dist: docxtpl>=0.16
 Requires-Dist: graphviz>=0.20
 Requires-Dist: jinja2>=3.1
 Requires-Dist: licos-platform-sdk>=0.2.8
@@ -16,3 +17,4 @@ Requires-Dist: python-pptx>=1.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: qrcode[pil]>=8.0
 Requires-Dist: weasyprint>=62.0
+Requires-Dist: xlsxwriter>=3.2

{licos_dev_sdk-0.2.7 → licos_dev_sdk-0.2.8}/pyproject.toml

@@ -4,14 +4,16 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.2.7"
+version = "0.2.8"
 description = "LICOS Dev SDK - file generation and model capability clients"
 requires-python = ">=3.10"
 dependencies = [
     "licos-platform-sdk>=0.2.8",
     "weasyprint>=62.0",
-    "python-docx>=1.1",
-    "openpyxl>=3.1",
+    "python-docx>=1.1",
+    "docxtpl>=0.16",
+    "openpyxl>=3.1",
+    "xlsxwriter>=3.2",
     "python-pptx>=1.0",
     "matplotlib>=3.9",
     "graphviz>=0.20",

{licos_dev_sdk-0.2.7 → licos_dev_sdk-0.2.8}/src/licos_dev_sdk/__init__.py

@@ -23,12 +23,14 @@ def __getattr__(name: str):
         "create_html": ("web", "create_html"),
         "create_markdown": ("web", "create_markdown"),
         "markdown_to_html": ("web", "markdown_to_html"),
-        # document
-        "create_pdf": ("document", "create_pdf"),
-        "create_docx": ("document", "create_docx"),
-        # spreadsheet
-        "create_xlsx": ("spreadsheet", "create_xlsx"),
-        "create_csv": ("spreadsheet", "create_csv"),
+        # document
+        "create_pdf": ("document", "create_pdf"),
+        "create_docx": ("document", "create_docx"),
+        "create_docx_from_template": ("document", "create_docx_from_template"),
+        # spreadsheet
+        "create_xlsx": ("spreadsheet", "create_xlsx"),
+        "create_xlsx_workbook": ("spreadsheet", "create_xlsx_workbook"),
+        "create_csv": ("spreadsheet", "create_csv"),
         # chart
         "create_chart": ("chart", "create_chart"),
         # diagram
@@ -85,9 +87,9 @@ __all__ = [
     "create_json", "create_xml", "create_yaml",
     "create_zip", "create_tar_gz",
     "create_qrcode", "create_barcode", "create_watermark",
-    "create_html", "create_markdown", "markdown_to_html",
-    "create_pdf", "create_docx",
-    "create_xlsx", "create_csv",
+    "create_html", "create_markdown", "markdown_to_html",
+    "create_pdf", "create_docx", "create_docx_from_template",
+    "create_xlsx", "create_xlsx_workbook", "create_csv",
     "create_chart",
     "create_diagram",
     "create_pptx",

{licos_dev_sdk-0.2.7 → licos_dev_sdk-0.2.8}/src/licos_dev_sdk/document.py

@@ -2,11 +2,10 @@
 
 from __future__ import annotations
 
-import mistune
-from weasyprint import HTML
+from typing import Any
+
 from docx import Document
 from docx.shared import Pt, Inches
-from docx.enum.text import WD_ALIGN_PARAGRAPH
 
 from ._utils import resolve_output_path
 
@@ -29,6 +28,9 @@ blockquote { border-left: 3px solid #ccc; margin-left: 0; padding-left: 1em; col
 def create_pdf(content: str, filename: str, *, content_type: str = "markdown",
                output_dir: str | None = None, page_size: str = "A4") -> str:
     """Generate a PDF file from Markdown or HTML. Returns absolute path."""
+    import mistune
+    from weasyprint import HTML
+
     path = resolve_output_path(filename, ".pdf", output_dir)
     html_body = mistune.html(content) if content_type == "markdown" else content
     css = _PDF_CSS.replace("{page_size}", page_size)
@@ -96,3 +98,23 @@ def create_docx(content: str, filename: str, *, content_type: str = "markdown",
 
     doc.save(str(path))
     return str(path.resolve())
+
+
+def create_docx_from_template(template_path: str, data: dict[str, Any], filename: str, *,
+                              output_dir: str | None = None) -> str:
+    """Render a DOCX template with Jinja-style placeholders.
+
+    The template must be a `.docx` file. Placeholders use docxtpl syntax, for example
+    `{{ customer_name }}` or `{% for item in items %}...{% endfor %}`.
+    Returns the absolute path of the generated document.
+    """
+    if not isinstance(data, dict):
+        raise TypeError("data must be a dict")
+
+    from docxtpl import DocxTemplate
+
+    path = resolve_output_path(filename, ".docx", output_dir)
+    doc = DocxTemplate(template_path)
+    doc.render(data)
+    doc.save(str(path))
+    return str(path.resolve())

{licos_dev_sdk-0.2.7 → licos_dev_sdk-0.2.8}/src/licos_dev_sdk/model.py

@@ -698,22 +698,22 @@ def _fetch_model_detail(
     model_code = str(model_code or "").strip()
     if not model_code:
         return None
-    _ = workspace_id
-    cache_key = (runtime.base_url, runtime.token, model_code)
+    _ = workspace_id
+    cache_key = (runtime.base_url, runtime.token, model_code)
     ttl = _int_env("LICOS_MODEL_CATALOG_CACHE_TTL_SECS", DEFAULT_CATALOG_CACHE_TTL_SECS)
     cached = _DETAIL_CACHE.get(cache_key)
     if cached and not refresh and time.time() - cached[0] <= ttl:
         return cached[1]
 
-    query = {"code": model_code}
-    url = f"{runtime.base_url}{MODEL_DETAIL_PATH}?{parse.urlencode(query)}"
-    try:
-        payload = _request_json(
-            "GET",
-            url,
-            token=runtime.token,
-            timeout=30,
-        )
+    query = {"code": model_code}
+    url = f"{runtime.base_url}{MODEL_DETAIL_PATH}?{parse.urlencode(query)}"
+    try:
+        payload = _request_json(
+            "GET",
+            url,
+            token=runtime.token,
+            timeout=30,
+        )
     except ApiError as exc:
         if not refresh and should_refresh_user_token(exc):
             return _fetch_model_detail(
@@ -779,11 +779,11 @@ def _resolve_chat_endpoint(
         "chat",
         model_group=model_group,
         requested_model=requested_model,
-    )
-    selected_model = _selected_model(requested_model, endpoint.model)
-    endpoint = replace(endpoint, model=selected_model)
-    detail = _fetch_model_detail(runtime, selected_model)
-    return _apply_model_detail(endpoint, detail)
+    )
+    selected_model = _selected_model(requested_model, endpoint.model)
+    endpoint = replace(endpoint, model=selected_model)
+    detail = _fetch_model_detail(runtime, selected_model)
+    return _apply_model_detail(endpoint, detail)
 
 
 def _resolve_endpoint_with_detail(
@@ -801,8 +801,8 @@ def _resolve_endpoint_with_detail(
         requested_model=requested_model,
         input_capabilities=input_capabilities,
     )
-    detail = _fetch_model_detail(runtime, endpoint.model)
-    return _apply_model_detail(endpoint, detail)
+    detail = _fetch_model_detail(runtime, endpoint.model)
+    return _apply_model_detail(endpoint, detail)
 
 
 def _resolve_endpoint(

licos_dev_sdk-0.2.8/src/licos_dev_sdk/spreadsheet.py

@@ -0,0 +1,199 @@
+"""Spreadsheet generation — XLSX, CSV."""
+
+from __future__ import annotations
+
+import csv
+from typing import Any
+
+from openpyxl import Workbook
+from openpyxl.styles import Font, PatternFill, Alignment
+
+from ._utils import resolve_output_path
+
+
+def create_xlsx(data: list[dict] | list[list], filename: str, *,
+                output_dir: str | None = None, sheet_name: str = "Sheet1",
+                header_color: str = "4472C4") -> str:
+    """Generate an XLSX file from data. Returns absolute path.
+
+    Args:
+        data: List of dicts (keys as headers) or 2D list (first row as headers).
+    """
+    path = resolve_output_path(filename, ".xlsx", output_dir)
+    wb = Workbook()
+    ws = wb.active
+    ws.title = sheet_name
+
+    header_fill = PatternFill(start_color=header_color, end_color=header_color, fill_type="solid")
+    header_font = Font(bold=True, color="FFFFFF")
+
+    if data and isinstance(data[0], dict):
+        headers = list(data[0].keys())
+        ws.append(headers)
+        for row in data:
+            ws.append([row.get(h) for h in headers])
+    elif data and isinstance(data[0], list):
+        for row in data:
+            ws.append(row)
+    else:
+        wb.save(str(path))
+        return str(path.resolve())
+
+    # Style header row
+    for cell in ws[1]:
+        cell.fill = header_fill
+        cell.font = header_font
+        cell.alignment = Alignment(horizontal="center")
+
+    # Auto-width columns
+    for col in ws.columns:
+        max_len = 0
+        col_letter = col[0].column_letter
+        for cell in col:
+            val = str(cell.value) if cell.value is not None else ""
+            max_len = max(max_len, len(val))
+        ws.column_dimensions[col_letter].width = min(max_len + 4, 50)
+
+    wb.save(str(path))
+    return str(path.resolve())
+
+
+def create_csv(data: list[dict] | list[list], filename: str, *, output_dir: str | None = None) -> str:
+    """Generate a CSV file from data. Returns absolute path."""
+    path = resolve_output_path(filename, ".csv", output_dir)
+
+    with open(path, "w", newline="", encoding="utf-8-sig") as f:
+        if data and isinstance(data[0], dict):
+            writer = csv.DictWriter(f, fieldnames=data[0].keys())
+            writer.writeheader()
+            writer.writerows(data)
+        elif data and isinstance(data[0], list):
+            writer = csv.writer(f)
+            writer.writerows(data)
+
+    return str(path.resolve())
+
+
+def create_xlsx_workbook(workbook: dict[str, Any] | list[dict[str, Any]], filename: str, *,
+                         output_dir: str | None = None, header_color: str = "4472C4",
+                         freeze_header: bool = True, autofilter: bool = True) -> str:
+    """Generate a multi-sheet XLSX workbook. Returns absolute path.
+
+    Supported input shapes:
+
+    - `{"Sheet1": [{"A": 1}], "Sheet2": [["Name", "Score"], ["Alice", 95]]}`
+    - `{"sheets": [{"name": "Sheet1", "data": [{"A": 1}]}]}`
+    - `[{"name": "Sheet1", "data": [{"A": 1}]}]`
+    """
+    path = resolve_output_path(filename, ".xlsx", output_dir)
+
+    import xlsxwriter
+
+    sheets = _normalize_workbook_sheets(workbook)
+    book = xlsxwriter.Workbook(str(path))
+    header_fmt = book.add_format({
+        "bold": True,
+        "font_color": "white",
+        "bg_color": f"#{header_color.lstrip('#')}",
+        "align": "center",
+        "valign": "vcenter",
+        "border": 1,
+    })
+    cell_fmt = book.add_format({"border": 1, "valign": "top"})
+
+    used_names: set[str] = set()
+    for raw_name, data in sheets:
+        sheet_name = _unique_sheet_name(_sanitize_sheet_name(raw_name), used_names)
+        used_names.add(sheet_name)
+        ws = book.add_worksheet(sheet_name)
+        rows = _rows_from_sheet_data(data)
+
+        column_widths: list[int] = []
+        for row_index, row in enumerate(rows):
+            for col_index, value in enumerate(row):
+                fmt = header_fmt if row_index == 0 else cell_fmt
+                ws.write(row_index, col_index, value, fmt)
+                text_len = len(str(value)) if value is not None else 0
+                if col_index >= len(column_widths):
+                    column_widths.append(0)
+                column_widths[col_index] = min(max(column_widths[col_index], text_len + 4), 60)
+
+        for col_index, width in enumerate(column_widths):
+            ws.set_column(col_index, col_index, max(width, 10))
+        if rows and freeze_header:
+            ws.freeze_panes(1, 0)
+        if rows and autofilter and rows[0]:
+            ws.autofilter(0, 0, max(len(rows) - 1, 0), len(rows[0]) - 1)
+
+    if not sheets:
+        book.add_worksheet("Sheet1")
+    book.close()
+    return str(path.resolve())
+
+
+def _normalize_workbook_sheets(workbook: dict[str, Any] | list[dict[str, Any]]) -> list[tuple[str, Any]]:
+    if isinstance(workbook, dict) and "sheets" in workbook:
+        workbook = workbook["sheets"]
+
+    if isinstance(workbook, dict):
+        return [(str(name), data) for name, data in workbook.items()]
+
+    if isinstance(workbook, list):
+        sheets: list[tuple[str, Any]] = []
+        for index, item in enumerate(workbook, start=1):
+            if not isinstance(item, dict):
+                raise TypeError("workbook sheet list items must be dicts")
+            name = str(item.get("name") or item.get("sheet_name") or f"Sheet{index}")
+            data = item.get("data", item.get("rows", []))
+            sheets.append((name, data))
+        return sheets
+
+    raise TypeError("workbook must be a dict or a list of sheet definitions")
+
+
+def _rows_from_sheet_data(data: Any) -> list[list[Any]]:
+    if isinstance(data, dict) and "rows" in data:
+        columns = data.get("columns")
+        rows = data.get("rows") or []
+        if columns:
+            keys = [str(col.get("key") if isinstance(col, dict) else col) for col in columns]
+            labels = [str(col.get("label") or col.get("key")) if isinstance(col, dict) else str(col) for col in columns]
+            body = [[row.get(key) if isinstance(row, dict) else None for key in keys] for row in rows]
+            return [labels, *body]
+        data = rows
+
+    if not data:
+        return []
+
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        headers: list[str] = []
+        for row in data:
+            if not isinstance(row, dict):
+                raise TypeError("dict-row sheets cannot mix non-dict rows")
+            for key in row.keys():
+                key_str = str(key)
+                if key_str not in headers:
+                    headers.append(key_str)
+        return [headers, *[[row.get(header) for header in headers] for row in data]]
+
+    if isinstance(data, list) and all(isinstance(row, list) for row in data):
+        return data
+
+    raise TypeError("sheet data must be a list of dicts, a 2D list, or {columns, rows}")
+
+
+def _sanitize_sheet_name(name: str) -> str:
+    sanitized = "".join("_" if ch in "[]:*?/\\" else ch for ch in name).strip()
+    return (sanitized or "Sheet")[:31]
+
+
+def _unique_sheet_name(name: str, used_names: set[str]) -> str:
+    if name not in used_names:
+        return name
+    base = name[:28]
+    index = 2
+    while True:
+        candidate = f"{base}_{index}"[:31]
+        if candidate not in used_names:
+            return candidate
+        index += 1

licos_dev_sdk-0.2.8/tests/test_document_spreadsheet.py

@@ -0,0 +1,58 @@
+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 docx import Document
+from openpyxl import load_workbook
+
+from licos_dev_sdk import create_docx_from_template, create_xlsx_workbook
+
+
+class DocumentSpreadsheetTests(unittest.TestCase):
+    def test_create_docx_from_template_renders_placeholders(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            template_path = tmp_path / "template.docx"
+
+            doc = Document()
+            doc.add_paragraph("客户：{{ customer }}")
+            doc.add_paragraph("金额：{{ amount }}")
+            doc.save(template_path)
+
+            output = create_docx_from_template(
+                str(template_path),
+                {"customer": "张三", "amount": "10000.00"},
+                "contract",
+                output_dir=str(tmp_path),
+            )
+
+            rendered = Document(output)
+            text = "\n".join(paragraph.text for paragraph in rendered.paragraphs)
+            self.assertIn("客户：张三", text)
+            self.assertIn("金额：10000.00", text)
+
+    def test_create_xlsx_workbook_writes_multiple_sheets(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            output = create_xlsx_workbook(
+                {
+                    "销售": [{"月份": "1月", "金额": 12000}, {"月份": "2月", "金额": 18000}],
+                    "客户": [["姓名", "等级"], ["张三", "A"]],
+                },
+                "report",
+                output_dir=tmp,
+            )
+
+            wb = load_workbook(output)
+            self.assertEqual(wb.sheetnames, ["销售", "客户"])
+            self.assertEqual(wb["销售"]["A1"].value, "月份")
+            self.assertEqual(wb["销售"]["B2"].value, 12000)
+            self.assertEqual(wb["客户"]["A2"].value, "张三")
+
+
+if __name__ == "__main__":
+    unittest.main()

licos_dev_sdk-0.2.7/src/licos_dev_sdk/spreadsheet.py

@@ -1,75 +0,0 @@
-"""Spreadsheet generation — XLSX, CSV."""
-
-from __future__ import annotations
-
-import csv
-import io
-from typing import Any
-
-from openpyxl import Workbook
-from openpyxl.styles import Font, PatternFill, Alignment
-
-from ._utils import resolve_output_path
-
-
-def create_xlsx(data: list[dict] | list[list], filename: str, *,
-                output_dir: str | None = None, sheet_name: str = "Sheet1",
-                header_color: str = "4472C4") -> str:
-    """Generate an XLSX file from data. Returns absolute path.
-
-    Args:
-        data: List of dicts (keys as headers) or 2D list (first row as headers).
-    """
-    path = resolve_output_path(filename, ".xlsx", output_dir)
-    wb = Workbook()
-    ws = wb.active
-    ws.title = sheet_name
-
-    header_fill = PatternFill(start_color=header_color, end_color=header_color, fill_type="solid")
-    header_font = Font(bold=True, color="FFFFFF")
-
-    if data and isinstance(data[0], dict):
-        headers = list(data[0].keys())
-        ws.append(headers)
-        for row in data:
-            ws.append([row.get(h) for h in headers])
-    elif data and isinstance(data[0], list):
-        for row in data:
-            ws.append(row)
-    else:
-        wb.save(str(path))
-        return str(path.resolve())
-
-    # Style header row
-    for cell in ws[1]:
-        cell.fill = header_fill
-        cell.font = header_font
-        cell.alignment = Alignment(horizontal="center")
-
-    # Auto-width columns
-    for col in ws.columns:
-        max_len = 0
-        col_letter = col[0].column_letter
-        for cell in col:
-            val = str(cell.value) if cell.value is not None else ""
-            max_len = max(max_len, len(val))
-        ws.column_dimensions[col_letter].width = min(max_len + 4, 50)
-
-    wb.save(str(path))
-    return str(path.resolve())
-
-
-def create_csv(data: list[dict] | list[list], filename: str, *, output_dir: str | None = None) -> str:
-    """Generate a CSV file from data. Returns absolute path."""
-    path = resolve_output_path(filename, ".csv", output_dir)
-
-    with open(path, "w", newline="", encoding="utf-8-sig") as f:
-        if data and isinstance(data[0], dict):
-            writer = csv.DictWriter(f, fieldnames=data[0].keys())
-            writer.writeheader()
-            writer.writerows(data)
-        elif data and isinstance(data[0], list):
-            writer = csv.writer(f)
-            writer.writerows(data)
-
-    return str(path.resolve())