klaket 0.7.0__tar.gz

klaket-0.7.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Klaket
+
+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.

klaket-0.7.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: klaket
+Version: 0.7.0
+Summary: Python client + CLI for Klaket — turn any video into LLM-ready data
+Author: Klaket
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/huseyinstif/klaket
+Project-URL: Repository, https://github.com/huseyinstif/klaket
+Project-URL: Issues, https://github.com/huseyinstif/klaket/issues
+Keywords: video,llm,transcription,whisper,diarization,subtitles,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# klaket (Python SDK)
+
+Turn any video into LLM-ready data. Zero dependencies.
+
+```bash
+pip install klaket
+```
+
+```python
+from klaket import Klaket
+
+k = Klaket()  # self-hosted; Klaket("https://api.klaket.dev", api_key="klk_...") for cloud
+
+result = k.process(
+    "https://youtube.com/watch?v=...",
+    model="medium",                 # optional quality bump
+    prompt="Klaket, Docker, RAG",   # proper-noun hints
+    num_speakers=2,                 # diarization hint
+)
+
+for seg in result["transcript"]:
+    print(f'[{seg["start"]:7.2f}] {seg.get("speaker", "")}: {seg["text"]}')
+
+hits = k.search(result["id"], "docker compose command")
+```
+
+MIT licensed. Part of [Klaket](https://github.com/klaket/klaket).

klaket-0.7.0/README.md

@@ -0,0 +1,27 @@
+# klaket (Python SDK)
+
+Turn any video into LLM-ready data. Zero dependencies.
+
+```bash
+pip install klaket
+```
+
+```python
+from klaket import Klaket
+
+k = Klaket()  # self-hosted; Klaket("https://api.klaket.dev", api_key="klk_...") for cloud
+
+result = k.process(
+    "https://youtube.com/watch?v=...",
+    model="medium",                 # optional quality bump
+    prompt="Klaket, Docker, RAG",   # proper-noun hints
+    num_speakers=2,                 # diarization hint
+)
+
+for seg in result["transcript"]:
+    print(f'[{seg["start"]:7.2f}] {seg.get("speaker", "")}: {seg["text"]}')
+
+hits = k.search(result["id"], "docker compose command")
+```
+
+MIT licensed. Part of [Klaket](https://github.com/klaket/klaket).

klaket-0.7.0/klaket/__init__.py

@@ -0,0 +1,123 @@
+"""Klaket Python SDK — turn any video into LLM-ready data.
+
+Zero dependencies (stdlib urllib only).
+
+    from klaket import Klaket
+
+    k = Klaket()                                  # self-hosted on localhost:8484
+    result = k.process("https://youtube.com/watch?v=...")
+    for seg in result["transcript"]:
+        print(seg["start"], seg.get("speaker", ""), seg["text"])
+"""
+
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+__version__ = "0.7.0"
+
+
+class KlaketError(RuntimeError):
+    """API-level error (validation, quota, auth, failed job…)."""
+
+
+class Klaket:
+    def __init__(self, base_url: str = "http://localhost:8484", api_key: str = ""):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+
+    # --- core calls ---
+
+    def ingest(
+        self,
+        url: str,
+        *,
+        language: str = "auto",
+        model: str = "",
+        prompt: str = "",
+        num_speakers: int = 0,
+        translate_to: str = "",
+        webhook_url: str = "",
+    ) -> str:
+        """Queue a video; returns the job id."""
+        body = {"url": url, "language": language}
+        if model:
+            body["model"] = model
+        if prompt:
+            body["prompt"] = prompt
+        if num_speakers:
+            body["num_speakers"] = num_speakers
+        if translate_to:
+            body["translate_to"] = translate_to
+        if webhook_url:
+            body["webhook_url"] = webhook_url
+        return self._request("POST", "/v1/ingest", body)["id"]
+
+    def batch(self, urls: list, **options) -> list:
+        """Queue many videos; returns the job ids."""
+        body = {"urls": urls, **{k: v for k, v in options.items() if v}}
+        return self._request("POST", "/v1/batch", body)["ids"]
+
+    def status(self, job_id: str) -> dict:
+        return self._request("GET", f"/v1/jobs/{job_id}")
+
+    def result(self, job_id: str) -> dict:
+        """The full LLM-ready result (transcript, scenes, chapters…)."""
+        return self._request("GET", f"/v1/jobs/{job_id}/result")
+
+    def search(self, job_id: str, query: str) -> list:
+        """Find moments inside a processed video."""
+        q = urllib.parse.quote(query)
+        return self._request("GET", f"/v1/jobs/{job_id}/search?q={q}")["hits"]
+
+    def delete(self, job_id: str) -> None:
+        self._request("DELETE", f"/v1/jobs/{job_id}")
+
+    def usage(self) -> dict:
+        return self._request("GET", "/v1/usage")
+
+    # --- conveniences ---
+
+    def wait(self, job_id: str, *, timeout: float = 1800, poll: float = 3) -> dict:
+        """Block until the job finishes; raises KlaketError on failure/timeout."""
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            job = self.status(job_id)
+            if job["status"] == "done":
+                return job
+            if job["status"] == "failed":
+                raise KlaketError(f"job {job_id} failed: {job.get('error', '')}")
+            time.sleep(poll)
+        raise KlaketError(f"job {job_id} timed out after {timeout}s")
+
+    def process(self, url: str, **options) -> dict:
+        """ingest + wait + result in one call."""
+        job_id = self.ingest(url, **options)
+        self.wait(job_id)
+        return self.result(job_id)
+
+    # --- plumbing ---
+
+    def _request(self, method: str, path: str, body: dict | None = None) -> dict:
+        req = urllib.request.Request(
+            self.base_url + path,
+            data=json.dumps(body).encode() if body is not None else None,
+            headers={
+                "Content-Type": "application/json",
+                "User-Agent": f"klaket-python/{__version__}",
+                **({"Authorization": f"Bearer {self.api_key}"} if self.api_key else {}),
+            },
+            method=method,
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=60) as res:
+                raw = res.read()
+                return json.loads(raw) if raw else {}
+        except urllib.error.HTTPError as exc:
+            try:
+                message = json.loads(exc.read()).get("error", str(exc))
+            except Exception:
+                message = str(exc)
+            raise KlaketError(message) from None

klaket-0.7.0/klaket/cli.py

@@ -0,0 +1,141 @@
+"""Klaket CLI — talk to a Klaket API from the terminal.
+
+    klaket ingest "https://youtube.com/watch?v=..."          # queue, print job id
+    klaket ingest "https://..." --wait                       # queue + wait + print result JSON
+    klaket status <job-id>
+    klaket result <job-id>
+    klaket search <job-id> "docker compose"
+    klaket usage
+
+Configuration: --api-url / KLAKET_API_URL (default http://localhost:8484),
+--api-key / KLAKET_API_KEY (only needed against a cloud deployment).
+"""
+
+import argparse
+import json
+import os
+import sys
+
+from . import Klaket, KlaketError, __version__
+
+
+def _client(args: argparse.Namespace) -> Klaket:
+    return Klaket(base_url=args.api_url, api_key=args.api_key)
+
+
+def _dump(data) -> None:
+    json.dump(data, sys.stdout, indent=2, ensure_ascii=False)
+    sys.stdout.write("\n")
+
+
+def _cmd_ingest(args) -> None:
+    k = _client(args)
+    job_id = k.ingest(
+        args.url,
+        language=args.language,
+        model=args.model,
+        prompt=args.prompt,
+        num_speakers=args.num_speakers,
+        translate_to=args.translate_to,
+        webhook_url=args.webhook_url,
+    )
+    if args.wait:
+        print(f"queued {job_id} - waiting...", file=sys.stderr)
+        k.wait(job_id, timeout=args.timeout)
+        _dump(k.result(job_id))
+    else:
+        _dump({"id": job_id, "status": "queued"})
+
+
+def _cmd_status(args) -> None:
+    _dump(_client(args).status(args.job_id))
+
+
+def _cmd_wait(args) -> None:
+    _dump(_client(args).wait(args.job_id, timeout=args.timeout))
+
+
+def _cmd_result(args) -> None:
+    _dump(_client(args).result(args.job_id))
+
+
+def _cmd_search(args) -> None:
+    _dump(_client(args).search(args.job_id, args.query))
+
+
+def _cmd_delete(args) -> None:
+    _client(args).delete(args.job_id)
+    print(f"deleted {args.job_id}", file=sys.stderr)
+
+
+def _cmd_usage(args) -> None:
+    _dump(_client(args).usage())
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="klaket", description="Turn any video into LLM-ready data."
+    )
+    parser.add_argument("--version", action="version", version=f"klaket {__version__}")
+    parser.add_argument(
+        "--api-url",
+        default=os.environ.get("KLAKET_API_URL", "http://localhost:8484"),
+        help="Klaket API base URL (env KLAKET_API_URL)",
+    )
+    parser.add_argument(
+        "--api-key",
+        default=os.environ.get("KLAKET_API_KEY", ""),
+        help="API key for cloud mode (env KLAKET_API_KEY)",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("ingest", help="queue a video (URL or worker-visible path)")
+    p.add_argument("url")
+    p.add_argument("--language", default="auto", help="ISO 639-1 hint (default: auto)")
+    p.add_argument("--model", default="", help="whisper model: tiny|base|small|medium|large-v3")
+    p.add_argument("--prompt", default="", help="context hint: proper nouns, jargon (max 500 chars)")
+    p.add_argument("--num-speakers", type=int, default=0, help="diarization hint (0 = auto)")
+    p.add_argument("--translate-to", default="", help="translate transcript to this ISO 639-1 language")
+    p.add_argument("--webhook-url", default="", help="POSTed on done/failed")
+    p.add_argument("--wait", action="store_true", help="wait and print the full result JSON")
+    p.add_argument("--timeout", type=float, default=1800, help="max seconds to wait (with --wait)")
+    p.set_defaults(func=_cmd_ingest)
+
+    p = sub.add_parser("status", help="show job status")
+    p.add_argument("job_id")
+    p.set_defaults(func=_cmd_status)
+
+    p = sub.add_parser("wait", help="block until a job finishes")
+    p.add_argument("job_id")
+    p.add_argument("--timeout", type=float, default=1800)
+    p.set_defaults(func=_cmd_wait)
+
+    p = sub.add_parser("result", help="print the LLM-ready result JSON")
+    p.add_argument("job_id")
+    p.set_defaults(func=_cmd_result)
+
+    p = sub.add_parser("search", help="find moments inside a processed video")
+    p.add_argument("job_id")
+    p.add_argument("query")
+    p.set_defaults(func=_cmd_search)
+
+    p = sub.add_parser("delete", help="delete a job and its artifacts")
+    p.add_argument("job_id")
+    p.set_defaults(func=_cmd_delete)
+
+    p = sub.add_parser("usage", help="show this month's video-minute usage")
+    p.set_defaults(func=_cmd_usage)
+
+    args = parser.parse_args(argv)
+    try:
+        args.func(args)
+    except KlaketError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 130
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

klaket-0.7.0/klaket/langchain.py

@@ -0,0 +1,78 @@
+"""LangChain document loader for Klaket.
+
+    pip install klaket langchain-core
+
+    from klaket.langchain import KlaketLoader
+
+    docs = KlaketLoader("https://youtube.com/watch?v=…").load()
+    # or from a finished job: KlaketLoader("1f3a9c04d2e88b17").load()
+
+Each Document corresponds to a chapter (by="chapter", the default) or a
+single transcript segment (by="segment"); metadata carries the video title,
+time range, language, and speaker.
+"""
+
+import re
+from typing import Iterator
+
+from . import Klaket
+
+_JOB_ID = re.compile(r"^[0-9a-f]{16}$")
+
+
+class KlaketLoader:
+    def __init__(
+        self,
+        source: str,
+        *,
+        base_url: str = "http://localhost:8484",
+        api_key: str = "",
+        by: str = "chapter",
+        **ingest_options,
+    ):
+        if by not in ("chapter", "segment"):
+            raise ValueError('by must be "chapter" or "segment"')
+        self.source = source
+        self.by = by
+        self.ingest_options = ingest_options
+        self.client = Klaket(base_url, api_key)
+
+    def _result(self) -> dict:
+        if _JOB_ID.match(self.source):
+            return self.client.result(self.source)
+        return self.client.process(self.source, **self.ingest_options)
+
+    def lazy_load(self) -> Iterator:
+        try:
+            from langchain_core.documents import Document
+        except ImportError as exc:  # pragma: no cover
+            raise ImportError("KlaketLoader requires langchain-core: pip install langchain-core") from exc
+
+        result = self._result()
+        base_meta = {
+            "source": result.get("url", self.source),
+            "title": result.get("title", ""),
+            "language": result.get("language", ""),
+            "klaket_job_id": result.get("id", ""),
+        }
+        if self.by == "segment":
+            for seg in result["transcript"]:
+                yield Document(
+                    page_content=seg["text"],
+                    metadata={**base_meta, "start": seg["start"], "end": seg["end"],
+                              "speaker": seg.get("speaker", "")},
+                )
+            return
+        for chapter in result.get("chapters", []):
+            texts = [
+                seg["text"] for seg in result["transcript"]
+                if seg["start"] < chapter["end"] and seg["end"] > chapter["start"]
+            ]
+            yield Document(
+                page_content=" ".join(texts) or chapter["title"],
+                metadata={**base_meta, "chapter": chapter["title"],
+                          "start": chapter["start"], "end": chapter["end"]},
+            )
+
+    def load(self) -> list:
+        return list(self.lazy_load())

klaket-0.7.0/klaket/llamaindex.py

@@ -0,0 +1,60 @@
+"""LlamaIndex reader for Klaket.
+
+    pip install klaket llama-index-core
+
+    from klaket.llamaindex import KlaketReader
+
+    docs = KlaketReader().load_data("https://youtube.com/watch?v=…")
+"""
+
+import re
+
+from . import Klaket
+
+_JOB_ID = re.compile(r"^[0-9a-f]{16}$")
+
+
+class KlaketReader:
+    def __init__(self, base_url: str = "http://localhost:8484", api_key: str = "", by: str = "chapter"):
+        if by not in ("chapter", "segment"):
+            raise ValueError('by must be "chapter" or "segment"')
+        self.by = by
+        self.client = Klaket(base_url, api_key)
+
+    def load_data(self, source: str, **ingest_options) -> list:
+        try:
+            from llama_index.core.schema import Document
+        except ImportError as exc:  # pragma: no cover
+            raise ImportError("KlaketReader requires llama-index-core: pip install llama-index-core") from exc
+
+        result = (
+            self.client.result(source)
+            if _JOB_ID.match(source)
+            else self.client.process(source, **ingest_options)
+        )
+        base_meta = {
+            "source": result.get("url", source),
+            "title": result.get("title", ""),
+            "language": result.get("language", ""),
+            "klaket_job_id": result.get("id", ""),
+        }
+        docs = []
+        if self.by == "segment":
+            for seg in result["transcript"]:
+                docs.append(Document(
+                    text=seg["text"],
+                    metadata={**base_meta, "start": seg["start"], "end": seg["end"],
+                              "speaker": seg.get("speaker", "")},
+                ))
+            return docs
+        for chapter in result.get("chapters", []):
+            texts = [
+                seg["text"] for seg in result["transcript"]
+                if seg["start"] < chapter["end"] and seg["end"] > chapter["start"]
+            ]
+            docs.append(Document(
+                text=" ".join(texts) or chapter["title"],
+                metadata={**base_meta, "chapter": chapter["title"],
+                          "start": chapter["start"], "end": chapter["end"]},
+            ))
+        return docs

klaket-0.7.0/klaket.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: klaket
+Version: 0.7.0
+Summary: Python client + CLI for Klaket — turn any video into LLM-ready data
+Author: Klaket
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/huseyinstif/klaket
+Project-URL: Repository, https://github.com/huseyinstif/klaket
+Project-URL: Issues, https://github.com/huseyinstif/klaket/issues
+Keywords: video,llm,transcription,whisper,diarization,subtitles,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# klaket (Python SDK)
+
+Turn any video into LLM-ready data. Zero dependencies.
+
+```bash
+pip install klaket
+```
+
+```python
+from klaket import Klaket
+
+k = Klaket()  # self-hosted; Klaket("https://api.klaket.dev", api_key="klk_...") for cloud
+
+result = k.process(
+    "https://youtube.com/watch?v=...",
+    model="medium",                 # optional quality bump
+    prompt="Klaket, Docker, RAG",   # proper-noun hints
+    num_speakers=2,                 # diarization hint
+)
+
+for seg in result["transcript"]:
+    print(f'[{seg["start"]:7.2f}] {seg.get("speaker", "")}: {seg["text"]}')
+
+hits = k.search(result["id"], "docker compose command")
+```
+
+MIT licensed. Part of [Klaket](https://github.com/klaket/klaket).

klaket-0.7.0/klaket.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+klaket/__init__.py
+klaket/cli.py
+klaket/langchain.py
+klaket/llamaindex.py
+klaket.egg-info/PKG-INFO
+klaket.egg-info/SOURCES.txt
+klaket.egg-info/dependency_links.txt
+klaket.egg-info/entry_points.txt
+klaket.egg-info/top_level.txt

klaket-0.7.0/klaket.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

klaket-0.7.0/klaket.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+klaket = klaket.cli:main

klaket-0.7.0/klaket.egg-info/top_level.txt

@@ -0,0 +1 @@
+klaket

klaket-0.7.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "klaket"
+version = "0.7.0"
+description = "Python client + CLI for Klaket — turn any video into LLM-ready data"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+keywords = ["video", "llm", "transcription", "whisper", "diarization", "subtitles", "mcp"]
+authors = [{ name = "Klaket" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/huseyinstif/klaket"
+Repository = "https://github.com/huseyinstif/klaket"
+Issues = "https://github.com/huseyinstif/klaket/issues"
+
+[project.scripts]
+klaket = "klaket.cli:main"
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["klaket*"]

klaket-0.7.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+