@laitszkin/apollo-toolkit 3.13.2 → 3.14.1

package/openai-text-to-image-storyboard/tests/test_generate_storyboard_images.py

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import json
-import random
-import string
-import tempfile
-import types
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-PIL_AVAILABLE = importlib.util.find_spec("PIL") is not None
-
-if PIL_AVAILABLE:
-    from PIL import Image
-    SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "generate_storyboard_images.py"
-    SPEC = importlib.util.spec_from_file_location("generate_storyboard_images", SCRIPT_PATH)
-    MODULE = importlib.util.module_from_spec(SPEC)
-    SPEC.loader.exec_module(MODULE)
-else:
-    Image = None
-    MODULE = None
-
-
-def png_bytes(width: int, height: int, color: tuple[int, int, int] = (64, 128, 255)) -> bytes:
-    buffer = io.BytesIO()
-    Image.new("RGB", (width, height), color).save(buffer, format="PNG")
-    return buffer.getvalue()
-
-
-@unittest.skipUnless(PIL_AVAILABLE, "Pillow is required for storyboard image tests")
-class GenerateStoryboardImagesTests(unittest.TestCase):
-    def test_sanitize_component_property_removes_invalid_path_characters(self) -> None:
-        generator = random.Random(20260418)
-        alphabet = string.ascii_letters + string.digits + string.punctuation + " \t中文"
-
-        for _ in range(200):
-            raw = "".join(generator.choice(alphabet) for _ in range(generator.randint(0, 30)))
-            sanitized = MODULE.sanitize_component(raw, "fallback")
-            with self.subTest(raw=raw, sanitized=sanitized):
-                self.assertTrue(sanitized)
-                self.assertNotRegex(sanitized, MODULE.INVALID_PATH_CHARS)
-                self.assertNotIn(" ", sanitized)
-
-    def test_parse_image_dimensions_supports_png_and_jpeg(self) -> None:
-        png = png_bytes(320, 180)
-        self.assertEqual(MODULE.parse_image_dimensions(png), (320, 180))
-
-        buffer = io.BytesIO()
-        Image.new("RGB", (160, 90), (0, 0, 0)).save(buffer, format="JPEG")
-        self.assertEqual(MODULE.parse_image_dimensions(buffer.getvalue()), (160, 90))
-
-    def test_parse_prompts_file_supports_structured_scene_mode(self) -> None:
-        payload = {
-            "characters": [
-                {
-                    "id": "hero",
-                    "name": "Kai",
-                    "appearance": "short black hair",
-                    "outfit": "blue jacket",
-                    "description": "determined teenage inventor",
-                }
-            ],
-            "scenes": [
-                {
-                    "title": "Workshop",
-                    "description": "Kai repairs a flickering lantern inside a cramped workshop.",
-                    "character_ids": ["hero"],
-                    "character_descriptions": {"hero": "focused and covered with grease"},
-                    "camera": "medium shot",
-                }
-            ],
-        }
-
-        with tempfile.TemporaryDirectory() as temp_dir:
-            prompts_file = Path(temp_dir) / "prompts.json"
-            prompts_file.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
-            items = MODULE.parse_prompts_file(prompts_file)
-
-        self.assertEqual(len(items), 1)
-        self.assertEqual(items[0]["title"], "Workshop")
-        prompt_payload = json.loads(items[0]["prompt"])
-        self.assertEqual(prompt_payload["characters"][0]["description"], "focused and covered with grease")
-        self.assertEqual(prompt_payload["camera"], "medium shot")
-
-    def test_build_scene_json_prompt_rejects_unknown_override_character(self) -> None:
-        scene = {
-            "title": "Workshop",
-            "description": "Lantern repair",
-            "character_ids": ["hero"],
-            "character_descriptions": {"ghost": "not listed"},
-        }
-
-        with self.assertRaises(SystemExit) as context:
-            MODULE.build_scene_json_prompt(
-                scene=scene,
-                scene_index=1,
-                prompts_file=Path("prompts.json"),
-                character_profiles={
-                    "hero": {
-                        "id": "hero",
-                        "name": "Kai",
-                        "appearance": "short black hair",
-                        "outfit": "blue jacket",
-                        "description": "determined teenage inventor",
-                    }
-                },
-            )
-
-        self.assertIn("ids not listed in character_ids", str(context.exception))
-
-    def test_generate_image_supports_b64_payload(self) -> None:
-        raw = png_bytes(100, 60)
-
-        with patch.object(
-            MODULE,
-            "post_json",
-            return_value={"data": [{"b64_json": MODULE.base64.b64encode(raw).decode("ascii"), "revised_prompt": "ok"}]},
-        ):
-            image_bytes, revised_prompt = MODULE.generate_image(
-                base_url="https://example.com",
-                api_key="token",
-                image_model="gpt-image-1",
-                prompt="scene",
-                aspect_ratio=None,
-                image_size=None,
-                quality=None,
-                style=None,
-            )
-
-        self.assertEqual(image_bytes, raw)
-        self.assertEqual(revised_prompt, "ok")
-
-    def test_main_generates_cropped_images_and_summary(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            project_dir = Path(temp_dir)
-            args = types.SimpleNamespace(
-                content_name="Lantern / Story",
-                project_dir=str(project_dir),
-                env_file=str(project_dir / ".env"),
-                api_url="https://example.com",
-                api_key="token",
-                prompts_file=None,
-                prompt=["Lantern workshop at dusk"],
-                image_model="gpt-image-1",
-                aspect_ratio="1:1",
-                image_size=None,
-                quality=None,
-                style=None,
-            )
-
-            with patch.object(MODULE, "parse_args", return_value=args), patch.object(
-                MODULE, "load_dotenv_file", return_value=False
-            ), patch.object(
-                MODULE,
-                "generate_image",
-                return_value=(png_bytes(200, 100), "Lantern workshop at dusk, improved"),
-            ):
-                exit_code = MODULE.main()
-
-            self.assertEqual(exit_code, 0)
-            output_dir = project_dir / "pictures" / "Lantern_Story"
-            summary = json.loads((output_dir / "storyboard.json").read_text(encoding="utf-8"))
-            self.assertEqual(summary["aspect_ratio"], "1:1")
-            self.assertEqual(summary["images"][0]["width"], 100)
-            self.assertEqual(summary["images"][0]["height"], 100)
-            self.assertEqual(summary["images"][0]["source_width"], 200)
-            self.assertEqual(summary["images"][0]["source_height"], 100)
-            self.assertEqual(summary["images"][0]["revised_prompt"], "Lantern workshop at dusk, improved")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/read-github-issue/scripts/find_issues.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import json
-import subprocess
-import sys
-from typing import Any
-
-ISSUE_FIELDS = "number,title,state,updatedAt,url,labels,assignees"
-
-
-def positive_int(raw: str) -> int:
-    value = int(raw)
-    if value <= 0:
-        raise argparse.ArgumentTypeError("limit must be a positive integer")
-    return value
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Find remote GitHub issues with gh CLI and display table or JSON output."
-    )
-    parser.add_argument("--repo", help="Target repository in owner/name format.")
-    parser.add_argument("--state", default="open", choices=["open", "closed", "all"])
-    parser.add_argument("--limit", type=positive_int, default=50)
-    parser.add_argument(
-        "--label",
-        action="append",
-        default=[],
-        help="Label filter (repeat for multiple labels).",
-    )
-    parser.add_argument("--search", help="Search query for issue list filtering.")
-    parser.add_argument(
-        "--output",
-        choices=["table", "json"],
-        default="table",
-        help="Output format.",
-    )
-    return parser.parse_args()
-
-
-def build_command(args: argparse.Namespace) -> list[str]:
-    cmd = [
-        "gh",
-        "issue",
-        "list",
-        "--state",
-        args.state,
-        "--limit",
-        str(args.limit),
-        "--json",
-        ISSUE_FIELDS,
-    ]
-
-    if args.repo:
-        cmd.extend(["--repo", args.repo])
-    for label in args.label:
-        cmd.extend(["--label", label])
-    if args.search:
-        cmd.extend(["--search", args.search])
-
-    return cmd
-
-
-def truncate(text: str, width: int) -> str:
-    if len(text) <= width:
-        return text
-    if width <= 3:
-        return text[:width]
-    return text[: width - 3] + "..."
-
-
-def format_labels(issue: dict[str, Any]) -> str:
-    labels = issue.get("labels", [])
-    names = [item.get("name", "") for item in labels if item.get("name")]
-    return ",".join(names)
-
-
-def format_assignees(issue: dict[str, Any]) -> str:
-    assignees = issue.get("assignees", [])
-    logins = [item.get("login", "") for item in assignees if item.get("login")]
-    return ",".join(logins) if logins else "-"
-
-
-def print_table(issues: list[dict[str, Any]]) -> None:
-    columns = {
-        "number": 7,
-        "title": 54,
-        "labels": 22,
-        "assignees": 18,
-        "updated": 20,
-    }
-
-    header = (
-        f"{'NUMBER':<{columns['number']}} "
-        f"{'TITLE':<{columns['title']}} "
-        f"{'LABELS':<{columns['labels']}} "
-        f"{'ASSIGNEES':<{columns['assignees']}} "
-        f"{'UPDATED':<{columns['updated']}}"
-    )
-    print(header)
-    print("-" * len(header))
-
-    for issue in issues:
-        number = f"#{issue.get('number', '')}"
-        title = truncate(str(issue.get("title", "")), columns["title"])
-        labels = truncate(format_labels(issue), columns["labels"])
-        assignees = truncate(format_assignees(issue), columns["assignees"])
-        updated = truncate(str(issue.get("updatedAt", "")), columns["updated"])
-
-        row = (
-            f"{number:<{columns['number']}} "
-            f"{title:<{columns['title']}} "
-            f"{labels:<{columns['labels']}} "
-            f"{assignees:<{columns['assignees']}} "
-            f"{updated:<{columns['updated']}}"
-        )
-        print(row)
-
-
-def main() -> int:
-    args = parse_args()
-    cmd = build_command(args)
-
-    try:
-        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
-    except FileNotFoundError:
-        print("Error: gh CLI is not installed or not in PATH.", file=sys.stderr)
-        return 1
-    except subprocess.CalledProcessError as exc:
-        print(exc.stderr.strip() or "gh issue list failed.", file=sys.stderr)
-        return exc.returncode
-
-    try:
-        issues = json.loads(result.stdout)
-    except json.JSONDecodeError:
-        print("Error: unable to parse gh output as JSON.", file=sys.stderr)
-        return 1
-
-    if args.output == "json":
-        print(json.dumps(issues, indent=2))
-        return 0
-
-    print_table(issues)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/read-github-issue/scripts/read_issue.py

