Skywork Ppt

SKYWORK_GATEWAY_URL = "https://api-tools.skywork.ai/theme-gateway"
POD_TYPE = ""

#!/usr/bin/env python3
"""
Local PPTX operation tool (Layer 3, no backend required).
Dependency: pip install python-pptx

Subcommands:
  info     View basic file info (slide count, slide titles)
  delete   Delete specified slides (1-based, supports multiple and ranges, e.g. 3,5,7-9)
  reorder  Reorder slide sequence (e.g. 2,1,4,3,5)
  extract  Extract selected slides into a new file
  merge    Merge multiple pptx files

Usage examples:
  python scripts/local_pptx_ops.py info --file my.pptx
  python scripts/local_pptx_ops.py delete --file my.pptx --slides 3,5,7-9
  python scripts/local_pptx_ops.py delete --file my.pptx --slides 3,5,7-9 -o trimmed.pptx
  python scripts/local_pptx_ops.py reorder --file my.pptx --order 2,1,4,3,5
  python scripts/local_pptx_ops.py extract --file my.pptx --slides 1-3 -o subset.pptx
  python scripts/local_pptx_ops.py merge --files a.pptx b.pptx -o merged.pptx
"""

import argparse
import os
import sys
import shutil
import copy
import warnings

try:
    from pptx import Presentation
    from pptx.util import Inches, Pt
    from lxml import etree
except ImportError:
    print("Missing dependency, please run: pip install python-pptx", file=sys.stderr)
    sys.exit(1)


# ---------------------------------------------------------------------------
# Parse slide number string (1-based), return 0-based index list
# ---------------------------------------------------------------------------

def parse_slide_spec(spec: str, total: int) -> list[int]:
    """Parse a slide number string like '1,3,5-8,10', return a deduplicated sorted list of 0-based indices."""
    indices = set()
    for part in spec.split(","):
        part = part.strip()
        if not part:
            continue
        if "-" in part:
            lo, hi = part.split("-", 1)
            lo_i, hi_i = int(lo.strip()), int(hi.strip())
            if lo_i < 1 or hi_i > total:
                raise ValueError(f"Slide range {lo_i}-{hi_i} is out of bounds for a file with {total} slides")
            for i in range(lo_i - 1, hi_i):
                indices.add(i)
        else:
            n = int(part)
            if n < 1 or n > total:
                raise ValueError(f"Slide number {n} is out of bounds for a file with {total} slides")
            indices.add(n - 1)
    return sorted(indices)


def parse_order_spec(spec: str, total: int) -> list[int]:
    """Parse an order string for reorder, preserving user-specified order, return 0-based index list."""
    result = []
    seen = set()
    for part in spec.split(","):
        part = part.strip()
        if not part:
            continue
        n = int(part)
        if n < 1 or n > total:
            raise ValueError(f"Slide number {n} is out of bounds for a file with {total} slides")
        idx = n - 1
        if idx in seen:
            raise ValueError(f"Slide number {n} appears more than once")
        seen.add(idx)
        result.append(idx)
    return result


# ---------------------------------------------------------------------------
# Core operation: remove a single slide (XML manipulation, not natively supported by python-pptx)
# ---------------------------------------------------------------------------

def _remove_slide(prs: "Presentation", index: int) -> None:
    """Remove the slide at the given index (0-based) from the Presentation."""
    xml_slides = prs.slides._sldIdLst
    slide_elem = xml_slides[index]
    rId = slide_elem.get("{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id")
    xml_slides.remove(slide_elem)
    # Remove the corresponding relationship from rels to avoid "Duplicate name" warnings on save
    prs.part.rels.pop(rId)


# ---------------------------------------------------------------------------
# Subcommand: info
# ---------------------------------------------------------------------------

def cmd_info(args):
    prs = Presentation(args.file)
    total = len(prs.slides)
    print(f"File: {os.path.abspath(args.file)}")
    print(f"Total slides: {total}")
    print(f"Slide dimensions: {prs.slide_width.inches:.1f}\" x {prs.slide_height.inches:.1f}\"")
    print()
    for i, slide in enumerate(prs.slides):
        title_text = ""
        for shape in slide.shapes:
            if shape.has_text_frame and shape.shape_type == 13:
                continue  # Skip images
            try:
                if hasattr(shape, "placeholder_format") and shape.placeholder_format is not None:
                    ph_idx = shape.placeholder_format.idx
                    if ph_idx == 0:  # Title placeholder
                        title_text = shape.text_frame.text.strip()
                        break
            except Exception:
                pass
        # Fallback: use the first shape that has text
        if not title_text:
            for shape in slide.shapes:
                if shape.has_text_frame:
                    t = shape.text_frame.text.strip()
                    if t:
                        title_text = t[:60]
                        break
        print(f"  Slide {i+1:2d}: {title_text or '(no title)'}")


# ---------------------------------------------------------------------------
# Subcommand: delete
# ---------------------------------------------------------------------------

