vctx 0.1.0__py3-none-any.whl

vctx/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from vctx.cli import main
+
+__all__ = ["main"]

vctx/app/chunk.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import ValidationError
+
+from vctx.chunking import ChunkOptions, chunk_transcript
+from vctx.errors import InvalidTranscriptError, VctxError
+from vctx.io import model_to_json
+from vctx.transcript import Transcript
+
+
+class ChunkWriteError(VctxError):
+    exit_code = 1
+
+
+def write_chunk_file(
+    transcript_path: Path,
+    out_path: Path,
+    *,
+    max_chars: int = 6000,
+    max_seconds: int | None = None,
+) -> Path:
+    try:
+        transcript = Transcript.model_validate_json(transcript_path.read_text(encoding="utf-8"))
+    except (OSError, ValidationError) as exc:
+        raise InvalidTranscriptError(f"invalid transcript file: {transcript_path}") from exc
+
+    chunks = chunk_transcript(
+        transcript,
+        ChunkOptions(max_chars=max_chars, max_seconds=max_seconds),
+    )
+    try:
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(model_to_json(chunks), encoding="utf-8")
+    except OSError as exc:
+        raise ChunkWriteError(f"failed to write chunks: {out_path}: {exc}") from exc
+    return out_path

vctx/app/credentials.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable, Mapping
+from pathlib import Path
+
+
+class CredentialError(RuntimeError):
+    pass
+
+
+def env_with_credential_presence(
+    names: Iterable[str], *, env_files: list[Path], base_env: Mapping[str, str]
+) -> dict[str, str]:
+    env = dict(base_env)
+    for name in names:
+        if name in env:
+            continue
+        if any(_read_dotenv_value(env_file, name) for env_file in env_files):
+            env[name] = "[present]"
+    return env
+
+
+def resolve_env_credential(name: str | None, *, env_files: list[Path]) -> str:
+    if not name:
+        raise CredentialError("ASR instance is missing api_key_env")
+    value = os.environ.get(name)
+    if value:
+        return value
+    for env_file in env_files:
+        dotenv_value = _read_dotenv_value(env_file, name)
+        if dotenv_value:
+            return dotenv_value
+    searched = ", ".join(str(path) for path in env_files) or "no env files"
+    raise CredentialError(f"missing credential {name}; searched shell environment and {searched}")
+
+
+def _read_dotenv_value(path: Path, name: str) -> str | None:
+    if not path.exists():
+        return None
+    for raw_line in path.read_text(encoding="utf-8").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        if key.strip() != name:
+            continue
+        return _strip_dotenv_quotes(value.strip())
+    return None
+
+
+def _strip_dotenv_quotes(value: str) -> str:
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
+        return value[1:-1]
+    return value

vctx/app/doctor.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import importlib.metadata
+import shutil
+import sys
+from pathlib import Path
+
+from vctx.io import build_cache
+
+
+def doctor_report() -> str:
+    lines = [
+        f"python: {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+        f"vctx: {_package_version('vctx')}",
+        f"yt-dlp: {_package_version('yt-dlp')}",
+        f"cache: {_cache_status()}",
+        f"ffmpeg: {_command_status('ffmpeg')}",
+    ]
+    return "\n".join(lines) + "\n"
+
+
+def _package_version(distribution: str) -> str:
+    try:
+        return importlib.metadata.version(distribution)
+    except importlib.metadata.PackageNotFoundError:
+        return "missing"
+
+
+def _cache_status() -> str:
+    try:
+        cache = build_cache(None)
+        probe = Path(cache.root) / ".doctor-write-test"
+        probe.write_text("ok", encoding="utf-8")
+        probe.unlink(missing_ok=True)
+    except OSError as exc:
+        return f"error: {exc}"
+    return f"writable ({cache.root})"
+
+
+def _command_status(command: str) -> str:
+    path = shutil.which(command)
+    return path if path else "missing"

vctx/app/metadata.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from vctx.models.metadata import VideoMetadata
+from vctx.sources.detect import detect_source_adapter
+
+
+def inspect_metadata(value: str) -> VideoMetadata:
+    adapter = detect_source_adapter(value)
+    return adapter.extract_metadata(value)
+
+
+def render_metadata_text(metadata: VideoMetadata) -> str:
+    lines: list[str] = [
+        f"id: {metadata.id}",
+        f"source_type: {metadata.source_type}",
+        f"source: {metadata.source.value}",
+    ]
+    optional_fields = {
+        "title": metadata.title,
+        "uploader": metadata.uploader,
+        "duration_seconds": metadata.duration_seconds,
+        "webpage_url": metadata.webpage_url,
+        "language": metadata.language,
+        "extractor": metadata.extractor,
+        "raw_provider": metadata.raw_provider,
+    }
+    for key, value in optional_fields.items():
+        if value is not None:
+            lines.append(f"{key}: {value}")
+    return "\n".join(lines) + "\n"