@@ -1,108 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import subprocess
-import sys
-
-
-ISSUE_FIELDS = "number,title,body,state,author,labels,assignees,comments,createdAt,updatedAt,closedAt,url"
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Read a remote GitHub issue with gh CLI and display summary or JSON output."
-    )
-    parser.add_argument("issue", help="Issue number or URL.")
-    parser.add_argument("--repo", help="Target repository in owner/name format.")
-    parser.add_argument(
-        "--comments",
-        action="store_true",
-        help="Keep issue comments in formatted output.",
-    )
-    parser.add_argument(
-        "--json",
-        action="store_true",
-        help="Print raw JSON output.",
-    )
-    return parser.parse_args()
-
-
-def build_command(args: argparse.Namespace) -> list[str]:
-    cmd = [
-        "gh",
-        "issue",
-        "view",
-        args.issue,
-        "--json",
-        ISSUE_FIELDS,
-    ]
-    if args.repo:
-        cmd.extend(["--repo", args.repo])
-    return cmd
-
-
-def join_names(items: list[dict], key: str) -> str:
-    values = [item.get(key, "") for item in items if item.get(key)]
-    return ", ".join(values) if values else "-"
-
-
-def print_summary(issue: dict, include_comments: bool) -> None:
-    print(f"Number: #{issue.get('number', '')}")
-    print(f"Title: {issue.get('title', '')}")
-    print(f"State: {issue.get('state', '')}")
-    print(f"URL: {issue.get('url', '')}")
-    print(f"Author: {(issue.get('author') or {}).get('login', '-')}")
-    print(f"Labels: {join_names(issue.get('labels', []), 'name')}")
-    print(f"Assignees: {join_names(issue.get('assignees', []), 'login')}")
-    print(f"Created: {issue.get('createdAt', '')}")
-    print(f"Updated: {issue.get('updatedAt', '')}")
-    print(f"Closed: {issue.get('closedAt', '') or '-'}")
-    print("")
-    print("Body:")
-    print(issue.get("body", "") or "-")
-
-    if include_comments:
-        comments = issue.get("comments", [])
-        print("")
-        print(f"Comments ({len(comments)}):")
-        if not comments:
-            print("-")
-            return
-        for comment in comments:
-            author = (comment.get("author") or {}).get("login", "-")
-            created = comment.get("createdAt", "")
-            body = comment.get("body", "") or "-"
-            print(f"- [{created}] {author}: {body}")
-
-
-def main() -> int:
-    args = parse_args()
-    cmd = build_command(args)
-
-    try:
-        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
-    except FileNotFoundError:
-        print("Error: gh CLI is not installed or not in PATH.", file=sys.stderr)
-        return 1
-    except subprocess.CalledProcessError as exc:
-        print(exc.stderr.strip() or "gh issue view failed.", file=sys.stderr)
-        return exc.returncode
-
-    try:
-        issue = json.loads(result.stdout)
-    except json.JSONDecodeError:
-        print("Error: unable to parse gh output as JSON.", file=sys.stderr)
-        return 1
-
-    if args.json:
-        print(json.dumps(issue, indent=2))
-        return 0
-
-    print_summary(issue, include_comments=args.comments)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/read-github-issue/tests/test_find_issues.py