def cmd_delete(args):
    prs = Presentation(args.file)
    total = len(prs.slides)
    indices = parse_slide_spec(args.slides, total)
    if not indices:
        print("No valid slide numbers specified, no action taken.")
        return

    # Delete from back to front to avoid index shifting
    for idx in reversed(indices):
        _remove_slide(prs, idx)

    pages_str = ", ".join(str(i + 1) for i in indices)
    remaining = total - len(indices)
    out = _resolve_output(args, args.file)
    prs.save(out)
    print(f"Deleted slide(s) {pages_str} ({len(indices)} deleted, {remaining} remaining)")
    print(f"Saved to: {os.path.abspath(out)}")
    print()
    print(f"RESULT: success")
    print(f"OUTPUT_FILE: {os.path.abspath(out)}")


# ---------------------------------------------------------------------------
# Subcommand: reorder
# ---------------------------------------------------------------------------

def cmd_reorder(args):
    prs = Presentation(args.file)
    total = len(prs.slides)
    order = parse_order_spec(args.order, total)

    if len(order) != total:
        raise ValueError(
            f"--order specified {len(order)} slide numbers, but the file has {total} slides; all slides must be included without duplicates."
        )
    if sorted(order) != list(range(total)):
        raise ValueError("--order must include each slide exactly once (no duplicates, no omissions).")

    xml_slides = prs.slides._sldIdLst
    # Retrieve all sldId elements
    sld_id_elems = list(xml_slides)
    # Rearrange in the new order
    for elem in sld_id_elems:
        xml_slides.remove(elem)
    for new_pos in order:
        xml_slides.append(sld_id_elems[new_pos])

    out = _resolve_output(args, args.file)
    prs.save(out)
    order_str = ",".join(str(i + 1) for i in order)
    print(f"Reordered to [{order_str}], total {total} slides")
    print(f"Saved to: {os.path.abspath(out)}")
    print()
    print(f"RESULT: success")
    print(f"OUTPUT_FILE: {os.path.abspath(out)}")


# ---------------------------------------------------------------------------
# Subcommand: extract
# ---------------------------------------------------------------------------

def cmd_extract(args):
    prs = Presentation(args.file)
    total = len(prs.slides)
    keep = parse_slide_spec(args.slides, total)
    if not keep:
        print("No valid slide numbers specified, no action taken.")
        return

    # Delete slides not in the keep list
    delete_indices = [i for i in range(total) if i not in set(keep)]
    for idx in reversed(delete_indices):
        _remove_slide(prs, idx)

    out = args.output or "extracted.pptx"
    prs.save(out)
    pages_str = ", ".join(str(i + 1) for i in keep)
    print(f"Extracted slide(s) {pages_str} ({len(keep)} slides)")
    print(f"Saved to: {os.path.abspath(out)}")
    print()
    print(f"RESULT: success")
    print(f"OUTPUT_FILE: {os.path.abspath(out)}")


# ---------------------------------------------------------------------------
# Subcommand: merge
# ---------------------------------------------------------------------------

def cmd_merge(args):
    if not args.files or len(args.files) < 2:
        raise ValueError("At least two --files must be provided.")

    # Use the first file as the base
    base_prs = Presentation(args.files[0])
    slide_width = base_prs.slide_width
    slide_height = base_prs.slide_height

    for src_path in args.files[1:]:
        src_prs = Presentation(src_path)
        for slide in src_prs.slides:
            # Add a new slide with a blank layout
            slide_layout = base_prs.slide_layouts[-1]  # Use the last layout (usually blank)
            new_slide = base_prs.slides.add_slide(slide_layout)
            # Copy the spTree (shape tree) contents from the source slide
            new_sp_tree = new_slide.shapes._spTree
            old_sp_tree = slide.shapes._spTree
            # Remove default placeholders from the new slide
            for child in list(new_sp_tree):
                new_sp_tree.remove(child)
            # Copy all child elements
            for child in old_sp_tree:
                new_sp_tree.append(copy.deepcopy(child))

    out = args.output or "merged.pptx"
    base_prs.save(out)
    total = len(base_prs.slides)
    files_str = ", ".join(args.files)
    print(f"Merged: {files_str}")
    print(f"Total {total} slides, saved to: {os.path.abspath(out)}")
    print()
    print(f"RESULT: success")
    print(f"OUTPUT_FILE: {os.path.abspath(out)}")


# ---------------------------------------------------------------------------
# Utility functions
# ---------------------------------------------------------------------------

def _resolve_output(args, original_file: str) -> str:
    """Use -o output path if specified by the user, otherwise overwrite the original file."""
    if hasattr(args, "output") and args.output:
        return args.output
    return original_file


# ---------------------------------------------------------------------------
# CLI entry point
# ---------------------------------------------------------------------------

