sonilo-cli 0.1.0__py3-none-any.whl

sonilo_cli/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

sonilo_cli/__main__.py

@@ -0,0 +1,341 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, List, NoReturn, Optional
+from urllib.parse import urlparse
+
+from sonilo import Sonilo
+from sonilo.errors import SoniloError
+
+from sonilo_cli import __version__
+
+
+class _Parser(argparse.ArgumentParser):
+    """ArgumentParser that fails with `sonilo: <msg>` and exit code 1."""
+
+    def error(self, message: str) -> NoReturn:  # noqa: D401
+        sys.stderr.write(f"sonilo: {message}\n")
+        raise SystemExit(1)
+
+
+def _fail(message: str) -> NoReturn:
+    sys.stderr.write(f"sonilo: {message}\n")
+    raise SystemExit(1)
+
+
+def _print_json(value: Any) -> None:
+    print(json.dumps(value, indent=2))
+
+
+def _wrote(path: Any, size: int) -> None:
+    print(f"Wrote {path} ({size:,} bytes)")
+
+
+def build_client(api_key: Optional[str]) -> Sonilo:
+    key = api_key or os.environ.get("SONILO_API_KEY")
+    if not key:
+        _fail(
+            "no API key — pass --api-key <key> or set the "
+            "SONILO_API_KEY environment variable"
+        )
+    return Sonilo(api_key=key)
+
+
+def cmd_account(client: Sonilo, args: argparse.Namespace) -> None:
+    _print_json(client.account.services())
+
+
+def cmd_usage(client: Sonilo, args: argparse.Namespace) -> None:
+    _print_json(client.account.usage(days=args.days))
+
+
+def _music_output(args: argparse.Namespace, fmt: str) -> str:
+    return args.output if args.output is not None else f"output.{fmt}"
+
+
+def cmd_text_to_music(client: Sonilo, args: argparse.Namespace) -> None:
+    fmt = args.format
+    use_async = args.use_async or fmt == "wav"
+    out = _music_output(args, fmt)
+    if use_async:
+        result = client.text_to_music.generate_async(
+            prompt=args.prompt,
+            duration=args.duration,
+            output_format="wav" if fmt == "wav" else None,
+        )
+        path = result.save(out)
+        _wrote(path, path.stat().st_size)
+    else:
+        track = client.text_to_music.generate(prompt=args.prompt, duration=args.duration)
+        path = track.save(out)
+        _wrote(path, len(track.audio))
+
+
+def cmd_video_to_music(client: Sonilo, args: argparse.Namespace) -> None:
+    fmt = args.format
+    use_async = args.use_async or fmt == "wav" or args.isolate_vocals or args.preserve_speech
+    out = _music_output(args, fmt)
+    if use_async:
+        result = client.video_to_music.generate_async(
+            video=args.video,
+            video_url=args.video_url,
+            prompt=args.prompt,
+            isolate_vocals=args.isolate_vocals or None,
+            preserve_speech=args.preserve_speech or None,
+            output_format="wav" if fmt == "wav" else None,
+        )
+        path = result.save(out)
+        _wrote(path, path.stat().st_size)
+    else:
+        track = client.video_to_music.generate(
+            video=args.video, video_url=args.video_url, prompt=args.prompt
+        )
+        path = track.save(out)
+        _wrote(path, len(track.audio))
+
+
+_SFX_FORMATS = ["wav", "mp3", "aac", "flac"]
+
+
+def cmd_text_to_sfx(client: Sonilo, args: argparse.Namespace) -> None:
+    out = args.output if args.output is not None else f"output.{args.format}"
+    result = client.text_to_sfx.generate(
+        prompt=args.prompt, duration=args.duration, audio_format=args.format
+    )
+    path = result.save(out)
+    _wrote(path, path.stat().st_size)
+
+
+def cmd_video_to_sfx(client: Sonilo, args: argparse.Namespace) -> None:
+    out = args.output if args.output is not None else f"output.{args.format}"
+    result = client.video_to_sfx.generate(
+        video=args.video, video_url=args.video_url,
+        prompt=args.prompt, audio_format=args.format,
+    )
+    path = result.save(out)
+    _wrote(path, path.stat().st_size)
+
+
+_SOUND_STEMS = ["music", "music_processed", "sfx"]
+
+
+def _stem_path(out: str, stem: str, media: Any) -> str:
+    base = Path(out)
+    ext = ""
+    if media is not None and getattr(media, "url", None):
+        ext = Path(urlparse(media.url).path).suffix
+    return str(base.with_name(f"{base.stem}.{stem}{ext or base.suffix}"))
+
+
+def _run_sound(client: Sonilo, args: argparse.Namespace, resource: Any, default_ext: str) -> None:
+    out = args.output if args.output is not None else f"output.{default_ext}"
+    result = resource.generate(
+        video=args.video,
+        video_url=args.video_url,
+        music_prompt=args.music_prompt,
+        sfx_prompt=args.sfx_prompt,
+        preserve_speech=True if args.preserve_speech else None,
+        ducking=False if args.no_ducking else None,
+    )
+    path = result.save(out)
+    _wrote(path, path.stat().st_size)
+    for stem in args.stems or []:
+        stem_path = _stem_path(out, stem, getattr(result, stem, None))
+        saved = result.save_stem(stem_path, which=stem)
+        _wrote(saved, saved.stat().st_size)
+
+
+def cmd_video_to_sound(client: Sonilo, args: argparse.Namespace) -> None:
+    _run_sound(client, args, client.video_to_sound, "wav")
+
+
+def cmd_video_to_video_sound(client: Sonilo, args: argparse.Namespace) -> None:
+    _run_sound(client, args, client.video_to_video_sound, "mp4")
+
+
+def _identity(body: Any) -> Any:
+    return body
+
+
+def cmd_tasks_get(client: Sonilo, args: argparse.Namespace) -> None:
+    _print_json(client.tasks.get(args.task_id, parser=_identity))
+
+
+def cmd_tasks_wait(client: Sonilo, args: argparse.Namespace) -> None:
+    deadline = time.monotonic() + args.timeout
+    while True:
+        body = client.tasks.get(args.task_id, parser=_identity)
+        status = body.get("status") if isinstance(body, dict) else None
+        if status == "succeeded":
+            _print_json(body)
+            return
+        if status == "failed":
+            _print_json(body)
+            raise SystemExit(1)
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            _fail(f"timed out after {args.timeout}s waiting for task {args.task_id}")
+        time.sleep(min(args.poll_interval, max(0.0, remaining)))
+
+
+def _add_global(parser: argparse.ArgumentParser) -> None:
+    # default=SUPPRESS (not None) is required here: argparse subparsers parse
+    # into a *fresh* namespace and then copy every key back onto the parent
+    # namespace (see cpython's _SubParsersAction.__call__), so a subparser
+    # default of None would clobber an --api-key already set on the parent
+    # parser (e.g. `sonilo --api-key X account`). With SUPPRESS, the key is
+    # only ever set when the flag is actually given, so it never overwrites
+    # a value set elsewhere with a default.
+    parser.add_argument(
+        "--api-key",
+        dest="api_key",
+        default=argparse.SUPPRESS,
+        help="Overrides the SONILO_API_KEY environment variable.",
+    )
+
+
+def _add_video_source(parser: argparse.ArgumentParser) -> None:
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--video", default=None, help="Local video file to score.")
+    group.add_argument("--video-url", dest="video_url", default=None,
+                       help="Remote video URL to score.")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = _Parser(prog="sonilo", description="Command-line interface for the Sonilo API")
+    parser.add_argument("--version", action="version", version=__version__)
+    _add_global(parser)
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    p_account = sub.add_parser("account", help="Show plan limits and available services")
+    _add_global(p_account)
+    p_account.set_defaults(func=cmd_account)
+
+    p_usage = sub.add_parser("usage", help="Show usage summary")
+    _add_global(p_usage)
+    p_usage.add_argument("--days", type=int, default=None, help="Look-back window in days.")
+    p_usage.set_defaults(func=cmd_usage)
+
+    p_t2m = sub.add_parser("text-to-music", help="Generate music from a text prompt")
+    _add_global(p_t2m)
+    p_t2m.add_argument("--prompt", required=True, help="What the music should sound like.")
+    p_t2m.add_argument("--duration", type=int, required=True, help="Track length in seconds.")
+    p_t2m.add_argument("--output", default=None, help="Where to save the audio.")
+    p_t2m.add_argument("--format", choices=["m4a", "wav"], default="m4a",
+                       help="Output container. wav forces async. Default: m4a")
+    p_t2m.add_argument("--async", dest="use_async", action="store_true",
+                       help="Submit and poll instead of streaming.")
+    p_t2m.set_defaults(func=cmd_text_to_music)
+
+    p_v2m = sub.add_parser("video-to-music", help="Generate music matched to a video")
+    _add_global(p_v2m)
+    _add_video_source(p_v2m)
+    p_v2m.add_argument("--prompt", default=None, help="Optional creative direction.")
+    p_v2m.add_argument("--output", default=None, help="Where to save the audio.")
+    p_v2m.add_argument("--format", choices=["m4a", "wav"], default="m4a",
+                       help="Output container. wav forces async.")
+    p_v2m.add_argument("--isolate-vocals", dest="isolate_vocals", action="store_true",
+                       help="Split out a vocals-only stem. Forces async.")
+    p_v2m.add_argument("--preserve-speech", dest="preserve_speech", action="store_true",
+                       help="Keep source speech in the mix. Forces async.")
+    p_v2m.add_argument("--async", dest="use_async", action="store_true",
+                       help="Submit and poll instead of streaming.")
+    p_v2m.set_defaults(func=cmd_video_to_music)
+
+    p_t2s = sub.add_parser("text-to-sfx", help="Generate a sound effect from a text prompt")
+    _add_global(p_t2s)
+    p_t2s.add_argument("--prompt", required=True, help="What the sound effect should be.")
+    p_t2s.add_argument("--duration", type=int, required=True, help="Effect length in seconds.")
+    p_t2s.add_argument("--output", default=None, help="Where to save the audio.")
+    p_t2s.add_argument("--format", choices=_SFX_FORMATS, default="wav",
+                       help="Output format. Default: wav")
+    p_t2s.set_defaults(func=cmd_text_to_sfx)
+
+    p_v2s = sub.add_parser("video-to-sfx", help="Generate a sound effect matched to a video")
+    _add_global(p_v2s)
+    _add_video_source(p_v2s)
+    p_v2s.add_argument("--prompt", default=None, help="Optional creative direction.")
+    p_v2s.add_argument("--output", default=None, help="Where to save the audio.")
+    p_v2s.add_argument("--format", choices=_SFX_FORMATS, default="wav",
+                       help="Output format. Default: wav")
+    p_v2s.set_defaults(func=cmd_video_to_sfx)
+
+    p_v2sd = sub.add_parser(
+        "video-to-sound", help="Generate matched music+sfx audio for a video"
+    )
+    _add_global(p_v2sd)
+    _add_video_source(p_v2sd)
+    p_v2sd.add_argument("--music-prompt", dest="music_prompt", default=None,
+                        help="Optional creative direction for the music bed.")
+    p_v2sd.add_argument("--sfx-prompt", dest="sfx_prompt", default=None,
+                        help="Optional creative direction for the sound effects.")
+    p_v2sd.add_argument("--preserve-speech", dest="preserve_speech", action="store_true",
+                        help="Keep source speech in the mix.")
+    p_v2sd.add_argument("--no-ducking", dest="no_ducking", action="store_true",
+                        help="Disable automatic ducking (on by default server-side).")
+    p_v2sd.add_argument("--stem", dest="stems", action="append", choices=_SOUND_STEMS,
+                        default=None, help="Also save an individual stem. Repeatable.")
+    p_v2sd.add_argument("--output", default=None, help="Where to save the combined audio.")
+    p_v2sd.set_defaults(func=cmd_video_to_sound)
+
+    p_v2vsd = sub.add_parser(
+        "video-to-video-sound", help="Generate matched music+sfx muxed into the source video"
+    )
+    _add_global(p_v2vsd)
+    _add_video_source(p_v2vsd)
+    p_v2vsd.add_argument("--music-prompt", dest="music_prompt", default=None,
+                         help="Optional creative direction for the music bed.")
+    p_v2vsd.add_argument("--sfx-prompt", dest="sfx_prompt", default=None,
+                         help="Optional creative direction for the sound effects.")
+    p_v2vsd.add_argument("--preserve-speech", dest="preserve_speech", action="store_true",
+                         help="Keep source speech in the mix.")
+    p_v2vsd.add_argument("--no-ducking", dest="no_ducking", action="store_true",
+                         help="Disable automatic ducking (on by default server-side).")
+    p_v2vsd.add_argument("--stem", dest="stems", action="append", choices=_SOUND_STEMS,
+                         default=None, help="Also save an individual stem. Repeatable.")
+    p_v2vsd.add_argument("--output", default=None, help="Where to save the combined video.")
+    p_v2vsd.set_defaults(func=cmd_video_to_video_sound)
+
+    p_tasks = sub.add_parser("tasks", help="Inspect async tasks")
+    _add_global(p_tasks)
+    tsub = p_tasks.add_subparsers(dest="tasks_command", metavar="<get|wait>")
+
+    p_get = tsub.add_parser("get", help="Fetch the current state of an async task")
+    _add_global(p_get)
+    p_get.add_argument("task_id", help="The task id to fetch.")
+    p_get.set_defaults(func=cmd_tasks_get)
+
+    p_wait = tsub.add_parser("wait", help="Poll an async task until it finishes")
+    _add_global(p_wait)
+    p_wait.add_argument("task_id", help="The task id to poll.")
+    p_wait.add_argument("--poll-interval", dest="poll_interval", type=float, default=2.0,
+                        help="Seconds between polls. Default: 2")
+    p_wait.add_argument("--timeout", type=float, default=600.0,
+                        help="Give up after this many seconds. Default: 600")
+    p_wait.set_defaults(func=cmd_tasks_wait)
+
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    func = getattr(args, "func", None)
+    if func is None:
+        parser.error("missing command (try `sonilo --help`)")
+    client = build_client(getattr(args, "api_key", None))
+    try:
+        func(client, args)
+    except SoniloError as exc:
+        _fail(str(exc))
+    finally:
+        client.close()
+
+
+if __name__ == "__main__":
+    main()