@@ -1,127 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import argparse
-import importlib.util
-import io
-import json
-import unittest
-from argparse import Namespace
-from pathlib import Path
-from unittest.mock import patch
-
-
-SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "find_issues.py"
-SPEC = importlib.util.spec_from_file_location("find_issues", SCRIPT_PATH)
-MODULE = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(MODULE)
-
-
-class FindIssuesTests(unittest.TestCase):
-    def test_build_command_with_filters(self) -> None:
-        args = Namespace(
-            repo="owner/repo",
-            state="open",
-            limit=25,
-            label=["bug", "needs-triage"],
-            search="panic parser",
-            output="table",
-        )
-
-        cmd = MODULE.build_command(args)
-
-        self.assertEqual(
-            cmd,
-            [
-                "gh",
-                "issue",
-                "list",
-                "--state",
-                "open",
-                "--limit",
-                "25",
-                "--json",
-                MODULE.ISSUE_FIELDS,
-                "--repo",
-                "owner/repo",
-                "--label",
-                "bug",
-                "--label",
-                "needs-triage",
-                "--search",
-                "panic parser",
-            ],
-        )
-
-    def test_positive_int_rejects_zero(self) -> None:
-        with self.assertRaises(argparse.ArgumentTypeError):
-            MODULE.positive_int("0")
-
-    def test_truncate_handles_small_width(self) -> None:
-        self.assertEqual(MODULE.truncate("abcdef", 2), "ab")
-
-    def test_print_table_handles_missing_fields(self) -> None:
-        with patch("sys.stdout", new_callable=io.StringIO) as stdout:
-            MODULE.print_table([
-                {
-                    "number": 42,
-                    "title": "Fix formatter fallback",
-                }
-            ])
-
-        output = stdout.getvalue()
-        self.assertIn("NUMBER", output)
-        self.assertIn("#42", output)
-
-    def test_main_returns_error_when_gh_missing(self) -> None:
-        args = Namespace(
-            repo=None,
-            state="open",
-            limit=50,
-            label=[],
-            search=None,
-            output="table",
-        )
-
-        with patch.object(MODULE, "parse_args", return_value=args), patch(
-            "subprocess.run", side_effect=FileNotFoundError
-        ), patch("sys.stderr", new_callable=io.StringIO) as stderr:
-            code = MODULE.main()
-
-        self.assertEqual(code, 1)
-        self.assertIn("not in PATH", stderr.getvalue())
-
-    def test_main_json_output(self) -> None:
-        args = Namespace(
-            repo=None,
-            state="open",
-            limit=50,
-            label=[],
-            search=None,
-            output="json",
-        )
-        payload = [
-            {
-                "number": 1,
-                "title": "Fix bug",
-                "labels": [],
-                "assignees": [],
-                "updatedAt": "2026-02-26T00:00:00Z",
-            }
-        ]
-
-        class Result:
-            stdout = json.dumps(payload)
-
-        with patch.object(MODULE, "parse_args", return_value=args), patch(
-            "subprocess.run", return_value=Result()
-        ), patch("sys.stdout", new_callable=io.StringIO) as stdout:
-            code = MODULE.main()
-
-        self.assertEqual(code, 0)
-        self.assertEqual(json.loads(stdout.getvalue()), payload)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/read-github-issue/tests/test_read_issue.py