def main():
    parser = argparse.ArgumentParser(
        description="Local PPTX operation tool (delete/reorder/extract/merge slides)",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python scripts/local_pptx_ops.py info --file my.pptx
  python scripts/local_pptx_ops.py delete --file my.pptx --slides 3,5,7-9
  python scripts/local_pptx_ops.py delete --file my.pptx --slides 3,5,7-9 -o trimmed.pptx
  python scripts/local_pptx_ops.py reorder --file my.pptx --order 2,1,4,3,5
  python scripts/local_pptx_ops.py extract --file my.pptx --slides 1-3 -o subset.pptx
  python scripts/local_pptx_ops.py merge --files a.pptx b.pptx -o merged.pptx
""",
    )
    sub = parser.add_subparsers(dest="cmd", required=True)

    # info
    p_info = sub.add_parser("info", help="View file info (slide count, titles)")
    p_info.add_argument("--file", required=True, help="Input .pptx file path")

    # delete
    p_del = sub.add_parser("delete", help="Delete specified slides (1-based, supports '3,5,7-9')")
    p_del.add_argument("--file", required=True, help="Input .pptx file path")
    p_del.add_argument("--slides", required=True, help="Slide numbers to delete, e.g. '3,5,7-9'")
    p_del.add_argument("-o", "--output", default="", help="Output path (defaults to overwriting the original file)")

    # reorder
    p_reorder = sub.add_parser("reorder", help="Reorder slide sequence")
    p_reorder.add_argument("--file", required=True, help="Input .pptx file path")
    p_reorder.add_argument("--order", required=True, help="New order, e.g. '2,1,4,3,5' (must include all slides)")
    p_reorder.add_argument("-o", "--output", default="", help="Output path (defaults to overwriting the original file)")

    # extract
    p_extract = sub.add_parser("extract", help="Extract selected slides into a new file")
    p_extract.add_argument("--file", required=True, help="Input .pptx file path")
    p_extract.add_argument("--slides", required=True, help="Slide numbers to keep, e.g. '1-3,5'")
    p_extract.add_argument("-o", "--output", default="", help="Output path (defaults to extracted.pptx)")

    # merge
    p_merge = sub.add_parser("merge", help="Merge multiple pptx files")
    p_merge.add_argument("--files", nargs="+", required=True, help="Input file list (merged in order)")
    p_merge.add_argument("-o", "--output", default="", help="Output path (defaults to merged.pptx)")

    args = parser.parse_args()

    try:
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore", message="Duplicate name", category=UserWarning)
            if args.cmd == "info":
                cmd_info(args)
            elif args.cmd == "delete":
                cmd_delete(args)
            elif args.cmd == "reorder":
                cmd_reorder(args)
            elif args.cmd == "extract":
                cmd_extract(args)
            elif args.cmd == "merge":
                cmd_merge(args)
    except (ValueError, FileNotFoundError) as e:
        print(f"Error: {e}", file=sys.stderr)
        print()
        print(f"RESULT: error")
        print(f"ERROR: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Parse a reference file via the Skywork Office file/parse SSE endpoint.

Uploads the file, triggers server-side analysis (OCR, text extraction),
polls until complete, and returns the parsed content.

Usage:
    python parse_file.py /path/to/document.pdf [--output parsed_content.txt]

Environment variables:
    SKYWORK_API_KEY      - Auth api key
"""

import argparse
import io
import json
import mimetypes
import os
import sys
import uuid
from pathlib import Path
from urllib.request import Request, urlopen
from urllib.error import URLError, HTTPError

from constant import SKYWORK_GATEWAY_URL
from skywork_auth import get_skywork_api_key


def build_multipart_body(file_path: str):
    """Build a multipart/form-data request body."""
    boundary = f"----FormBoundary{uuid.uuid4().hex[:16]}"
    body = io.BytesIO()
    file_name = os.path.basename(file_path)
    mime_type = mimetypes.guess_type(file_path)[0] or "application/octet-stream"

    body.write(f"--{boundary}\r\n".encode())
    body.write(f'Content-Disposition: form-data; name="file"; filename="{file_name}"\r\n'.encode())
    body.write(f"Content-Type: {mime_type}\r\n\r\n".encode())
    with open(file_path, "rb") as f:
        body.write(f.read())
    body.write(b"\r\n")
    body.write(f"--{boundary}--\r\n".encode())

    return body.getvalue(), f"multipart/form-data; boundary={boundary}"


def parse_sse_events(response):
    """Parse SSE events from an HTTP response stream."""
    cur_event = None
    cur_data = None
    for line_bytes in response:
        line = line_bytes.decode("utf-8", errors="replace").rstrip("\r\n")
        if line == "":
            if cur_event is not None and cur_data is not None:
                try:
                    data = json.loads(cur_data)
                    yield cur_event, data
                except json.JSONDecodeError:
                    pass
            cur_event = None
            cur_data = None
        elif line.startswith("event: "):
            cur_event = line[7:].strip()
        elif line.startswith("data: "):
            cur_data = line[6:]
    if cur_event is not None and cur_data is not None:
        try:
            data = json.loads(cur_data)
            yield cur_event, data
        except json.JSONDecodeError:
            pass


def parse_file(base_url: str, api_key: str, file_path: str) -> dict:
    """Upload and parse a file, streaming progress. Returns parsed metadata."""
    url = f"{base_url}/api/sse/file/parse"
    file_name = os.path.basename(file_path)
    file_size = os.path.getsize(file_path)

    print(f"[parse] File: {file_name} ({file_size:,} bytes)")
    print(f"[parse] Server: {base_url}")
    print()

    body, content_type = build_multipart_body(file_path)
    req = Request(url, data=body, method="POST")
    req.add_header("Content-Type", content_type)
    if api_key:
        req.add_header("Authorization", f"Bearer {api_key}")

    try:
        resp = urlopen(req, timeout=300)
    except HTTPError as e:
        body_text = e.read().decode('utf-8', errors='replace')
        print(f"[error] HTTP {e.code}: {body_text}", file=sys.stderr)
        sys.exit(1)
    except URLError as e:
        print(f"[error] Cannot reach server: {e.reason}", file=sys.stderr)
        sys.exit(1)

    result = None
    event_count = 0
    for event_type, data in parse_sse_events(resp):
        event_count += 1
        print(f"[debug] Event #{event_count}: {event_type}\n", flush=True)
        if event_type == "progress":
            stage = data.get("stage", "")
            pct = data.get("percentage", 0)
            msg = data.get("message", "")
            bar = "=" * int(pct / 5) + ">" + " " * (20 - int(pct / 5))
            print(f"\r[{bar}] {pct:5.1f}%  {msg}", end="", flush=True)
        elif event_type == "success":
            print()  # newline after progress bar
            result = data
            metadata = data.get("metadata", {})
            exec_time = data.get("execution_time", 0)
            print()
            print(f"[success] File parsed!")
            print(f"  File ID:    {data.get('file_id', '?')}")
            print(f"  File NAME:    {metadata.get('file_name', '')}")
            print(f"  File URL:    {metadata.get('file_url', '')}")
            print(f"  Title:      {metadata.get('parsed_title', '(none)')}")
            print(f"  Summary:    {metadata.get('summary', '(none)')}")
        elif event_type == "error":
            print()
            code = data.get("code", "UNKNOWN")
            msg = data.get("message", "Unknown error")
            print(f"\n[error] {code}: {msg}", file=sys.stderr)
            sys.exit(1)

    if result is None:
        print("[debug] No success/error event received — stream may have been empty or malformed", file=sys.stderr)
    return result


def main():
    parser = argparse.ArgumentParser(description="Parse a reference file via Skywork Office API")
    parser.add_argument("file", help="Path to the file to parse")
    parser.add_argument("--output", "-o", default=None, help="Save parsed content to this file")
    parser.add_argument("--json", action="store_true", help="Output full result as JSON")
    args = parser.parse_args()

    if not os.path.isfile(args.file):
        print(f"[error] File not found: {args.file}", file=sys.stderr)
        sys.exit(1)

    base_url = SKYWORK_GATEWAY_URL
    api_key = get_skywork_api_key()
    if not api_key:
        print("[error] SKYWORK_API_KEY is required", file=sys.stderr)
        sys.exit(1)

    result = parse_file(base_url, api_key, args.file)

    if result:
        metadata = result.get("metadata", {})
        parsed_content = metadata.get("parsed_content", "")

        if args.output:
            with open(args.output, "w", encoding="utf-8") as f:
                f.write(parsed_content)
            print(f"\n[saved] Parsed content written to: {args.output}")
        elif args.json:
            print()
            print(json.dumps(result, indent=2, ensure_ascii=False))
        else:
            # Print a preview of the parsed content
            if parsed_content:
                preview = parsed_content[:1000]
                if len(parsed_content) > 1000:
                    preview += f"\n... ({len(parsed_content) - 1000:,} more chars)"

        # Machine-readable summary for downstream parsing
        file_name = metadata.get("file_name") or os.path.basename(args.file)
        file_url = metadata.get("file_url", "")
        parsed_info = {
            "file_id": result.get("file_id", ""),
            "filename": file_name,
            "file_type": metadata.get("file_type", ""),
            "url": file_url,
        }
        print(f"PARSED_FILE: {json.dumps(parsed_info, ensure_ascii=False)}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Call the ppt_write streaming API, output progress to stdout (for skill to relay in conversation), and save to disk via download_url upon completion.
Supports multiple environments: specify Base URL via environment variables or --env.

General usage (independent of skill installation path):
  - Recommended: have the platform execute run_ppt_write.py from the skill root, e.g.: python <skill_root>/run_ppt_write.py "title" -o my.pptx
    When the user types /ppt-write title, the platform resolves the skill root and runs the above command; no need for the user to specify the path.
  - Or call this script directly: python <skill_root>/scripts/call_stream.py "title" -o my.pptx
"""
import argparse
import datetime
import json
import os
import sys
import urllib.request
import urllib.error
import uuid

from constant import SKYWORK_GATEWAY_URL, POD_TYPE

from skywork_auth import get_skywork_api_key

def get_base_url() -> str:
    return SKYWORK_GATEWAY_URL


def write_log(log_file: str, line: str):
    """Append a plain-text line to the log file."""
    try:
        time_str = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        log_str = f"{time_str} {line.rstrip()}\n"
        print(log_str, flush=True)
        with open(log_file, "a", encoding="utf-8") as f:            
            f.write(log_str)
            f.flush()
    except Exception:
        pass


def phase_to_message(phase: str, data: dict) -> str:
    """Convert phase to a message suitable for conversation output (consistent with SKILL progress output)"""
    if phase == "outline":
        return "Generating outline..."
    if phase == "outline_page":
        # Outline page-by-page streaming output: show page number and content (newlines collapsed to spaces for single-line console display)
        page_num = data.get("page_num") or 0
        content = (data.get("content") or "").strip()
        if isinstance(content, str):
            content = " ".join(content.split())
        else:
            content = str(content) if content else ""
        if content:
            line = f"  Page {page_num}: {content[:300]}{'...' if len(content) > 300 else ''}"
            return line
        return f"  Page {page_num}: (no body text)"
    if phase == "outline_done":
        return "Outline generated successfully!"
    if phase == "slides":
        return "Generating slides..."
    if phase == "slides_page":
        page_num = data.get("page_num") or 0
        return f"Finish generating Page {page_num} "
    if phase == "slides_page_start":
        page_num = data.get("page_num") or 0
        content = " ".join((data.get("content") or "").split())
        snippet = content[:200] + ("..." if len(content) > 200 else "")
        return f"Start generating page {page_num},content: \n{snippet}" if snippet else f"Start generating page {page_num}"
    if phase == "slides_done":
        return "Slides generated, exporting PPTX..."
    if phase == "export":
        status = data.get("status", "")
        if status == "done":
            return "Export complete."
        return "Exporting PPTX... this step takes 2-5 minutes. KEEP reading this log every 5 seconds — do NOT stop polling until you see [DONE] or [ERROR]."
    if phase == "done":
        return "Generation complete, saving file..."
    if phase == "ping":
        progress = data.get("progress", "")
        stage = data.get("stage", "")
        return f"Now {progress}% was done, and is working on {stage}" if stage else f"{progress}%"
    # --- Update/Edit PPT specific phases ---
    if phase == "parse_pptx":
        status = data.get("status", "")
        if status == "start":
            return "Parsing existing PPTX..."
        if status == "done":
            count = data.get("original_pptx_slide_count", "")
            return f"PPTX parsed, {count} slides total."
        return ""
    if phase == "gen_update_plan":
        status = data.get("status", "")
        if status == "start":
            return "Generating update plan..."
        if status == "done":
            update_count = data.get("update_pptx_slide_count", "")
            new_count = data.get("new_slide_count", 0)
            return f"Update plan ready: {update_count} slides to update, {new_count} new slides to generate."
        return ""
    if phase == "gen_new_slides":
        status = data.get("status", "")
        if status == "start":
            return "Generating updated slides..."
        if status == "done":
            count = data.get("generated_new_slide_count", "")
            return f"Updated slides generated ({count} slides)."
        page_num = data.get("page_num")
        if page_num is not None:
            return f"Slide {page_num} updated."
        return ""
    if phase == "export_update_pptx":
        status = data.get("status", "")
        if status == "start":
            return "Exporting updated PPTX..."
        if status == "done":
            count = data.get("generated_update_pptx_slide_count", "")
            return f"Export complete, {count} slides."
        return ""
    # --- Template-based generation specific phases ---
    if phase == "parse_template":
        status = data.get("status", "")
        if status == "start":
            return "Parsing template..."
        if status == "done":
            slide_count = data.get("slide_count", "")
            return f"Template parsing complete, {slide_count} pages in total."
        return ""
    if phase == "gen_outline":
        status = data.get("status", "")
        if status == "start":
            return "Generating outline..."
        if status == "done":
            page_count = data.get("page_count", "")
            return f"Outline generated, {page_count} pages in total."
        return ""
    if phase == "assign_templates":
        status = data.get("status", "")
        page_count = data.get("page_count", "")
        if status == "start":
            return "Assigning templates to each page..."
        if status == "done":
            return f"Template assignment complete, {page_count} pages in total."
        return ""
    if phase == "fill_content":
        status = data.get("status", "")
        page_count = data.get("page_count", "")
        if status == "start":
            return "Filling in content..."
        if status == "done":
            return f"Content filled, {page_count} pages in total."
        return ""
    if phase == "gen_images":
        status = data.get("status", "")
        if status == "start":
            return "Generating images..."
        if status == "done":
            return "Image generation complete."
        return ""
    if phase == "slide_image":
        page_num = data.get("page_num", "")
        return f"Page {page_num} image generated."
    if phase == "convert_html":
        status = data.get("status", "")
        if status == "start":
            return "Converting HTML..."
        if status == "done":
            page_count = data.get("page_count", "")
            return f"HTML conversion complete, {page_count} pages in total."
        return ""
    if phase:
        return f"[{phase}]"
    return "..."


def parse_sse_stream(resp):
    """Parse SSE stream, yield (event_type, data_dict).
    The backend SendEventData wraps data as {"code":0,"message":"success","data": payload}; the data field needs to be extracted.
    """
    cur_event = None
    cur_data = None
    for line in resp:
        line = line.decode("utf-8", errors="replace").rstrip("\r\n")
        if line == "":
            if cur_event is not None and cur_data is not None:
                try:
                    raw = json.loads(cur_data) if cur_data else {}
                except json.JSONDecodeError:
                    raw = {}
                # Compatible with backend wrapper format: {"code":0,"message":"success","data": {...}}; data may also be a JSON string
                data = raw.get("data", raw) if isinstance(raw, dict) else raw
                if isinstance(data, str):
                    try:
                        data = json.loads(data)
                    except json.JSONDecodeError:
                        data = {}
                if not isinstance(data, dict):
                    data = {}
                yield cur_event, data
            cur_event = None
            cur_data = None
            continue
        if line.startswith("event:"):
            cur_event = line[6:].strip()
        elif line.startswith("data:"):
            cur_data = line[5:].strip()
    if cur_event is not None and cur_data is not None:
        try:
            raw = json.loads(cur_data) if cur_data else {}
        except json.JSONDecodeError:
            raw = {}
        data = raw.get("data", raw) if isinstance(raw, dict) else raw
        if isinstance(data, str):
            try:
                data = json.loads(data)
            except json.JSONDecodeError:
                data = {}
        if not isinstance(data, dict):
            data = {}
        yield cur_event, data


def main():
    parser = argparse.ArgumentParser(description="Call ppt_write stream API and save .pptx")
    parser.add_argument("query", nargs="?", default="", help="User query / PPT topic")
    parser.add_argument("--language", default="en", help="Language used to generate slides. e.g. English, Chinese, etc.")
    parser.add_argument("--reference", default="", help="Reference content for enriching slide content, e.g. web search results summary.")
    parser.add_argument("--reference-file", default="", dest="reference_file", help="Path to a local file whose content will be used as reference (preferred over --reference to avoid shell encoding issues).")
    parser.add_argument("-o", "--output", default="output.pptx", help="Output .pptx path")
    parser.add_argument("--session_id", default=str(uuid.uuid4()), help="session_id used for distinct ppt generate query")
    parser.add_argument("--template_urls", default="", help="Comma-separated list of template PPTX OSS URLs for style imitation")
    parser.add_argument("--files", default="", help='Reference files JSON from upload_files.py UPLOADED_FILES output, format: [{"filename":"a.pdf","url":"https://..."}]')
    parser.add_argument("--pptx-url", default="", dest="pptx_url", help="OSS URL of an existing PPTX to edit (triggers update/edit mode instead of generation).")
    parser.add_argument("--log_path", default="", dest="log_path", help="A file path to save the progress log.")
    args = parser.parse_args()
    query = args.query.strip()
    if not query:
        parser.error("query is required")
        return

    base_url = get_base_url()
    payload = {"query": query, "language": args.language}

    session_id = args.session_id.replace('-', '_')
    log_file = f"/tmp/ppt_run_{session_id}.log" if args.log_path == "" else args.log_path
    open(log_file, "w").close()  # clear previous run
    print(f"[LOG-File]: {log_file}", flush=True)

    # Determine endpoint and mode
    if args.pptx_url:
        url = f"{base_url}/update_pptx_process"
        payload["pptx_url"] = args.pptx_url
        mode = "editing"
    elif args.template_urls:
        url = f"{base_url}/chat_pptx_process"
        payload["template_urls"] = [u.strip() for u in args.template_urls.split(",") if u.strip()]
        mode = "imitation"
    else:
        url = f"{base_url}/ppt_write_stream"
        mode = "generating"

    print(f"[PID] {os.getpid()}", flush=True)
    print(f"[START] mode={mode} session={session_id} \nIS about to take 5-10minutes, please wait and check the process log every 5 seconds!", flush=True)
    write_log(log_file, f"[PID] {os.getpid()}")
    write_log(log_file, f"[START] mode={mode} session={session_id} \nIS about to take 5-10minutes, please wait and check the process log every 5 seconds!")

    reference = args.reference
    if args.reference_file:
        try:
            with open(args.reference_file, "r", encoding="utf-8") as f:
                reference = f.read()
        except Exception as e:
            print(f"[error] Failed to read reference file: {e}", file=sys.stderr)
            sys.exit(1)
    if reference:
        payload["reference"] = reference
    if args.files:
        try:
            payload["files"] = json.loads(args.files)
        except json.JSONDecodeError as e:
            print(f"--files JSON parse error: {e}", file=sys.stderr)
            sys.exit(1)
    payload["source_platform"] = "skyclaw" if POD_TYPE == "skyclaw" else ""
    body = json.dumps(payload).encode("utf-8")
    headers = {
        "Content-Type": "application/json",
        "Accept": "text/event-stream",
        "Session-Id": session_id,
        "Language": args.language,
    }
    api_key = get_skywork_api_key()
    if not api_key:
        print("[error] SKYWORK_API_KEY is required", file=sys.stderr)
        sys.exit(1)
    headers["Authorization"] = f"Bearer {api_key}"

    req = urllib.request.Request(
        url,
        data=body,
        method="POST",
        headers=headers,
    )

    out_abs = os.path.abspath(args.output)
    try:
        with urllib.request.urlopen(req, timeout=600) as resp:
            for event_type, data in parse_sse_stream(resp):
                if not isinstance(data, dict):
                    data = {}
                if event_type == "phase":
                    phase = data.get("phase", "")
                    msg = phase_to_message(phase, data)
                    if msg:
                        tag = "[PROGRESS]" if phase == "ping" else "[PHASE]"
                        write_log(log_file, f"{tag} {msg}")
                    if phase == "outline_done":
                        outline = data.get("outline", "")
                        if outline:
                            write_log(log_file, f"[OUTLINE]\n{outline}")
                elif event_type == "completionEvent":
                    phase = data.get("phase", "")
                    if phase == "done":
                        download_url = data.get("download_url")
                        write_log(log_file, "[PHASE] Generation complete, saving file to local disk. This may take 1 or 2 minutes, we are already success!")
                        if not download_url:
                            write_log(log_file, "[ERROR] No download_url in completionEvent")
                            sys.exit(1)
                        try:
                            req2 = urllib.request.Request(download_url, method="GET")
                            with urllib.request.urlopen(req2, timeout=120) as r:
                                with open(out_abs, "wb") as f:
                                    f.write(r.read())
                            write_log(log_file, f"[DONE] saved={out_abs} download_url={download_url}")
                        except Exception as e:
                            write_log(log_file, f"[ERROR] Download failed: {e}")
                            sys.exit(1)
                elif event_type == "error":
                    err_msg = data.get("message", str(data))
                    write_log(log_file, f"[ERROR] {err_msg}")
                    sys.exit(1)
    except urllib.error.HTTPError as e:
        body = e.read().decode("utf-8", errors="replace")
        write_log(log_file, f"[ERROR] HTTP {e.code}: {body}")
        sys.exit(1)
    except Exception as e:
        write_log(log_file, f"[ERROR] {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()

import os
from typing import Optional


def get_skywork_api_key() -> Optional[str]:
    """
    Returns skywork api key.
    """
    api_key = os.environ.get("SKYWORK_API_KEY", "")
    if not api_key:
        print("SKYWORK_API_KEY is not set.")
        return None
    return api_key

#!/usr/bin/env python3
"""
Upload local files to OSS by calling the /upload_oss endpoint.

Usage:
  python upload_files.py file1.png file2.jpg
  python upload_files.py file1.png --path skills/images/
"""
import argparse
import io
import json
import mimetypes
import os
import sys
import urllib.request
import urllib.error
import uuid

from pptx import api


from constant import SKYWORK_GATEWAY_URL

from skywork_auth import get_skywork_api_key


def build_multipart(fields: dict, files: dict) -> tuple[bytes, str]:
    """Build a multipart/form-data request body, returns (body_bytes, content_type).

    fields: {"field_name": "value", ...}
    files:  {"field_name": (filename, file_bytes, mime_type), ...}
    """
    boundary = uuid.uuid4().hex
    parts = []

    for name, value in fields.items():
        parts.append(
            f'--{boundary}\r\n'
            f'Content-Disposition: form-data; name="{name}"\r\n\r\n'
            f'{value}\r\n'
        )

    for name, (filename, data, mime) in files.items():
        parts.append(
            f'--{boundary}\r\n'
            f'Content-Disposition: form-data; name="{name}"; filename="{filename}"\r\n'
            f'Content-Type: {mime}\r\n\r\n'
        )
        if isinstance(data, str):
            data = data.encode()
        parts_bytes = b''.join(
            p.encode() if isinstance(p, str) else p for p in parts
        ) + data + b'\r\n'
        parts = [parts_bytes]

    body = b''.join(p.encode() if isinstance(p, str) else p for p in parts)
    body += f'--{boundary}--\r\n'.encode()
    content_type = f'multipart/form-data; boundary={boundary}'
    return body, content_type


def upload_file(local_path: str, oss_prefix: str | None, base_url: str, api_key: str = None) -> str:
    """Upload a single local file and return the OSS URL. Raises an exception on failure."""
    if not os.path.isfile(local_path):
        raise FileNotFoundError(f"File not found: {local_path}")

    filename = os.path.basename(local_path)
    mime = mimetypes.guess_type(filename)[0] or "application/octet-stream"

    with open(local_path, "rb") as f:
        file_bytes = f.read()

    fields = {}
    if oss_prefix:
        fields["path"] = oss_prefix

    body, content_type = build_multipart(
        fields=fields,
        files={"file": (filename, file_bytes, mime)},
    )

    url = base_url.rstrip("/") + "/upload_oss"
    headers = {
        "Content-Type": content_type,
    }
    if api_key:
        headers["Authorization"] = f"Bearer {api_key}"
    req = urllib.request.Request(
        url,
        data=body,
        method="POST",
        headers=headers,
    )

    with urllib.request.urlopen(req, timeout=60) as resp:
        raw = resp.read().decode("utf-8", errors="replace")

    result = json.loads(raw)
    code = result.get("code")
    if code != 200:
        raise RuntimeError(f"Upload failed code={code} msg={result.get('msg')}")

    return result["url"]


def upload_files(local_paths: list[str], oss_prefix: str | None = None, base_url: str = SKYWORK_GATEWAY_URL, api_key: str = None) -> list[dict]:
    """Upload a batch of local files and return a list of results for each file.

    Return format:
        [{"path": "/local/file.png", "url": "https://cdn.../xxx.png", "ok": True}, ...]
        On failure, url is empty, ok is False, and an error field is included.
    """
    results = []
    for path in local_paths:
        try:
            url = upload_file(path, oss_prefix, base_url, api_key)
            filename = os.path.basename(path)
            print(f"[OK] {path} -> {url}", flush=True)
            results.append({"path": path, "filename": filename, "url": url, "ok": True})
        except Exception as e:
            print(f"[FAIL] {path}: {e}", file=sys.stderr, flush=True)
            results.append({"path": path, "filename": os.path.basename(path), "url": "", "ok": False, "error": str(e)})
    # Print machine-readable summary for downstream parsing
    uploaded = [{"filename": r["filename"], "url": r["url"]} for r in results if r["ok"]]
    if uploaded:
        print(f"UPLOADED_FILES: {json.dumps(uploaded, ensure_ascii=False)}", flush=True)
    return results


def main():
    parser = argparse.ArgumentParser(description="Batch upload local files to OSS")
    parser.add_argument("files", nargs="+", help="List of local file paths")
    args = parser.parse_args()

    api_key = get_skywork_api_key()
    if not api_key:
        print("[error] SKYWORK_API_KEY is required", file=sys.stderr)
        sys.exit(1)

    results = upload_files(args.files, oss_prefix='', api_key=api_key)

    failed = [r for r in results if not r["ok"]]
    if failed:
        print(f"\n{len(failed)}/{len(results)} file(s) failed to upload", file=sys.stderr)
        sys.exit(1)
    else:
        print(f"\nAll {len(results)} file(s) uploaded successfully")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
web_search.py - Call local web search API and print results.

Usage:
    python web_search.py "query1" ["query2" ...]
"""

import argparse
import json
import os
import sys
import tempfile
import urllib.request

from constant import SKYWORK_GATEWAY_URL, POD_TYPE
from skywork_auth import get_skywork_api_key

def search(query: str, api_key: str) -> str:
    """Call web_search API and return formatted text of results."""
    url = f"{SKYWORK_GATEWAY_URL}/web_search"
    payload = {"query": query, "source_platform": "skyclaw" if POD_TYPE == "skyclaw" else ""}
    body = json.dumps(payload).encode("utf-8")
    headers = {"Content-Type": "application/json"}
    if api_key:
        headers["Authorization"] = f"Bearer {api_key}"
    req = urllib.request.Request(
        url,
        data=body,
        method="POST",
        headers=headers,
    )
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            raw = resp.read().decode("utf-8")
    except urllib.error.URLError as e:
        print(f"[ERROR] Error call web_search, try only 1 time more: {e}", file=sys.stderr)
        sys.exit(1)

    try:
        data = json.loads(raw)
    except json.JSONDecodeError:
        return raw  # fallback: return raw if not JSON

    results = data.get("search_res", [])
    if not results:
        return "(no results)"

    lines = []
    for i, item in enumerate(results, 1):
        content = (item.get("content") or "").strip()
        source_url = item.get("url", "")
        lines.append(f"[result-{i}] {source_url}\n{content}")
    return "\n\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Call local web_search API")
    parser.add_argument("queries", nargs="+", help="One or more search queries (max 3)")
    args = parser.parse_args()

    queries = args.queries[:3]
    out_dir = tempfile.mkdtemp(prefix="web_search_")

    api_key = get_skywork_api_key()
    if not api_key:
        print("[error] SKYWORK_API_KEY is required", file=sys.stderr)
        sys.exit(1)

    for i, q in enumerate(queries, 1):
        print(f"[query] {q} ...", file=sys.stderr, flush=True)
        raw = search(q, api_key)
        out_path = os.path.join(out_dir, f"{q}_result.txt")
        with open(out_path, "w", encoding="utf-8") as f:
            f.write(f"query: {q}\n\n{raw}")
            print(f'Already saved search result for query[{q}], \nout_path: {out_path}', flush=True)


if __name__ == "__main__":
    main()