aurclips 0.1.0__py3-none-any.whl

aurclips/__init__.py

@@ -0,0 +1,3 @@
+"""Bot de automatización de Shorts: descarga, recorta, edita y publica."""
+
+__version__ = "0.1.0"

aurclips/__main__.py

@@ -0,0 +1,366 @@
+"""CLI de aurclips.
+
+Uso:
+    python -m aurclips clip RUTA # recortar una grabación y ya (sin pipeline)
+    python -m aurclips run       # pipeline completo (ingesta -> proceso -> subida)
+    python -m aurclips mark      # marcar momentos en vivo mientras grabas
+    python -m aurclips review    # aprobar o corregir títulos antes de subir
+    python -m aurclips ingest    # solo buscar/descargar contenido nuevo
+    python -m aurclips process   # solo transcribir + seleccionar + renderizar
+    python -m aurclips upload    # solo subir clips renderizados
+    python -m aurclips auth      # iniciar sesión de YouTube (una sola vez)
+    python -m aurclips status    # ver estado de videos y clips
+    python -m aurclips report    # métricas de los Shorts publicados y cola
+    python -m aurclips retry     # reencolar videos/clips fallidos
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import traceback
+from pathlib import Path
+
+from .config import Config
+from .state import State
+
+
+def _load() -> tuple[Config, State]:
+    cfg = Config()
+    db = State(cfg.db_path)
+    return cfg, db
+
+
+def cmd_ingest(cfg: Config, db: State):
+    from .ingest import ingest
+    ingest(cfg, db)
+
+
+def cmd_process(cfg: Config, db: State):
+    from .render import render_clip
+    from .safety import screen_clip
+    from .select_clips import clip_words, select_clips
+    from .transcribe import transcribe
+
+    videos = db.videos_to_process()
+    if not videos:
+        print("[2/4] No hay videos pendientes por procesar")
+        return
+    max_videos = cfg.get("limits.max_videos_per_run", 3)
+    if len(videos) > max_videos:
+        print(f"[2/4] {len(videos)} pendientes; se procesan {max_videos} "
+              f"(limits.max_videos_per_run)")
+        videos = videos[:max_videos]
+    for video in videos:
+        vid = video["id"]
+        title = video["title"] or f"video_{vid}"
+        workdir = cfg.work_dir / f"video_{vid}"
+        transcript_path = workdir / "transcript.json"
+        try:
+            # --- transcribir -------------------------------------------
+            if db.needs_transcription(video):
+                print(f"[2/4] Transcribiendo: {title}")
+                transcript = transcribe(cfg, video["path"], transcript_path)
+                db.video_transcribed(vid)
+            else:
+                transcript = json.loads(transcript_path.read_text(encoding="utf-8"))
+
+            # --- seleccionar clips -------------------------------------
+            if db.needs_selection(video):
+                print(f"[3/4] Seleccionando clips: {title}")
+                clips = select_clips(cfg, transcript, title, video["path"])
+                if not clips:
+                    print("  sin clips útiles; video marcado como terminado")
+                    db.video_finished(vid)
+                    continue
+                added = 0
+                for i, c in enumerate(clips):
+                    text = " ".join(
+                        w["word"] for w in clip_words(transcript, c.start, c.end)
+                    )
+                    known = ((row["id"], row["text"])
+                             for row in db.texts_for_dedup())
+                    verdict = screen_clip(cfg, text, known)
+                    if verdict.unsafe_terms:
+                        print(f"  [filtro] clip {c.title!r} contiene: "
+                              f"{', '.join(verdict.unsafe_terms[:5])} -> "
+                              f"{cfg.get('safety.action', 'skip')}")
+                    if verdict.duplicate_of is not None:
+                        print(f"  [dedup] clip {c.title!r} es casi idéntico "
+                              f"al clip #{verdict.duplicate_of}; se omite")
+                    if not verdict.keep:
+                        continue
+                    db.add_clip(vid, i, c, text, flagged=verdict.flagged)
+                    added += 1
+                if not added:
+                    print("  todos los clips fueron filtrados; video terminado")
+                    db.video_finished(vid)
+                    continue
+                db.video_selected(vid)
+
+            # --- renderizar --------------------------------------------
+            for clip in db.clips_to_render(vid):
+                words = clip_words(transcript, clip["start"], clip["end"])
+                out = render_clip(cfg, video["path"], clip["start"], clip["end"],
+                                  clip["title"], words, clip["id"])
+                db.clip_rendered(clip["id"], str(out))
+            db.video_finished(vid)
+        except Exception as e:  # noqa: BLE001 — un video fallido no detiene el resto
+            print(f"  [error] video {vid} ({title}): {e}")
+            traceback.print_exc()
+            db.video_failed(vid, str(e))
+            from .notify import notify
+            notify(cfg, "error", f"Falló el video '{title}': {str(e)[:200]}")
+
+
+def cmd_mark(cfg: Config, db: State, name: str | None = None):
+    """Sesión de marcado en vivo: cada Enter marca el instante actual."""
+    from .marks import record_session
+    record_session(cfg, name)
+
+
+def _show_clip(clip, tags: list[str]):
+    dur = clip["end"] - clip["start"]
+    star = " ★ marcado por ti" if clip["marked"] else ""
+    print(f"\n── clip #{clip['id']} · {clip['start']:.0f}s-{clip['end']:.0f}s "
+          f"({dur:.0f}s){star}")
+    print(f"   archivo: {clip['path']}")
+    print(f"   título:  {clip['title']}")
+    if clip["description"]:
+        print(f"   desc:    {clip['description'][:160]}")
+    if tags:
+        print(f"   tags:    {' '.join('#' + t for t in tags)}")
+
+
+def cmd_review(cfg: Config, db: State):
+    """Revisa y aprueba la metadata antes de que los clips se suban.
+
+    Son unos pocos al día: la herramienta propone y tú apruebas. Es el punto
+    donde tu criterio entra al pipeline sin tener que tocar código.
+    """
+    from . import titles
+    from .stats import review_header
+
+    clips = db.clips_to_review()
+    if not clips:
+        print("No hay clips esperando revisión.")
+        return
+    llm = titles.enabled(cfg)
+    for line in review_header(db):  # los datos, donde se toman las decisiones
+        print(line)
+    print()
+    print(f"{len(clips)} clip(s) por revisar.")
+    print("[Enter] aprobar · [t] título · [d] descripción · "
+          f"{'[r] regenerar · ' if llm else ''}[x] descartar · [s] saltar · [q] salir")
+
+    approved = discarded = 0
+    for clip in clips:
+        tags = db.clip_tags(clip)
+        title, description = clip["title"], clip["description"]
+        _show_clip(clip, tags)
+        while True:
+            try:
+                choice = input("   > ").strip().lower()
+            except (EOFError, KeyboardInterrupt):
+                print("\nRevisión interrumpida; el resto queda pendiente.")
+                return
+            if choice in ("", "a", "ok"):
+                db.clip_approved(clip["id"], title, description, tags)
+                approved += 1
+                break
+            if choice == "t":
+                new = input("     título: ").strip()
+                if new:
+                    title = new[:93]
+                    print(f"   título:  {title}")
+                continue
+            if choice == "d":
+                new = input("     descripción: ").strip()
+                if new:
+                    description = new
+                continue
+            if choice == "r" and llm:
+                proposal = titles.propose(cfg, clip["text"] or description, "")
+                if proposal:  # se guarda al aprobar, no antes
+                    title, description, tags = proposal
+                    print(f"   título:  {title}")
+                    print(f"   desc:    {description[:160]}")
+                continue
+            if choice == "x":
+                db.clip_discarded(clip["id"])
+                discarded += 1
+                print("   descartado (no se subirá)")
+                break
+            if choice == "s":
+                break
+            if choice == "q":
+                print(f"\n{approved} aprobado(s), {discarded} descartado(s).")
+                return
+            print("   opciones: Enter / t / d / r / x / s / q")
+
+    print(f"\n{approved} aprobado(s), {discarded} descartado(s).")
+
+
+def cmd_upload(cfg: Config, db: State):
+    from .upload import upload_pending
+    upload_pending(cfg, db)
+
+
+def cmd_auth(cfg: Config, db: State):
+    from .upload import get_credentials
+    get_credentials(cfg, interactive=True)
+    print("Autenticación de YouTube completada.")
+
+
+def cmd_status(cfg: Config, db: State):
+    print("== Videos ==")
+    rows = db.recent_videos(20)
+    if not rows:
+        print("  (ninguno)")
+    for r in rows:
+        dur = f"{r['duration']:.0f}s" if r["duration"] else "?"
+        print(f"  #{r['id']:<4} {r['status']:<12} [{r['source']}] {r['title'] or ''} ({dur})")
+    print("\n== Clips ==")
+    rows = db.recent_clips(20)
+    if not rows:
+        print("  (ninguno)")
+    review_on = cfg.get("review.enabled", True)
+    for r in rows:
+        extra = ""
+        situation = db.clip_situation(r, review_on)
+        if situation == "published":
+            extra = f" -> https://youtu.be/{r['youtube_id']} @ {r['publish_at'] or '?'}"
+        elif situation == "discarded":
+            extra = " (descartado en revisión)"
+        elif situation == "awaiting_review":
+            extra = " (por revisar)"
+        star = "★" if r["marked"] else " "
+        print(f"  #{r['id']:<4} {star} {r['status']:<10} {r['title'] or ''}{extra}")
+
+
+def cmd_report(cfg: Config, db: State):
+    from .stats import build_report, fetch_stats
+    if cfg.get("stats.enabled", True):
+        n = fetch_stats(cfg, db)
+        if n:
+            print(f"(métricas actualizadas para {n} clip(s))\n")
+    print(build_report(db))
+
+
+def cmd_retry(cfg: Config, db: State):
+    """Reencola videos y clips fallidos."""
+    def has_transcript(video_id: int) -> bool:
+        return (cfg.work_dir / f"video_{video_id}" / "transcript.json").exists()
+
+    n = db.requeue_failed(has_transcript)
+    print(f"{n} elemento(s) reencolados. Corre 'run' para reintentarlos.")
+
+
+def cmd_run(cfg: Config, db: State):
+    """Corrida diaria: se protege contra solapes y deja su propio log.
+
+    El lock reemplaza el -MultipleInstances del Task Scheduler (cron/launchd no
+    lo dan); la captura y rotación del log vivían en run.ps1 y ahora son iguales
+    en los tres SO, así que el scheduler solo llama a `aurclips run`.
+    """
+    from datetime import datetime
+
+    from .runner import prune_run_logs, single_instance, tee_output
+
+    logs_dir = cfg.logs_dir
+    with single_instance(logs_dir / "run.lock") as acquired:
+        if not acquired:
+            print("Ya hay una corrida en marcha; esta se omite.")
+            return
+        stamp = datetime.now().strftime("%Y-%m-%d_%H%M")
+        with tee_output(logs_dir / f"run_{stamp}.log"):
+            _run_pipeline(cfg, db)
+        prune_run_logs(logs_dir, keep=30)
+
+
+def _run_pipeline(cfg: Config, db: State):
+    from .notify import notify
+    cmd_ingest(cfg, db)
+    cmd_process(cfg, db)
+    cmd_upload(cfg, db)
+    uploaded = db.count_published()
+    queued = db.count_queued()
+    notify(cfg, "run",
+           f"Corrida completa: {uploaded} clips subidos en total, {queued} en cola")
+    print("\nCorrida completa.")
+    # la corrida diaria pasa de madrugada: si algo espera tu criterio, que te
+    # busque a ti — el loop no se cierra solo
+    pending = len(db.clips_to_review())
+    if pending and cfg.get("review.enabled", True):
+        print(f"{pending} clip(s) esperan tu visto bueno: python -m aurclips review")
+        notify(cfg, "review",
+               f"{pending} clip(s) listos y esperando tu revisión "
+               f"(python -m aurclips review)")
+
+
+def cmd_clip(cfg: Config, path: str | None, out: str | None,
+             max_clips: int | None):
+    """Modo recortador: una grabación entra, salen recortes sueltos.
+
+    El único comando que no abre la base: no hay progreso ni criterio que
+    guardar. Por eso recibe la config y no el par (cfg, db).
+    """
+    from .clipper import clip_recording
+
+    if not path:
+        print("Falta la grabación: aurclips clip RUTA_DEL_VIDEO")
+        sys.exit(2)
+    if max_clips is not None and max_clips < 1:
+        print("--clips es un tope: tiene que ser 1 o más")
+        sys.exit(2)
+    try:
+        clip_recording(cfg, path, out, max_clips)
+    except (OSError, ValueError) as e:
+        print(f"[error] {e}")
+        sys.exit(1)
+
+
+COMMANDS = {
+    "run": cmd_run,
+    "mark": cmd_mark,
+    "review": cmd_review,
+    "ingest": cmd_ingest,
+    "process": cmd_process,
+    "upload": cmd_upload,
+    "auth": cmd_auth,
+    "status": cmd_status,
+    "report": cmd_report,
+    "retry": cmd_retry,
+}
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="aurclips", description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("command", choices=["clip", *COMMANDS])
+    parser.add_argument("name", nargs="?",
+                        help="ruta de la grabación (para 'clip') o nombre de "
+                             "la sesión (para 'mark')")
+    parser.add_argument("--out", metavar="CARPETA",
+                        help="dónde dejar los recortes (solo 'clip')")
+    parser.add_argument("--clips", type=int, metavar="N",
+                        help="tope de recortes en esta corrida (solo 'clip')")
+    args = parser.parse_args()
+    try:
+        # 'clip' no toca la base: se carga solo la config
+        if args.command == "clip":
+            cmd_clip(Config(), args.name, args.out, args.clips)
+            return
+        cfg, db = _load()
+        if args.command == "mark":
+            cmd_mark(cfg, db, args.name)
+        else:
+            COMMANDS[args.command](cfg, db)
+    except KeyboardInterrupt:
+        print("\nInterrumpido.")
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()

aurclips/assets/config.default.yaml

@@ -0,0 +1,204 @@
+# ============================================================
+# Configuración de aurclips
+#
+# El proyecto se afina en tres puntos del flujo, no parámetro a parámetro:
+#   1. ARRIBA  — cómo grabas (marks): grabar en beats y marcarlos le gana a
+#                cualquier heurística. Es la palanca más grande.
+#   2. MEDIO   — el selector (selection.profile): mismo motor, calibrado a
+#                cómo suenas tú.
+#   3. ABAJO   — título (channel/titles) y medición (`report`): ahí es donde
+#                el canal mejora con el tiempo.
+# ============================================================
+
+# ------------------------------------------------------------
+# 1) ARRIBA — tus marcas al grabar
+#    Di la frase en voz alta mientras grabas, o deja un
+#    <video>.marks.txt al lado (lo escribe `aurclips mark`).
+# ------------------------------------------------------------
+marks:
+  enabled: true
+  phrases:              # frases gatillo: dilas y ese momento queda marcado.
+    - "esto es un short"   # ¿un fraseo tuyo no marcó? AGRÉGALO AQUÍ; es más
+    - "esto va a ser un short"  # seguro que bajar 'similarity': una variante
+    - "esto va al short"   # nueva coincide al 100% sin acercar el umbral a
+    - "este es el short"   # los falsos positivos
+    - "va para short"
+    - "marca aquí"
+    - "clip esto"
+  similarity: 0.85      # se comparan por parecido, no al pie de la letra: si un
+                        # día dices "esto es short" o Whisper escribe "shot", la
+                        # marca no se pierde (1.0 = exigir la frase literal).
+                        # Negar nunca marca: "esto NO es un short" se parece un
+                        # 91% y aun así se descarta
+  exclusive: true       # si el video trae marcas, solo se miran esas ventanas
+                        # (false = el resto del video sigue compitiendo).
+                        # OJO: un video SIN marcas no se ve afectado — se
+                        # selecciona normal, no se queda sin Shorts
+  tolerance: 3.0        # holgura (seg) al emparejar una marca con una ventana
+
+# ------------------------------------------------------------
+# 3) ABAJO — tu canal: contexto para escribir los títulos
+# ------------------------------------------------------------
+channel:
+  angle: ""             # de qué va tu canal, en una línea
+                        # ej: "análisis tranquilo de videojuegos, sin gritos"
+  title_examples: []    # 3-5 títulos tuyos que te gusten: marcan la línea
+                        # editorial que el modelo debe imitar
+                        # - "Por qué nadie termina este juego"
+                        # - "El detalle que todos se saltan"
+
+# Canales de YouTube a vigilar (URL del canal o de su pestaña /videos)
+channels:
+  # - "https://www.youtube.com/@MiCanal/videos"
+
+# Cuántos videos recientes revisar por canal en cada corrida
+channel_scan_limit: 5
+
+# Duración mínima (segundos) para descargar un video de un canal
+# (solo aplica a canales; la carpeta inbox acepta clips de cualquier duración)
+min_source_duration: 300
+
+# Calidad máxima de descarga
+max_download_height: 1080
+
+# ------------------------------------------------------------
+# Transcripción (faster-whisper, corre local y gratis)
+# ------------------------------------------------------------
+whisper:
+  model: "medium"       # tiny / base / small / medium / large-v3 (más grande = mejor)
+                        # con GPU NVIDIA, "medium" o "large-v3" van rápido y transcriben mejor
+  language: null        # null = autodetectar; o "es", "en", etc.
+  device: "auto"        # auto = GPU si hay, si no CPU (con respaldo automático)
+  compute_type: "auto"  # auto elige lo mejor según el dispositivo
+
+# ------------------------------------------------------------
+# 2) MEDIO — selección de clips (100% local, sin API keys)
+# ------------------------------------------------------------
+selection:
+  profile: "comentario" # calibración del selector a TU género:
+                        #   comentario = charla tranquila (análisis, podcast,
+                        #                tutorial): el volumen dice poco, manda
+                        #                cerrar la idea y la densidad
+                        #   gaming     = reacciones y streams: los picos de
+                        #                audio sí señalan el momento
+  weights: {}           # ajuste fino sobre el perfil; cada número es lo máximo
+                        # que esa señal mueve la puntuación. Ej:
+                        #   energy: 0.08
+                        #   closes: 0.32
+                        # señales: energy, pace, hook, punct, closes, density,
+                        #          filler, gaps, mark
+  clips_per_video: 3    # tope máximo de Shorts por video largo
+  minutes_per_short: 4  # densidad: ~1 Short por cada N minutos de video
+                        # (el número real = duración/N, acotado por el tope;
+                        #  0 = desactivado: usa siempre el tope)
+  quality_floor: 0.55   # descarta candidatos bajo esta fracción de la
+                        # puntuación del mejor (0 = desactivado); mejor
+                        # pocos Shorts buenos que rellenar el cupo
+                        # (lo que marcaste tú queda exento)
+                        #
+                        # ESTE ES EL DIAL DEL VOLUMEN. Es agresivo: en una
+                        # medición sintética dejó pasar 1 de 11 candidatos, o
+                        # sea ~1 Short por video sin marcar. Si con corridas
+                        # reales te rinde muy poco, BAJA ESTE NÚMERO (0.40),
+                        # no toques los pesos: los pesos deciden CUÁL clip,
+                        # este decide CUÁNTOS.
+  min_clip_seconds: 15
+  max_clip_seconds: 59
+
+# ------------------------------------------------------------
+# 3) ABAJO — títulos escritos por un LLM local y revisados por ti
+# ------------------------------------------------------------
+titles:
+  engine: "auto"        # heuristic = título sacado del propio clip (sin LLM)
+                        # ollama    = siempre pedírselo a Ollama
+                        # auto      = usa Ollama si está corriendo
+  model: "qwen2.5:7b"   # modelo de Ollama que redacta (alternativa ligera:
+                        # "gemma3:4b"). Instálalo con: ollama pull qwen2.5:7b
+  url: "http://localhost:11434"
+
+review:
+  enabled: true         # nada se sube sin tu visto bueno: `aurclips review`
+                        # muestra cada clip para aprobar, corregir o descartar
+                        # (false = pipeline 100% desatendido)
+
+# ------------------------------------------------------------
+# Edición / render
+# ------------------------------------------------------------
+render:
+  subtitles: true       # subtítulos virales quemados (estilo Hormozi)
+  words_per_caption: 3  # palabras por frase en pantalla (aparecen una a una)
+  font: "Anton"         # viene con el paquete; si faltara, una familia genérica
+  font_size: 112        # sobre lienzo de 1080x1920 (rango viral: 80-120)
+  outline: 10           # grosor del contorno negro
+  base_color: "#FFFFFF"
+  highlight_colors: ["#FFD93D", "#39FF14"]  # palabra clave (rota amarillo/verde)
+  caption_position: 0.70  # altura del texto (0.70 = tercio bajo, libre de UI)
+  tighten_silences: true  # jump cuts: recorta pausas muertas
+  max_pause: 1.5          # pausas más largas que esto (seg) se recortan
+                          # (1.0 para charla pura; 1.5-2.0 en gaming conserva acción visual)
+  crf: 20
+  preset: "veryfast"
+
+# ------------------------------------------------------------
+# Encuadre inteligente
+# ------------------------------------------------------------
+crop:
+  face_tracking: true   # detecta el rostro y centra el recorte vertical en él
+
+# ------------------------------------------------------------
+# Filtro de contenido y duplicados
+# ------------------------------------------------------------
+safety:
+  enabled: true
+  action: "skip"        # skip = descartar el clip | flag = guardarlo marcado para revisión
+  strict: false         # false = permite groserías comunes (monetizables, normales en gaming)
+                        # true  = también filtra groserías (canales de marca/infantiles)
+  extra_words: []       # palabras adicionales a bloquear (además de la lista integrada)
+
+dedup:
+  enabled: true
+  similarity: 0.8       # umbral de similitud (0-1) para considerar un clip duplicado
+
+# ------------------------------------------------------------
+# Límites por corrida (control de carga y escalado)
+# ------------------------------------------------------------
+limits:
+  max_videos_per_run: 3   # videos largos procesados por corrida
+  max_uploads_per_run: 5  # subidas por corrida (la cuota de YouTube da ~6/día)
+
+# ------------------------------------------------------------
+# Métricas y alertas
+# ------------------------------------------------------------
+stats:
+  enabled: true           # consulta vistas/likes de los Shorts publicados
+
+alerts:
+  discord_webhook: null   # URL de webhook de Discord para avisos (opcional)
+  notify_on: ["error", "uploaded", "review"]  # eventos que generan aviso
+                          # review = hay clips esperando tu aprobación; sin
+                          # este aviso la corrida de madrugada se queda muda
+
+# ------------------------------------------------------------
+# Publicación en YouTube
+# ------------------------------------------------------------
+upload:
+  enabled: false            # MODO BETA: cambia a true cuando quieras publicar de verdad
+  privacy: "private"        # se sube en privado y YouTube lo publica solo en publish_time
+  publish_time: "19:00"     # hora local de publicación diaria
+  timezone: null            # null = zona horaria del sistema; o "America/Mexico_City", etc.
+  min_lead_hours: 1         # margen mínimo entre subir y publicar
+  category_id: "24"         # 24 = Entertainment, 20 = Gaming, 22 = People & Blogs
+  extra_tags: ["shorts"]
+
+# ------------------------------------------------------------
+# Rutas (relativas a la raíz del proyecto)
+# ------------------------------------------------------------
+paths:
+  data: "data"
+  inbox: "data/inbox"           # deja aquí videos locales para procesar
+  downloads: "data/downloads"
+  work: "data/work"
+  output: "data/output"
+  credentials: "credentials"    # client_secrets.json y token de YouTube
+  ffmpeg: "tools/ffmpeg/bin"    # ffmpeg/ffprobe empaquetados (.exe en Windows);
+                                # si están en el PATH, se usan esos

aurclips/assets/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The Anton Project Authors (https://github.com/googlefonts/AntonFont.git)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.