@@ -1,109 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import json
-import unittest
-from argparse import Namespace
-from pathlib import Path
-from unittest.mock import patch
-
-
-SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "read_issue.py"
-SPEC = importlib.util.spec_from_file_location("read_issue", SCRIPT_PATH)
-MODULE = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(MODULE)
-
-
-class ReadIssueTests(unittest.TestCase):
-    def test_build_command_with_repo(self) -> None:
-        args = Namespace(issue="123", repo="owner/repo", comments=False, json=False)
-
-        self.assertEqual(
-            MODULE.build_command(args),
-            [
-                "gh",
-                "issue",
-                "view",
-                "123",
-                "--json",
-                MODULE.ISSUE_FIELDS,
-                "--repo",
-                "owner/repo",
-            ],
-        )
-
-    def test_main_returns_error_when_gh_missing(self) -> None:
-        args = Namespace(issue="123", repo=None, comments=False, json=False)
-
-        with patch.object(MODULE, "parse_args", return_value=args), patch(
-            "subprocess.run", side_effect=FileNotFoundError
-        ), patch("sys.stderr", new_callable=io.StringIO) as stderr:
-            code = MODULE.main()
-
-        self.assertEqual(code, 1)
-        self.assertIn("not in PATH", stderr.getvalue())
-
-    def test_main_json_output(self) -> None:
-        args = Namespace(issue="123", repo=None, comments=False, json=True)
-        payload = {
-            "number": 123,
-            "title": "Need better retries",
-            "body": "detail",
-            "state": "OPEN",
-            "author": {"login": "octocat"},
-            "labels": [],
-            "assignees": [],
-            "comments": [],
-            "createdAt": "2026-03-24T00:00:00Z",
-            "updatedAt": "2026-03-24T01:00:00Z",
-            "closedAt": None,
-            "url": "https://github.com/owner/repo/issues/123",
-        }
-
-        class Result:
-            stdout = json.dumps(payload)
-
-        with patch.object(MODULE, "parse_args", return_value=args), patch(
-            "subprocess.run", return_value=Result()
-        ), patch("sys.stdout", new_callable=io.StringIO) as stdout:
-            code = MODULE.main()
-
-        self.assertEqual(code, 0)
-        self.assertEqual(json.loads(stdout.getvalue()), payload)
-
-    def test_print_summary_includes_comments(self) -> None:
-        issue = {
-            "number": 123,
-            "title": "Need better retries",
-            "body": "detail",
-            "state": "OPEN",
-            "author": {"login": "octocat"},
-            "labels": [{"name": "bug"}],
-            "assignees": [{"login": "alice"}],
-            "comments": [
-                {
-                    "author": {"login": "bob"},
-                    "createdAt": "2026-03-24T02:00:00Z",
-                    "body": "extra context",
-                }
-            ],
-            "createdAt": "2026-03-24T00:00:00Z",
-            "updatedAt": "2026-03-24T01:00:00Z",
-            "closedAt": None,
-            "url": "https://github.com/owner/repo/issues/123",
-        }
-
-        with patch("sys.stdout", new_callable=io.StringIO) as stdout:
-            MODULE.print_summary(issue, include_comments=True)
-
-        output = stdout.getvalue()
-        self.assertIn("#123", output)
-        self.assertIn("bug", output)
-        self.assertIn("extra context", output)
-
-
-if __name__ == "__main__":
-    unittest.main()