sonilo_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: sonilo-cli
+Version: 0.1.0
+Summary: Command-line interface for the Sonilo API: generate music and sound effects from text or video
+Project-URL: Repository, https://github.com/sonilo-ai/sonilo-python
+Author: Sonilo AI
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,cli,music,sfx,sonilo,text-to-music,video-to-music
+Requires-Python: >=3.9
+Requires-Dist: sonilo<0.6,>=0.5
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sonilo-cli
+
+Command-line interface for the [Sonilo API](https://github.com/sonilo-ai/sonilo-python) — generate music and sound effects from text or video.
+
+## Install
+
+    pip install sonilo-cli
+
+## Auth
+
+Set your API key once:
+
+    export SONILO_API_KEY=sk-...
+
+or pass `--api-key sk-...` on any command.
+
+## Commands
+
+    sonilo account                     # plan limits and available services
+    sonilo usage --days 7              # usage summary
+    sonilo text-to-music --prompt "warm lo-fi piano, rain" --duration 30
+    sonilo video-to-music --video clip.mp4 --prompt "tense synths" --format wav
+    sonilo text-to-sfx --prompt "glass shattering on concrete" --duration 3
+    sonilo video-to-sfx --video clip.mp4 --output whoosh.wav
+    sonilo video-to-sound --video clip.mp4 \
+        --music-prompt "uplifting orchestral score" --sfx-prompt "match the on-screen action"
+    sonilo video-to-video-sound --video clip.mp4 --music-prompt "tense synths"
+    sonilo tasks get <task-id>
+    sonilo tasks wait <task-id> --poll-interval 2 --timeout 600
+
+### Notes
+
+- `text-to-music` / `video-to-music` stream a short `.m4a` by default. `--format wav`,
+  `--isolate-vocals`, and `--preserve-speech` each switch to the async submit-and-poll path.
+- `text-to-sfx` / `video-to-sfx` are always async; `--format` accepts `wav|mp3|aac|flac`.
+- Output defaults to `./output.<ext>`; override with `--output`.
+
+### Combined soundtracks
+
+`video-to-sound` and `video-to-video-sound` score a clip with a music bed *and* sound effects in one
+call (one charge, instead of chaining two requests). Both are async-only and take the same options —
+they differ only in what comes back: `video-to-sound` writes the mixed **audio** (default
+`output.wav`), `video-to-video-sound` writes the **source video with that audio muxed in** (default
+`output.mp4`).
+
+    sonilo video-to-sound --video clip.mp4 \
+        --music-prompt "uplifting orchestral score" \
+        --sfx-prompt "match the on-screen action" \
+        --output soundtrack.wav --stem music --stem sfx
+
+- `--music-prompt` / `--sfx-prompt` steer the two layers separately; both are optional.
+- `--preserve-speech` keeps speech from the source video in the mix.
+- **Ducking is on by default** (music dips under speech). Pass `--no-ducking` to opt out — omitting
+  the flag leaves the server default untouched.
+- `--stem` is repeatable (`music`, `music_processed`, `sfx`) and saves the individual layers next to
+  the combined output, so you can re-balance the mix yourself. With `--output soundtrack.wav`, the
+  music stem lands at `soundtrack.music.m4a`. `music_processed` exists only when `--preserve-speech`
+  or ducking altered the music bed.
+
+## Free trial
+
+Accounts created through self-serve signup start with free runs on every endpoint — no card
+required:
+
+| Free runs | Endpoints |
+| --- | --- |
+| 2 each | text-to-music, text-to-sfx, audio-ducking |
+| 1 each | video-to-music, video-to-sfx, video-to-video-music, video-to-video-sfx, video-to-sound, video-to-video-sound |
+
+Once an endpoint's free runs are used up, calls to it bill at the normal rate. `sonilo account`
+shows the services available to your key.

sonilo_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+sonilo_cli/__init__.py,sha256=tr2-zP7nAwYvPIwHWMSf1BmGnXbB-5N7mN_ONxhPZAw,49
+sonilo_cli/__main__.py,sha256=KFjNMF0JSDTAcuI042ytQ55er3EZkjIJB21G90mWvdQ,14141
+sonilo_cli-0.1.0.dist-info/METADATA,sha256=jV8ki0mlRROORdaDL-x1jlcF-EOOuLO_KJU1jo4D7BU,3724
+sonilo_cli-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+sonilo_cli-0.1.0.dist-info/entry_points.txt,sha256=WJ-VCW2tp4aZfTHtrhnpIhABEVt9gdiVxI7Vl3Tk4OA,52
+sonilo_cli-0.1.0.dist-info/licenses/LICENSE,sha256=CWNa0JUhCcgEbCAYa96vZji3ML97PzrjKNRGocl1N2I,1066
+sonilo_cli-0.1.0.dist-info/RECORD,,

sonilo_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sonilo_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sonilo = sonilo_cli.__main__:main

sonilo_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sonilo AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.