@laitszkin/apollo-toolkit 3.13.2 → 3.14.0

package/scripts/validate_skill_frontmatter.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python3
-"""Validate SKILL.md frontmatter for all top-level skills."""
-
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from pathlib import Path
-
-import yaml
-
-NAME_PATTERN = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
-REQUIRED_KEYS = {"name", "description"}
-MAX_DESCRIPTION_LENGTH = 1024
-
-HELP_EPILOG = """Examples:
-  apltk validate-skill-frontmatter
-    Result: prints either a pass summary or one error per invalid top-level SKILL.md frontmatter file.
-"""
-
-
-def repo_root() -> Path:
-    return Path(__file__).resolve().parent.parent
-
-
-def iter_skill_dirs(root: Path) -> list[Path]:
-    return sorted(path for path in root.iterdir() if path.is_dir() and (path / "SKILL.md").is_file())
-
-
-def extract_frontmatter(content: str) -> str:
-    lines = content.splitlines()
-    if not lines or lines[0].strip() != "---":
-        raise ValueError("SKILL.md must start with YAML frontmatter delimiter '---'.")
-
-    for index in range(1, len(lines)):
-        if lines[index].strip() == "---":
-            return "\n".join(lines[1:index])
-
-    raise ValueError("SKILL.md frontmatter is missing the closing '---' delimiter.")
-
-
-def validate_skill(skill_dir: Path) -> list[str]:
-    errors: list[str] = []
-    skill_md = skill_dir / "SKILL.md"
-
-    try:
-        content = skill_md.read_text(encoding="utf-8")
-    except OSError as exc:
-        return [f"{skill_md}: cannot read file ({exc})."]
-
-    try:
-        frontmatter_text = extract_frontmatter(content)
-    except ValueError as exc:
-        return [f"{skill_md}: {exc}"]
-
-    try:
-        frontmatter = yaml.safe_load(frontmatter_text)
-    except yaml.YAMLError as exc:
-        return [f"{skill_md}: invalid YAML in frontmatter ({exc})."]
-
-    if not isinstance(frontmatter, dict):
-        return [f"{skill_md}: frontmatter must be a YAML mapping."]
-
-    keys = set(frontmatter.keys())
-    if keys != REQUIRED_KEYS:
-        missing = sorted(REQUIRED_KEYS - keys)
-        extra = sorted(keys - REQUIRED_KEYS)
-        if missing:
-            errors.append(f"{skill_md}: missing required frontmatter keys: {', '.join(missing)}.")
-        if extra:
-            errors.append(f"{skill_md}: unsupported frontmatter keys: {', '.join(extra)}.")
-
-    name = frontmatter.get("name")
-    if not isinstance(name, str) or not name.strip():
-        errors.append(f"{skill_md}: 'name' must be a non-empty string.")
-    else:
-        normalized_name = name.strip()
-        if not NAME_PATTERN.fullmatch(normalized_name):
-            errors.append(
-                f"{skill_md}: 'name' must be kebab-case (lowercase letters, digits, and hyphens)."
-            )
-        if normalized_name != skill_dir.name:
-            errors.append(
-                f"{skill_md}: frontmatter name '{normalized_name}' must match folder name '{skill_dir.name}'."
-            )
-
-    description = frontmatter.get("description")
-    if not isinstance(description, str) or not description.strip():
-        errors.append(f"{skill_md}: 'description' must be a non-empty string.")
-    elif len(description) > MAX_DESCRIPTION_LENGTH:
-        errors.append(
-            f"{skill_md}: invalid description: exceeds maximum length of "
-            f"{MAX_DESCRIPTION_LENGTH} characters"
-        )
-
-    return errors
-
-
-def build_parser() -> argparse.ArgumentParser:
-    return argparse.ArgumentParser(
-        description="Validate SKILL.md frontmatter for all top-level skills.",
-        epilog=HELP_EPILOG,
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-
-
-def main(argv: list[str] | None = None) -> int:
-    build_parser().parse_args(argv)
-    root = repo_root()
-    skill_dirs = iter_skill_dirs(root)
-    if not skill_dirs:
-        print("No top-level skill directories found.")
-        return 1
-
-    all_errors: list[str] = []
-    for skill_dir in skill_dirs:
-        all_errors.extend(validate_skill(skill_dir))
-
-    if all_errors:
-        print("SKILL.md frontmatter validation failed:")
-        for error in all_errors:
-            print(f"- {error}")
-        return 1
-
-    print(f"SKILL.md frontmatter validation passed for {len(skill_dirs)} skills.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/text-to-short-video/scripts/enforce_video_aspect_ratio.py

@@ -1,350 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import re
-import shutil
-import subprocess
-import tempfile
-from pathlib import Path
-
-SKILL_DIR = Path(__file__).resolve().parent.parent
-DEFAULT_ENV_FILE = SKILL_DIR / ".env"
-SIZE_PATTERN = re.compile(r"^(\d{2,5})x(\d{2,5})$")
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description=(
-            "Enforce final video aspect ratio and size. "
-            "If input aspect ratio differs from target, center-crop then scale."
-        )
-    )
-    parser.add_argument("--input-video", required=True, help="Path to rendered input video.")
-    parser.add_argument(
-        "--output-video",
-        help=(
-            "Path to processed output video. If omitted, write next to input as "
-            "<name>_aspect_fixed.mp4."
-        ),
-    )
-    parser.add_argument(
-        "--in-place",
-        action="store_true",
-        help="Overwrite input file in place (uses a temporary file then replaces input).",
-    )
-    parser.add_argument(
-        "--target-size",
-        help="Target size in WIDTHxHEIGHT format, for example 1080x1920.",
-    )
-    parser.add_argument("--target-width", type=int, help="Target width in pixels.")
-    parser.add_argument("--target-height", type=int, help="Target height in pixels.")
-    parser.add_argument(
-        "--env-file",
-        default=str(DEFAULT_ENV_FILE),
-        help=f"Path to .env file (default: {DEFAULT_ENV_FILE}).",
-    )
-    parser.add_argument("--force", action="store_true", help="Overwrite output if it exists.")
-    parser.add_argument("--ffmpeg-bin", default="ffmpeg", help="ffmpeg executable name or path.")
-    parser.add_argument("--ffprobe-bin", default="ffprobe", help="ffprobe executable name or path.")
-    return parser.parse_args()
-
-
-def parse_dotenv_line(content: str, line_no: int, file_path: Path) -> tuple[str, str] | None:
-    stripped = content.strip()
-    if not stripped or stripped.startswith("#"):
-        return None
-    if stripped.startswith("export "):
-        stripped = stripped[7:].strip()
-
-    if "=" not in stripped:
-        raise SystemExit(f"Invalid .env format at {file_path}:{line_no}: missing =")
-
-    key, value = stripped.split("=", 1)
-    key = key.strip()
-    value = value.strip()
-
-    if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", key):
-        raise SystemExit(f"Invalid .env key at {file_path}:{line_no}: {key}")
-
-    if value and value[0] in {"'", '"'}:
-        quote = value[0]
-        if len(value) >= 2 and value[-1] == quote:
-            value = value[1:-1]
-    else:
-        value = value.split(" #", 1)[0].strip()
-
-    return key, value
-
-
-def load_dotenv_file(env_file: Path, override: bool = False) -> bool:
-    if not env_file.exists():
-        return False
-
-    for line_no, line in enumerate(env_file.read_text(encoding="utf-8").splitlines(), start=1):
-        parsed = parse_dotenv_line(line, line_no, env_file)
-        if not parsed:
-            continue
-        key, value = parsed
-        if override or key not in os.environ:
-            os.environ[key] = value
-    return True
-
-
-def parse_size(value: str) -> tuple[int, int]:
-    match = SIZE_PATTERN.fullmatch(value.strip().lower())
-    if not match:
-        raise SystemExit("Invalid size format. Use WIDTHxHEIGHT, for example 1080x1920.")
-    width = int(match.group(1))
-    height = int(match.group(2))
-    if width <= 0 or height <= 0:
-        raise SystemExit("Width and height must be positive integers.")
-    return width, height
-
-
-def required_command(command: str) -> None:
-    if shutil.which(command):
-        return
-    raise SystemExit(f"Missing required command: {command}")
-
-
-def probe_video_size(video_path: Path, ffprobe_bin: str) -> tuple[int, int]:
-    cmd = [
-        ffprobe_bin,
-        "-v",
-        "error",
-        "-select_streams",
-        "v:0",
-        "-show_entries",
-        "stream=width,height",
-        "-of",
-        "json",
-        str(video_path),
-    ]
-    try:
-        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
-    except subprocess.CalledProcessError as exc:
-        stderr = exc.stderr.strip()
-        raise SystemExit(f"ffprobe failed for {video_path}: {stderr}") from exc
-
-    try:
-        payload = json.loads(result.stdout)
-    except json.JSONDecodeError as exc:
-        raise SystemExit(f"Unable to parse ffprobe output for {video_path}.") from exc
-
-    streams = payload.get("streams")
-    if not isinstance(streams, list) or not streams:
-        raise SystemExit(f"No video stream found in {video_path}.")
-
-    first = streams[0]
-    if not isinstance(first, dict):
-        raise SystemExit(f"Unexpected ffprobe stream payload for {video_path}.")
-
-    width = first.get("width")
-    height = first.get("height")
-    if not isinstance(width, int) or not isinstance(height, int) or width <= 0 or height <= 0:
-        raise SystemExit(f"Invalid video dimensions from ffprobe for {video_path}.")
-    return width, height
-
-
-def even_floor(value: int, minimum: int = 2) -> int:
-    floored = value if value % 2 == 0 else value - 1
-    return max(floored, minimum)
-
-
-def build_video_filter(
-    input_width: int,
-    input_height: int,
-    target_width: int,
-    target_height: int,
-) -> tuple[str | None, bool]:
-    same_ratio = input_width * target_height == input_height * target_width
-    same_size = input_width == target_width and input_height == target_height
-
-    if same_ratio and same_size:
-        return None, False
-
-    if same_ratio:
-        return f"scale={target_width}:{target_height}", False
-
-    input_wider = input_width * target_height > input_height * target_width
-    if input_wider:
-        crop_width = input_height * target_width // target_height
-        crop_height = input_height
-    else:
-        crop_width = input_width
-        crop_height = input_width * target_height // target_width
-
-    crop_width = min(even_floor(crop_width), even_floor(input_width))
-    crop_height = min(even_floor(crop_height), even_floor(input_height))
-
-    offset_x = max((input_width - crop_width) // 2, 0)
-    offset_y = max((input_height - crop_height) // 2, 0)
-
-    return f"crop={crop_width}:{crop_height}:{offset_x}:{offset_y},scale={target_width}:{target_height}", True
-
-
-def resolve_target_size(args: argparse.Namespace) -> tuple[int, int]:
-    if args.target_size and (args.target_width is not None or args.target_height is not None):
-        raise SystemExit("Use either --target-size or --target-width/--target-height, not both.")
-
-    if args.target_size:
-        return parse_size(args.target_size)
-
-    env_width = os.getenv("TEXT_TO_SHORT_VIDEO_WIDTH", "").strip()
-    env_height = os.getenv("TEXT_TO_SHORT_VIDEO_HEIGHT", "").strip()
-
-    if args.target_width is not None:
-        width = args.target_width
-    else:
-        try:
-            width = int(env_width or "1080")
-        except ValueError as exc:
-            raise SystemExit("TEXT_TO_SHORT_VIDEO_WIDTH must be an integer.") from exc
-
-    if args.target_height is not None:
-        height = args.target_height
-    else:
-        try:
-            height = int(env_height or "1920")
-        except ValueError as exc:
-            raise SystemExit("TEXT_TO_SHORT_VIDEO_HEIGHT must be an integer.") from exc
-
-    if width <= 0 or height <= 0:
-        raise SystemExit("Target width and height must be positive integers.")
-    return width, height
-
-
-def resolve_output_path(args: argparse.Namespace, input_video: Path) -> Path:
-    if args.in_place and args.output_video:
-        raise SystemExit("Do not pass --output-video with --in-place.")
-
-    if args.in_place:
-        return input_video
-
-    if args.output_video:
-        output_video = Path(args.output_video).expanduser().resolve()
-    else:
-        output_video = input_video.with_name(f"{input_video.stem}_aspect_fixed.mp4")
-
-    if output_video == input_video:
-        raise SystemExit("Output path equals input path. Use --in-place to replace the input file.")
-
-    return output_video
-
-
-def copy_if_needed(source: Path, target: Path, force: bool) -> None:
-    if source == target:
-        return
-    if target.exists() and not force:
-        raise SystemExit(f"Output already exists: {target}. Use --force to overwrite.")
-    target.parent.mkdir(parents=True, exist_ok=True)
-    shutil.copy2(source, target)
-
-
-def main() -> int:
-    args = parse_args()
-
-    input_video = Path(args.input_video).expanduser().resolve()
-    if not input_video.is_file():
-        raise SystemExit(f"Input video not found: {input_video}")
-
-    env_file = Path(args.env_file).expanduser()
-    if not env_file.is_absolute():
-        env_file = SKILL_DIR / env_file
-    load_dotenv_file(env_file, override=False)
-
-    target_width, target_height = resolve_target_size(args)
-    output_video = resolve_output_path(args, input_video)
-
-    required_command(args.ffmpeg_bin)
-    required_command(args.ffprobe_bin)
-
-    input_width, input_height = probe_video_size(input_video, args.ffprobe_bin)
-    filter_expression, crop_applied = build_video_filter(
-        input_width=input_width,
-        input_height=input_height,
-        target_width=target_width,
-        target_height=target_height,
-    )
-
-    if filter_expression is None:
-        print(
-            f"[INFO] Video already matches target size and aspect ratio: "
-            f"{input_width}x{input_height}."
-        )
-        copy_if_needed(input_video, output_video, args.force)
-        if input_video != output_video:
-            print(f"[OK] Copied original video to: {output_video}")
-        return 0
-
-    replace_in_place = args.in_place
-    if replace_in_place:
-        temp_fd, temp_name = tempfile.mkstemp(
-            prefix=f"{input_video.stem}_aspect_tmp_",
-            suffix=".mp4",
-            dir=str(input_video.parent),
-        )
-        os.close(temp_fd)
-        temp_output = Path(temp_name)
-    else:
-        temp_output = output_video
-        if temp_output.exists() and not args.force:
-            raise SystemExit(f"Output already exists: {temp_output}. Use --force to overwrite.")
-        temp_output.parent.mkdir(parents=True, exist_ok=True)
-
-    ffmpeg_cmd = [
-        args.ffmpeg_bin,
-        "-hide_banner",
-        "-loglevel",
-        "error",
-        "-y" if (args.force or replace_in_place) else "-n",
-        "-i",
-        str(input_video),
-        "-vf",
-        filter_expression,
-        "-map",
-        "0:v:0",
-        "-map",
-        "0:a?",
-        "-c:v",
-        "libx264",
-        "-preset",
-        "medium",
-        "-crf",
-        "18",
-        "-c:a",
-        "aac",
-        "-movflags",
-        "+faststart",
-        str(temp_output),
-    ]
-
-    try:
-        subprocess.run(ffmpeg_cmd, check=True)
-    except subprocess.CalledProcessError as exc:
-        if replace_in_place and temp_output.exists():
-            temp_output.unlink(missing_ok=True)
-        raise SystemExit(f"ffmpeg failed with exit code {exc.returncode}.") from exc
-
-    if replace_in_place:
-        temp_output.replace(input_video)
-        final_output = input_video
-    else:
-        final_output = output_video
-
-    final_width, final_height = probe_video_size(final_output, args.ffprobe_bin)
-    print(
-        f"[OK] Processed video written: {final_output}\n"
-        f"[INFO] Input size: {input_width}x{input_height}\n"
-        f"[INFO] Target size: {target_width}x{target_height}\n"
-        f"[INFO] Output size: {final_width}x{final_height}\n"
-        f"[INFO] Center crop applied: {'yes' if crop_applied else 'no'}"
-    )
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/text-to-short-video/tests/test_enforce_video_aspect_ratio.py

@@ -1,194 +0,0 @@
-#!/usr/bin/env python3
-
-from __future__ import annotations
-
-import importlib.util
-import io
-import json
-import os
-import random
-import re
-import tempfile
-import types
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-
-SCRIPT_PATH = Path(__file__).resolve().parents[1] / "scripts" / "enforce_video_aspect_ratio.py"
-SPEC = importlib.util.spec_from_file_location("enforce_video_aspect_ratio", SCRIPT_PATH)
-MODULE = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(MODULE)
-
-
-def parse_crop(expression: str) -> tuple[int, int, int, int] | None:
-    match = re.search(r"crop=(\d+):(\d+):(\d+):(\d+)", expression)
-    if not match:
-        return None
-    return tuple(int(value) for value in match.groups())
-
-
-class EnforceVideoAspectRatioTests(unittest.TestCase):
-    def test_parse_size_property_round_trips_positive_dimensions(self) -> None:
-        generator = random.Random(20260418)
-        for _ in range(150):
-            width = generator.randint(1, 9999)
-            height = generator.randint(1, 9999)
-            raw = f"{width}x{height}"
-            with self.subTest(raw=raw):
-                self.assertEqual(MODULE.parse_size(raw), (width, height))
-
-    def test_load_dotenv_file_parses_quotes_and_respects_override(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            env_file = Path(temp_dir) / ".env"
-            env_file.write_text(
-                'TEXT_TO_SHORT_VIDEO_WIDTH="720"\n'
-                "TEXT_TO_SHORT_VIDEO_HEIGHT=1280 # comment\n",
-                encoding="utf-8",
-            )
-            original = os.environ.get("TEXT_TO_SHORT_VIDEO_WIDTH")
-            os.environ["TEXT_TO_SHORT_VIDEO_WIDTH"] = "999"
-            try:
-                loaded = MODULE.load_dotenv_file(env_file, override=False)
-                self.assertTrue(loaded)
-                self.assertEqual(os.environ["TEXT_TO_SHORT_VIDEO_WIDTH"], "999")
-                self.assertEqual(os.environ["TEXT_TO_SHORT_VIDEO_HEIGHT"], "1280")
-                MODULE.load_dotenv_file(env_file, override=True)
-                self.assertEqual(os.environ["TEXT_TO_SHORT_VIDEO_WIDTH"], "720")
-            finally:
-                if original is None:
-                    os.environ.pop("TEXT_TO_SHORT_VIDEO_WIDTH", None)
-                else:
-                    os.environ["TEXT_TO_SHORT_VIDEO_WIDTH"] = original
-                os.environ.pop("TEXT_TO_SHORT_VIDEO_HEIGHT", None)
-
-    def test_build_video_filter_property_keeps_crop_within_bounds(self) -> None:
-        generator = random.Random(20260418)
-        for _ in range(200):
-            input_width = generator.randint(32, 4096)
-            input_height = generator.randint(32, 4096)
-            target_width = generator.randint(32, 2160)
-            target_height = generator.randint(32, 3840)
-
-            expression, crop_applied = MODULE.build_video_filter(
-                input_width=input_width,
-                input_height=input_height,
-                target_width=target_width,
-                target_height=target_height,
-            )
-
-            with self.subTest(
-                input_width=input_width,
-                input_height=input_height,
-                target_width=target_width,
-                target_height=target_height,
-                expression=expression,
-            ):
-                if expression is None:
-                    self.assertFalse(crop_applied)
-                    self.assertEqual((input_width, input_height), (target_width, target_height))
-                    continue
-
-                self.assertIn(f"scale={target_width}:{target_height}", expression)
-                crop = parse_crop(expression)
-                if crop is None:
-                    self.assertFalse(crop_applied)
-                    self.assertEqual(input_width * target_height, input_height * target_width)
-                    continue
-
-                crop_width, crop_height, offset_x, offset_y = crop
-                self.assertTrue(crop_applied)
-                self.assertEqual(crop_width % 2, 0)
-                self.assertEqual(crop_height % 2, 0)
-                self.assertGreaterEqual(crop_width, 2)
-                self.assertGreaterEqual(crop_height, 2)
-                self.assertLessEqual(crop_width, input_width)
-                self.assertLessEqual(crop_height, input_height)
-                self.assertGreaterEqual(offset_x, 0)
-                self.assertGreaterEqual(offset_y, 0)
-                self.assertLessEqual(offset_x + crop_width, input_width)
-                self.assertLessEqual(offset_y + crop_height, input_height)
-
-    def test_resolve_output_path_enforces_in_place_rules(self) -> None:
-        input_video = Path("/tmp/input.mp4")
-        args = types.SimpleNamespace(in_place=False, output_video=None)
-        self.assertEqual(MODULE.resolve_output_path(args, input_video), Path("/tmp/input_aspect_fixed.mp4"))
-
-        args = types.SimpleNamespace(in_place=True, output_video=None)
-        self.assertEqual(MODULE.resolve_output_path(args, input_video), input_video)
-
-        args = types.SimpleNamespace(in_place=True, output_video="/tmp/out.mp4")
-        with self.assertRaises(SystemExit):
-            MODULE.resolve_output_path(args, input_video)
-
-    def test_main_copies_file_when_video_already_matches_target(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            input_video = Path(temp_dir) / "input.mp4"
-            input_video.write_bytes(b"video")
-            output_video = Path(temp_dir) / "copy.mp4"
-            args = types.SimpleNamespace(
-                input_video=str(input_video),
-                output_video=str(output_video),
-                in_place=False,
-                target_size="640x360",
-                target_width=None,
-                target_height=None,
-                env_file=str(Path(temp_dir) / ".env"),
-                force=False,
-                ffmpeg_bin="ffmpeg",
-                ffprobe_bin="ffprobe",
-            )
-
-            with patch.object(MODULE, "parse_args", return_value=args), patch.object(
-                MODULE, "load_dotenv_file", return_value=False
-            ), patch.object(MODULE, "required_command"), patch.object(
-                MODULE, "probe_video_size", return_value=(640, 360)
-            ), patch("sys.stdout", new_callable=io.StringIO) as stdout:
-                exit_code = MODULE.main()
-
-            self.assertEqual(exit_code, 0)
-            self.assertEqual(output_video.read_bytes(), b"video")
-            self.assertIn("already matches target size", stdout.getvalue())
-
-    def test_main_runs_ffmpeg_and_reports_output_dimensions(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            input_video = Path(temp_dir) / "input.mp4"
-            output_video = Path(temp_dir) / "output.mp4"
-            input_video.write_bytes(b"video")
-            args = types.SimpleNamespace(
-                input_video=str(input_video),
-                output_video=str(output_video),
-                in_place=False,
-                target_size="1080x1920",
-                target_width=None,
-                target_height=None,
-                env_file=str(Path(temp_dir) / ".env"),
-                force=True,
-                ffmpeg_bin="ffmpeg",
-                ffprobe_bin="ffprobe",
-            )
-
-            def fake_run(command, check):
-                self.assertIn("-vf", command)
-                Path(command[-1]).write_bytes(b"processed")
-                return types.SimpleNamespace(returncode=0)
-
-            with patch.object(MODULE, "parse_args", return_value=args), patch.object(
-                MODULE, "load_dotenv_file", return_value=False
-            ), patch.object(MODULE, "required_command"), patch.object(
-                MODULE,
-                "probe_video_size",
-                side_effect=[(1920, 1080), (1080, 1920)],
-            ), patch.object(MODULE.subprocess, "run", side_effect=fake_run), patch(
-                "sys.stdout", new_callable=io.StringIO
-            ) as stdout:
-                exit_code = MODULE.main()
-
-            self.assertEqual(exit_code, 0)
-            self.assertTrue(output_video.is_file())
-            self.assertIn("Center crop applied: yes", stdout.getvalue())
-            self.assertIn("Output size: 1080x1920", stdout.getvalue())
-
-
-if __name__ == "__main__":
-    unittest.main()