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

{licos_dev_sdk-0.2.7 → licos_dev_sdk-0.2.9}/.gitignore

@@ -33,6 +33,7 @@ crates/industrial/industrial-stack.env
 # Build
 *.log
 *.pid
+crates/industrial/bin/
 .licos
 .tmp
 .playwright-cli
@@ -42,6 +43,8 @@ tools/android-sdk-cache/*.zip
 
 *.codex-*
 
+__pycache__
+
 dist
 logs
 

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

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: licos-dev-sdk
-Version: 0.2.7
+Version: 0.2.9
 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.9}/pyproject.toml

@@ -4,14 +4,16 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-dev-sdk"
-version = "0.2.7"
+version = "0.2.9"
 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",
+    "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.9}/src/licos_dev_sdk/__init__.py

@@ -26,8 +26,10 @@ def __getattr__(name: str):
         # 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"),
@@ -86,8 +88,8 @@ __all__ = [
     "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_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.9}/src/licos_dev_sdk/_utils.py

@@ -10,13 +10,19 @@ from pathlib import Path
 def resolve_output_dir(output_dir: str | None = None) -> Path:
     """Resolve the output directory.
 
-    Priority: explicit arg > $LICOS_WORKSPACE_PATH > cwd
+    Priority: explicit arg > $LICOS_PROJECT_PATH > $LICOS_WORKSPACE_PATH/projects > cwd
     """
     if output_dir:
         p = Path(output_dir)
     else:
-        env = os.environ.get("LICOS_WORKSPACE_PATH", "")
-        p = Path(env) if env else Path.cwd()
+        project_path = os.environ.get("LICOS_PROJECT_PATH", "")
+        workspace_path = os.environ.get("LICOS_WORKSPACE_PATH", "")
+        if project_path:
+            p = Path(project_path)
+        elif workspace_path:
+            p = Path(workspace_path) / "projects"
+        else:
+            p = Path.cwd()
     p.mkdir(parents=True, exist_ok=True)
     return p
 

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

@@ -1,98 +1,120 @@
-"""Document generation — PDF, DOCX."""
-
-from __future__ import annotations
-
-import mistune
-from weasyprint import HTML
-from docx import Document
-from docx.shared import Pt, Inches
-from docx.enum.text import WD_ALIGN_PARAGRAPH
-
-from ._utils import resolve_output_path
-
-_PDF_CSS = """
-@page { size: {page_size}; margin: 2cm; }
-body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Noto Sans CJK SC", sans-serif;
-       font-size: 11pt; line-height: 1.6; color: #333; }
-h1 { font-size: 22pt; margin-top: 0; }
-h2 { font-size: 16pt; }
-h3 { font-size: 13pt; }
-table { border-collapse: collapse; width: 100%; margin: 1em 0; }
-th, td { border: 1px solid #ccc; padding: 6px 10px; text-align: left; }
-th { background: #f0f0f0; font-weight: 600; }
-code { background: #f4f4f4; padding: 1px 4px; border-radius: 3px; font-size: 10pt; }
-pre { background: #f4f4f4; padding: 12px; border-radius: 4px; overflow-x: auto; }
-blockquote { border-left: 3px solid #ccc; margin-left: 0; padding-left: 1em; color: #666; }
-"""
-
-
-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."""
-    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)
-    full_html = f"<html><head><style>{css}</style></head><body>{html_body}</body></html>"
-    HTML(string=full_html).write_pdf(str(path))
-    return str(path.resolve())
-
-
-def create_docx(content: str, filename: str, *, content_type: str = "markdown",
-                output_dir: str | None = None, font_name: str = "Arial", font_size: int = 11) -> str:
-    """Generate a DOCX file from Markdown or HTML. Returns absolute path.
-
-    Converts Markdown to a simple DOCX with headings, paragraphs, and lists.
-    For complex HTML, consider generating PDF instead.
-    """
-    path = resolve_output_path(filename, ".docx", output_dir)
-
-    if content_type == "html":
-        # For HTML input, convert to markdown-like text first
-        import re
-        text = re.sub(r"<[^>]+>", "", content)
-        lines = [l.strip() for l in text.split("\n") if l.strip()]
-    else:
-        lines = content.split("\n")
-
-    doc = Document()
-    # Set default font
-    style = doc.styles["Normal"]
-    style.font.name = font_name
-    style.font.size = Pt(font_size)
-
-    for line in lines:
-        stripped = line.strip()
-        if not stripped:
-            continue
-        # Headings
-        if stripped.startswith("######"):
-            doc.add_heading(stripped.lstrip("#").strip(), level=6)
-        elif stripped.startswith("#####"):
-            doc.add_heading(stripped.lstrip("#").strip(), level=5)
-        elif stripped.startswith("####"):
-            doc.add_heading(stripped.lstrip("#").strip(), level=4)
-        elif stripped.startswith("###"):
-            doc.add_heading(stripped.lstrip("#").strip(), level=3)
-        elif stripped.startswith("##"):
-            doc.add_heading(stripped.lstrip("#").strip(), level=2)
-        elif stripped.startswith("#"):
-            doc.add_heading(stripped.lstrip("#").strip(), level=1)
-        # Unordered list
-        elif stripped.startswith("- ") or stripped.startswith("* "):
-            doc.add_paragraph(stripped[2:], style="List Bullet")
-        # Ordered list
-        elif len(stripped) > 2 and stripped[0].isdigit() and stripped[1] in (".", ")"):
-            doc.add_paragraph(stripped[2:].strip(), style="List Number")
-        # Blockquote
-        elif stripped.startswith("> "):
-            p = doc.add_paragraph(stripped[2:])
-            p.paragraph_format.left_indent = Inches(0.5)
-            p.style.font.italic = True
-        # Horizontal rule
-        elif stripped in ("---", "***", "___"):
-            doc.add_paragraph("─" * 50)
-        else:
-            doc.add_paragraph(stripped)
-
-    doc.save(str(path))
-    return str(path.resolve())
+"""Document generation — PDF, DOCX."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from docx import Document
+from docx.shared import Pt, Inches
+
+from ._utils import resolve_output_path
+
+_PDF_CSS = """
+@page { size: {page_size}; margin: 2cm; }
+body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Noto Sans CJK SC", sans-serif;
+       font-size: 11pt; line-height: 1.6; color: #333; }
+h1 { font-size: 22pt; margin-top: 0; }
+h2 { font-size: 16pt; }
+h3 { font-size: 13pt; }
+table { border-collapse: collapse; width: 100%; margin: 1em 0; }
+th, td { border: 1px solid #ccc; padding: 6px 10px; text-align: left; }
+th { background: #f0f0f0; font-weight: 600; }
+code { background: #f4f4f4; padding: 1px 4px; border-radius: 3px; font-size: 10pt; }
+pre { background: #f4f4f4; padding: 12px; border-radius: 4px; overflow-x: auto; }
+blockquote { border-left: 3px solid #ccc; margin-left: 0; padding-left: 1em; color: #666; }
+"""
+
+
+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)
+    full_html = f"<html><head><style>{css}</style></head><body>{html_body}</body></html>"
+    HTML(string=full_html).write_pdf(str(path))
+    return str(path.resolve())
+
+
+def create_docx(content: str, filename: str, *, content_type: str = "markdown",
+                output_dir: str | None = None, font_name: str = "Arial", font_size: int = 11) -> str:
+    """Generate a DOCX file from Markdown or HTML. Returns absolute path.
+
+    Converts Markdown to a simple DOCX with headings, paragraphs, and lists.
+    For complex HTML, consider generating PDF instead.
+    """
+    path = resolve_output_path(filename, ".docx", output_dir)
+
+    if content_type == "html":
+        # For HTML input, convert to markdown-like text first
+        import re
+        text = re.sub(r"<[^>]+>", "", content)
+        lines = [l.strip() for l in text.split("\n") if l.strip()]
+    else:
+        lines = content.split("\n")
+
+    doc = Document()
+    # Set default font
+    style = doc.styles["Normal"]
+    style.font.name = font_name
+    style.font.size = Pt(font_size)
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        # Headings
+        if stripped.startswith("######"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=6)
+        elif stripped.startswith("#####"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=5)
+        elif stripped.startswith("####"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=4)
+        elif stripped.startswith("###"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=3)
+        elif stripped.startswith("##"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=2)
+        elif stripped.startswith("#"):
+            doc.add_heading(stripped.lstrip("#").strip(), level=1)
+        # Unordered list
+        elif stripped.startswith("- ") or stripped.startswith("* "):
+            doc.add_paragraph(stripped[2:], style="List Bullet")
+        # Ordered list
+        elif len(stripped) > 2 and stripped[0].isdigit() and stripped[1] in (".", ")"):
+            doc.add_paragraph(stripped[2:].strip(), style="List Number")
+        # Blockquote
+        elif stripped.startswith("> "):
+            p = doc.add_paragraph(stripped[2:])
+            p.paragraph_format.left_indent = Inches(0.5)
+            p.style.font.italic = True
+        # Horizontal rule
+        elif stripped in ("---", "***", "___"):
+            doc.add_paragraph("─" * 50)
+        else:
+            doc.add_paragraph(stripped)
+
+    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.9}/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.9/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.9/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.9/tests/test_output_paths.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+from licos_dev_sdk._utils import resolve_output_dir
+
+
+class OutputPathTests(unittest.TestCase):
+    def test_explicit_output_dir_wins(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            explicit = Path(tmp) / "custom"
+            with patch.dict(
+                os.environ,
+                {
+                    "LICOS_PROJECT_PATH": str(Path(tmp) / "project"),
+                    "LICOS_WORKSPACE_PATH": str(Path(tmp) / "workspace"),
+                },
+                clear=False,
+            ):
+                self.assertEqual(resolve_output_dir(str(explicit)), explicit)
+                self.assertTrue(explicit.exists())
+
+    def test_defaults_to_licos_project_path(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            project = Path(tmp) / "projects"
+            workspace = Path(tmp) / "workspace"
+            with patch.dict(
+                os.environ,
+                {
+                    "LICOS_PROJECT_PATH": str(project),
+                    "LICOS_WORKSPACE_PATH": str(workspace),
+                },
+                clear=False,
+            ):
+                self.assertEqual(resolve_output_dir(), project)
+                self.assertTrue(project.exists())
+
+    def test_workspace_fallback_uses_projects_subdir(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            workspace = Path(tmp) / "workspace"
+            with patch.dict(
+                os.environ,
+                {"LICOS_WORKSPACE_PATH": str(workspace)},
+                clear=False,
+            ):
+                os.environ.pop("LICOS_PROJECT_PATH", None)
+                expected = workspace / "projects"
+                self.assertEqual(resolve_output_dir(), expected)
+                self.assertTrue(expected.exists())
+
+
+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())