diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ac24be8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,7 @@
+/.venv/
+/dist/
+/build/
+__pycache__
+*.pyc
+/videos/
+.DS_Store
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..355f228
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,44 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+
+default_install_hook_types: [pre-commit, pre-push, pre-merge-commit]
+
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+    -   id: check-executables-have-shebangs
+    -   id: check-json
+    -   id: check-merge-conflict
+    -   id: check-toml
+    -   id: check-yaml
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+
+-   repo: https://github.com/python/black
+    rev: 23.3.0
+    hooks:
+    -   id: black
+
+-   repo: https://github.com/sqlalchemyorg/zimports/
+    rev: v0.4.5
+    hooks:
+    -   id: zimports
+
+-   repo: https://github.com/pycqa/flake8
+    rev: 6.0.0
+    hooks:
+    -   id: flake8
+        additional_dependencies:
+          - flake8-import-order
+          - flake8-import-single
+          - flake8-builtins
+          - flake8-future-annotations
+          - flake8-docstrings
+          - flake8-rst-docstrings
+          - pygments
+
+-   repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.3.0
+    hooks:
+    -   id: mypy
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..2c07333
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.11
diff --git a/README.rst b/README.rst
new file mode 100644
index 0000000..49982d1
--- /dev/null
+++ b/README.rst
@@ -0,0 +1,190 @@
+ProFUSION Video Transcribe
+==========================
+
+Install
+-------
+
+Install the project using `Poetry <https://python-poetry.org/docs/#installation>`_:
+
+.. code-block:: console
+
+    $ poetry install --with dev
+    Installing dependencies from lock file
+    ...
+    Installing the current project: pf-video-transcribe
+
+This project uses `Faster Whisper <https://pypi.org/project/faster-whisper/>`_,
+a faster implementation of `OpenAI's Whisper <https://openai.com/research/whisper>`_,
+which in turn is built on top of `CTranslate2 <https://opennmt.net/CTranslate2/index.html>`_
+hardware optimizations, that requires installation of **NVidia CUDA libraries**, see
+`their installation instructions <https://opennmt.net/CTranslate2/installation.html>`_.
+
+Run
+---
+
+Run the command line tool:
+
+.. code-block:: console
+
+    $ pf-video-transcribe --help
+
+All commands take ``--log=LEVEL`` or ``--log=DOMAIN:LEVEL`` to change the
+log level of every package, such as ``pf_video_transcribe.transcribe``,
+``faster_whisper`` and so on. If no domain is given, then the provided level
+applies to all log domains. This is a global option and should be specified
+before the subcommand.
+
+Subcommands are explained in the next sections.
+
+Transcription
+=============
+
+Given that the transcription is a heavy process and takes a lot to load the model
+and then to process each media file, it's implemented as a batch operation that
+generates an intermediate in the `JSON Lines <https://jsonlines.org/>`_
+(``".jsonl"``) format, with a ``"header"`` line followed by all the ``"segment"``,
+ended by a ``"finished"`` line with success or failure indicator. Each ``segment``
+carries the useful information extracted by
+`OpenAI Whisper <https://github.com/openai/whisper>`_:
+
+.. code-block:: console
+
+    $ pf-video-transcribe transcribe videos/my-video.mp4 videos/other-video.mp4
+
+
+This will generate ``videos/my-video.jsonl`` and ``videos/other-video.jsonl``.
+
+Note that the first time it will take a lot to download the model from the internet.
+In the next iterations, the local model will be used, but first they will be checked
+remotely -- which can also take time. Using the ``--local`` flag will skip that check.
+
+The language is auto-detected from the first 30 seconds of actual sound (silent is
+ignored), but if you do know the language, use the ``--language=LANG`` flag.
+
+Audio Speech Recognition (ASR) models work on slices of the media, producing segments
+that are smaller than an actual human language sentence/phrase.
+The ``--merge-threshold=SECONDS`` will merge sibling segments if:
+``next_segment.start - last_segment.end <= merge_threshold``. The default is 1 second.
+
+A more complex example:
+
+.. code-block:: console
+
+    $ pf-video-transcribe \
+          --log=DEBUG \
+          transcribe \
+          --local \
+          --language=pt \
+          --merge-threshold=5 \
+          videos/my-video.mp4 videos/other-video.mp4
+
+With the transcribed ``".jsonl"`` one can convert to more usable formats,
+see the next sections.
+
+
+Convert to HTML
+===============
+
+This generates the HTML meant to easy viewing of the result, a ``<video>`` linking
+to the transcribed media alongside a ``<track kind="subtitles">`` linking to the
+subtitles, the thumbnail to be used by `OpenGraph <https://ogp.me/>`_ ``og:image``
+and the actual transcription segments.
+
+Note: both ``.vtt`` (subtitles) and ``.jpeg`` (thumbnail) are auto-generated
+if they don't exist or if they are older than the actual input ``.jsonl``.
+
+
+Convert to VTT
+==============
+
+Web Video Text Track is a subtitle specified by the
+`W3C <https://w3c.github.io/webvtt/>`_ and used by all web browsers whenever
+specified inside the ``<video>`` element.
+
+The conversion takes parameter ``--duration-threshold=SECONDS`` to control the maximum
+duration of a single subtitle entry.
+
+.. code-block:: console
+
+    $ pf-video-transcribe vtt videos/*.jsonl
+
+
+Convert to SRT
+==============
+
+SRT or SubRip is a defacto standard subtitle format that most media players will take.
+The conversion takes parameter ``--duration-threshold=SECONDS`` to control the maximum
+duration of a single subtitle entry.
+
+.. code-block:: console
+
+    $ pf-video-transcribe srt videos/*.jsonl
+
+
+Create Thumbnail
+================
+
+Uses `FFmpeg <https://ffmpeg.org/>`_ to generate a thumbnail from the video or
+its transcription. The ``--size=WIDTHxHEIGHT`` allows to override the default
+``320x-1`` (-1 is used to calculate that dimension from the other, keeping the
+aspect ratio).
+
+.. code-block:: console
+
+    $ pf-video-transcribe thumbnail videos/*.jsonl
+
+
+Creating Index HTML
+===================
+
+Recursively scans the given directories looking for ``.html`` files, which
+can be produced by this tool or not. The generated index will take the ``<title>``
+and ``<meta property="og:image">`` to gather the actual title or preview.
+
+It's a very simple way to generate a landing page.
+
+.. code-block:: console
+
+    $ pf-video-transcribe index_html videos/
+
+
+Serving (Development)
+=====================
+
+While developing this tool or playing with parameters it's useful to serve
+the files from ``http://`` as the ``file://`` will have some issues with
+video files (security limitations). By default serves at ``--port=8000``.
+
+.. code-block:: console
+
+    $ pf-video-transcribe serve videos/
+
+
+Development
+-----------
+
+Install the project with development dependencies:
+
+.. code-block:: console
+
+    $ poetry install --with dev
+    Installing dependencies from lock file
+    ...
+    Installing the current project: pf-video-transcribe
+
+
+Install `pre-commit <https://pre-commit.com/>`_ in your machine, then install the GIT Hooks:
+
+.. code-block:: console
+
+    $ pre-commit install
+    pre-commit installed at .git/hooks/pre-commit
+    pre-commit installed at .git/hooks/pre-push
+    pre-commit installed at .git/hooks/pre-merge-commit
+
+
+Used tools:
+
+* Code Formatter: `Black <https://black.readthedocs.io/>`_
+* Static Type Checker: `MyPy <https://mypy.readthedocs.io/>`_
+* Style Enforcement/Linter: `Flake8 <https://flake8.pycqa.org/>`_
diff --git a/pf_video_transcribe/__init__.py b/pf_video_transcribe/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/__main__.py b/pf_video_transcribe/__main__.py
new file mode 100644
index 0000000..0b2ef74
--- /dev/null
+++ b/pf_video_transcribe/__main__.py
@@ -0,0 +1,40 @@
+import argparse
+
+from . import log
+from .html import cli as html
+from .index_html import cli as index_html
+from .serve import cli as serve
+from .srt import cli as srt
+from .thumbnail import cli as thumbnail
+from .transcribe import cli as transcribe
+from .vtt import cli as vtt
+
+
+def create_arg_parser() -> argparse.ArgumentParser:
+    ap = argparse.ArgumentParser()
+    log.add_arguments(ap)
+
+    sub = ap.add_subparsers()
+    transcribe.add_sub_parser(sub)
+    html.add_sub_parser(sub)
+    vtt.add_sub_parser(sub)
+    srt.add_sub_parser(sub)
+    thumbnail.add_sub_parser(sub)
+    index_html.add_sub_parser(sub)
+    serve.add_sub_parser(sub)
+
+    return ap
+
+
+def cli() -> None:
+    ap = create_arg_parser()
+    args = ap.parse_args()
+    log.config(args)
+
+    handle = getattr(args, "handle", None)
+    if handle is not None:
+        handle(args)
+
+
+if __name__ == "__main__":
+    cli()
diff --git a/pf_video_transcribe/abstract_subtitles/__init__.py b/pf_video_transcribe/abstract_subtitles/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/abstract_subtitles/cli.py b/pf_video_transcribe/abstract_subtitles/cli.py
new file mode 100644
index 0000000..c2ef1c9
--- /dev/null
+++ b/pf_video_transcribe/abstract_subtitles/cli.py
@@ -0,0 +1,43 @@
+from argparse import ArgumentParser
+import textwrap
+
+from ..utils import check_file_exists
+
+
+def add_arguments(ap: ArgumentParser, add_files: bool) -> None:
+    ap.add_argument(
+        "-t",
+        "--duration-threshold",
+        type=float,
+        default=10.0,
+        help=textwrap.dedent(
+            """\
+            Duration (in seconds) to split each segment. The split will
+            happen at word boundary, no words will be split.
+
+            Default: %(default)s seconds
+        """
+        ),
+    )
+    ap.add_argument(
+        "-f",
+        "--force",
+        default=False,
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+            Force regeneration of existing files.
+
+            By default, if the generated file timestamp (mtime) is newer than the
+            source (jsonl), then it will be skipped.
+        """
+        ),
+    )
+
+    if add_files:
+        ap.add_argument(
+            "file",
+            nargs="+",
+            help="jsonl file to be processed",
+            type=check_file_exists,
+        )
diff --git a/pf_video_transcribe/abstract_subtitles/converter.py b/pf_video_transcribe/abstract_subtitles/converter.py
new file mode 100644
index 0000000..3a65be9
--- /dev/null
+++ b/pf_video_transcribe/abstract_subtitles/converter.py
@@ -0,0 +1,18 @@
+from typing import TypedDict
+
+from ..converter import AbstractJsonlConverter
+from ..jsonl.reader import Reader
+from ..utils import iter_split_segments
+
+KT = TypedDict(
+    "KT",
+    {
+        "duration_threshold": float,
+    },
+)
+
+
+class AbstractSubtitlesConverter(AbstractJsonlConverter[KT]):
+    def get_template_context(self, reader: Reader) -> dict:
+        duration_threshold = self.kwargs["duration_threshold"]
+        return {"segments": iter_split_segments(iter(reader), duration_threshold)}
diff --git a/pf_video_transcribe/converter.py b/pf_video_transcribe/converter.py
new file mode 100644
index 0000000..66fcfc7
--- /dev/null
+++ b/pf_video_transcribe/converter.py
@@ -0,0 +1,108 @@
+from abc import ABC
+from abc import abstractmethod
+from typing import Any
+from typing import Callable
+from typing import cast
+from typing import ClassVar
+from typing import Generic
+from typing import Mapping
+from typing import Sequence
+from typing import TypeVar
+
+from termcolor import colored
+
+from .jsonl.reader import Reader
+from .templates import get_template
+from .utils import needs_generate
+from .utils import replace_ext
+
+T = TypeVar("T", bound="AbstractConverter")
+KT = TypeVar("KT", bound=Mapping[str, Any])
+
+
+class AbstractConverter(ABC):
+    ext: ClassVar[str]
+    logger: ClassVar[Callable[[str], None]]
+
+    force: bool
+    input_filename: str
+    filename: str
+    generated: bool
+
+    def __init__(
+        self,
+        input_filename: str,
+        force: bool,
+    ) -> None:
+        self.input_filename = input_filename
+        self.force = force
+        self.filename = self.create_output_name(input_filename)
+        self.generated = False
+        self._write()
+
+    @classmethod
+    def create_output_name(self, input_filename: str) -> str:
+        return replace_ext(input_filename, self.ext)
+
+    def _needs_generate(self) -> bool:
+        if self.force:
+            return True
+        return needs_generate(self.input_filename, self.filename)
+
+    @abstractmethod
+    def generate(self) -> None:
+        raise NotImplementedError()
+
+    def _write(self) -> None:
+        logger = self.__class__.logger  # mypy is getting it wrong from self.logger
+        if not self._needs_generate():
+            logger(
+                "Up to date: "
+                + colored(self.filename, "green")
+                + f" (from: {self.input_filename})"
+            )
+            return
+
+        self.generate()
+
+        logger(
+            "Saved: "
+            + colored(self.filename, "cyan")
+            + f" (from: {self.input_filename})"
+        )
+        self.generated = False
+
+    @classmethod
+    def batch(
+        cls: type[T],
+        input_filenames: Sequence[str],
+        force: bool,
+        **kwargs: object,
+    ) -> Sequence[T]:
+        return [cls(f, force, **kwargs) for f in input_filenames]
+
+
+class AbstractJsonlConverter(AbstractConverter, Generic[KT]):
+    template_name: ClassVar[str]
+
+    kwargs: KT
+
+    def __init__(
+        self,
+        input_filename: str,
+        force: bool,
+        **kwargs: Any,
+    ) -> None:
+        self.kwargs = cast(KT, kwargs)
+        super().__init__(input_filename, force)
+
+    def generate(self) -> None:
+        tmpl = get_template(self.template_name)
+        with Reader(self.input_filename) as reader:
+            ctx = self.get_template_context(reader)
+            with open(self.filename, "w") as out:
+                for chunk in tmpl.generate(**ctx):
+                    out.write(chunk)
+
+    def get_template_context(self, reader: Reader) -> Mapping[str, object]:
+        return {**self.kwargs, "reader": reader}
diff --git a/pf_video_transcribe/html/__init__.py b/pf_video_transcribe/html/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/html/__main__.py b/pf_video_transcribe/html/__main__.py
new file mode 100644
index 0000000..4e28416
--- /dev/null
+++ b/pf_video_transcribe/html/__main__.py
@@ -0,0 +1,3 @@
+from .cli import main
+
+main()
diff --git a/pf_video_transcribe/html/cli.py b/pf_video_transcribe/html/cli.py
new file mode 100644
index 0000000..6641bde
--- /dev/null
+++ b/pf_video_transcribe/html/cli.py
@@ -0,0 +1,140 @@
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+from argparse import RawTextHelpFormatter
+import textwrap
+
+from .. import log
+from ..types import Size
+from ..utils import parse_size
+from ..vtt import cli as vtt
+
+description = """\
+Loads transcribed jsonl (JSON Lines) file and generate HTML.
+
+The generated HTML page will include a video viewer using WebVTT and
+the transcriptions.
+
+By default it will use its own CSS and JavaScript, that will keep
+the video and transcriptions in sync. These files will be copied to
+the same folder as the generated HTML.
+
+However, if custom stylesheet or script are to be used, they can be overridden
+with ``stylesheet`` and ``--javascript``. In such case, no files will be
+copied.
+"""
+
+
+def handle_command(args: Namespace) -> None:
+    # avoid loading heavy libraries in the command line
+    from .converter import HTMLConverter
+    from ..vtt.converter import VTTConverter
+    from ..thumbnail.converter import ThumbnailConverter
+
+    VTTConverter.batch(
+        args.file,
+        args.force,
+        duration_threshold=args.duration_threshold,
+    )
+    ThumbnailConverter.batch(args.file, args.force, size=args.thumb_size)
+    HTMLConverter.batch(
+        args.file,
+        args.force,
+        html_head_entry=args.html_head_entry,
+        stylesheet=args.stylesheet,
+        javascript=args.javascript,
+    )
+
+
+def add_arguments(ap: ArgumentParser) -> None:
+    vtt.add_arguments(ap)
+    ap.add_argument(
+        "--html-head-entry",
+        action="append",
+        default=[],
+        help=textwrap.dedent(
+            """\
+            Lines to be added to <head>.
+
+            They will be passed as is and won't be checked/parsed.
+            """
+        ),
+    )
+    ap.add_argument(
+        "--stylesheet",
+        default="",
+        help=textwrap.dedent(
+            """\
+            Use the CSS stylesheet instead of the built-in.
+
+            Note that the stylesheet must provide all the theme, it's
+            NOT an override.
+
+            Note it will be passed as is, it can be an URL of a remote file
+            or a relative path. The given value will NOT be accessed or
+            copied.
+            """
+        ),
+    )
+    ap.add_argument(
+        "--javascript",
+        default="",
+        help=textwrap.dedent(
+            """\
+            Use the JavaScript instead of the built-in.
+
+            Note that the script must implement all the behavior, it's
+            NOT an override.
+
+            Note it will be passed as is, it can be an URL of a remote file
+            or a relative path. The given value will NOT be accessed or
+            copied.
+            """
+        ),
+    )
+    ap.add_argument(
+        "--thumb-size",
+        type=parse_size,
+        default=Size(320, -1),
+        help=textwrap.dedent(
+            """\
+            Specify the thumbnail (JPEG) size.
+
+            Use format: WIDTHxHEIGHT.
+
+            If one of WIDTH or HEIGHT are -1, they will be calculated based
+            on the other dimension.
+
+            Default: %(default)s
+        """
+        ),
+    )
+
+
+def add_sub_parser(sub: _SubParsersAction) -> ArgumentParser:
+    ap = sub.add_parser(
+        "html",
+        help="Convert '.jsonl' into HTML with video and transcriptions",
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    add_arguments(ap)
+    ap.set_defaults(handle=handle_command)
+    return ap
+
+
+def create_argument_parser() -> ArgumentParser:
+    ap = ArgumentParser(
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    log.add_arguments(ap)
+    add_arguments(ap)
+    return ap
+
+
+def main() -> None:
+    ap = create_argument_parser()
+    args = ap.parse_args()
+    log.config(args)
+    handle_command(args)
diff --git a/pf_video_transcribe/html/converter.py b/pf_video_transcribe/html/converter.py
new file mode 100644
index 0000000..bdd55a1
--- /dev/null
+++ b/pf_video_transcribe/html/converter.py
@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import functools
+import importlib.resources
+import logging
+from mimetypes import guess_type
+import os.path
+import re
+import shutil
+from typing import TypedDict
+
+from termcolor import colored
+
+from ..converter import AbstractJsonlConverter
+from ..jsonl.reader import Reader
+from ..thumbnail.converter import ThumbnailConverter
+from ..vtt.converter import VTTConverter
+
+
+_logger = logging.getLogger(__name__.replace(".converter", ""))
+_inf = functools.partial(_logger.log, logging.INFO)
+
+_clean_title_from_path_re = re.compile(
+    r"[^a-zA-Z0-9:_]",
+)
+
+
+def _gen_title_from_filename(filename: str) -> str:
+    name = os.path.splitext(os.path.basename(filename))[0]
+    return _clean_title_from_path_re.sub(" ", name).title()
+
+
+KT = TypedDict(
+    "KT",
+    {
+        "html_head_entry": list[str],
+        "stylesheet": str,
+        "javascript": str,
+    },
+)
+
+
+class HTMLConverter(AbstractJsonlConverter[KT]):
+    ext = "html"
+    template_name = "write.html.jinja2"
+    logger = _inf
+
+    default_resource_name = __name__.replace(".html.converter", "")
+
+    def get_template_context(self, reader: Reader) -> dict:
+        media_filename = reader.media_filename
+        base_media_filename = os.path.basename(media_filename)
+        mime_type = guess_type(media_filename)[0]
+        vtt_filename = VTTConverter.create_output_name(base_media_filename)
+        image = ThumbnailConverter.create_output_name(media_filename)
+        if os.path.isfile(image):
+            image = os.path.basename(image)
+        else:
+            image = ""
+
+        html_head_entry = self.kwargs["html_head_entry"]
+
+        return {
+            "javascript": self._get_and_copy_javascript(),
+            "stylesheet": self._get_and_copy_stylesheet(),
+            "html_head_entry": html_head_entry,
+            "image": image,
+            "language": reader.language,
+            "media_filename": base_media_filename,
+            "mime_type": mime_type,
+            "title": _gen_title_from_filename(media_filename),
+            "vtt_filename": vtt_filename,
+            "segments": iter(reader),
+        }
+
+    def _get_and_copy_stylesheet(self) -> str:
+        stylesheet = self.kwargs["stylesheet"]
+        if stylesheet:
+            return stylesheet
+        return self._get_and_copy_default("css")
+
+    def _get_and_copy_javascript(self) -> str:
+        javascript = self.kwargs["javascript"]
+        if javascript:
+            return javascript
+        return self._get_and_copy_default("js")
+
+    def _get_and_copy_default(self, ext: str) -> str:
+        dst_name = f"{self.default_resource_name}{os.path.extsep}{ext}"
+        dst_path = os.path.join(os.path.dirname(self.filename), dst_name)
+        if os.path.exists(dst_path):
+            _inf("Already exists " + colored(dst_path, "cyan"))
+            return dst_name
+        src = importlib.resources.open_text(__package__, f"default.{ext}")
+        with open(dst_path, "x") as dst:
+            _inf("Created " + colored(dst_path, "cyan"))
+            shutil.copyfileobj(src, dst)
+        return dst_name
diff --git a/pf_video_transcribe/html/default.css b/pf_video_transcribe/html/default.css
new file mode 100644
index 0000000..d7e76cf
--- /dev/null
+++ b/pf_video_transcribe/html/default.css
@@ -0,0 +1,74 @@
+@import url("https://fonts.googleapis.com/css2?family=Exo+2:wght@100;400;700&display=swap");
+
+body {
+    font-family: "Exo 2", sans-serif;
+    font-size: 1rem;
+    line-height: 1.5rem;
+    color: #fff;
+    background-color: #000;
+}
+video#viewer {
+    border: 1px solid #2f334b;
+    display: block;
+    height: 60vh;
+    margin: auto;
+}
+div#transcription {
+    color: #2f334b;
+    background-color: #fff;
+    height: 40vh;
+    overflow: scroll;
+}
+div.segment {
+    display: flex;
+    justify-content: center;
+    margin-bottom: 1rem;
+}
+div.segment:hover {
+    background-color: #eee;
+}
+a.timestamp {
+    flex: 0 0 6.5rem;
+    font-size: 0.8rem;
+    line-height: 1.5rem;
+    color: #ccc;
+    text-decoration: none;
+}
+div.segment.active > a.timestamp {
+    color: #63c3d1;
+}
+a.timestamp > span.start::after {
+    content: "→";
+}
+p.text {
+    flex-grow: 1;
+    max-width: 60vw;
+    padding-left: 0.5rem;
+    margin: 0 5rem 0 0;
+    color: #999;
+}
+div.segment.active > p.text,
+div.segment:hover > p.text {
+    color: #2f334b;
+}
+span.word.active {
+    text-decoration: underline;
+    text-decoration-color: #999;
+}
+button#go-to-current {
+    position: absolute;
+    right: 0;
+    top: 60vh;
+    font-family: "Exo 2", sans-serif;
+    font-size: 0.8rem;
+    color: #fff;
+    background-color: #63c3d1;
+    border: 0;
+    border-radius: 1rem;
+    margin: 1rem;
+    padding: 0.5rem;
+    opacity: 0;
+}
+button#go-to-current.visible {
+    opacity: 1;
+}
diff --git a/pf_video_transcribe/html/default.js b/pf_video_transcribe/html/default.js
new file mode 100644
index 0000000..ca0886e
--- /dev/null
+++ b/pf_video_transcribe/html/default.js
@@ -0,0 +1,141 @@
+function createTimeActiveTracker(videoEl, className) {
+    function getStart(element) {
+        const { dataset: { start } } = element;
+        if (start === undefined) {
+            if (element.parentNode) {
+                return getStart(element.parentNode);
+            }
+        }
+        return start;
+    }
+
+    function seek(clickEvent) {
+        clickEvent.preventDefault();
+        const start = getStart(clickEvent.target)
+        if (start == undefined) {
+            console.warn("missing dataset.start:", clickEvent);
+            return;
+        }
+        console.log("seek to:", className, start);
+        videoEl.currentTime = start;
+    }
+
+    const array = [];
+    for (const element of document.getElementsByClassName(className)) {
+        const start = Number(element.dataset.start);
+        const end = Number(element.dataset.end);
+        array.push({ start, end, element });
+        element.onclick = seek;
+    }
+
+    let currentIdx;
+
+    function findTime(time, backwards) {
+        const start = currentIdx || 0;
+        if (backwards) {
+            for (let i = start; i >= 0; i--) {
+                const { start, end } = array[i];
+                if (start <= time && time <= end) {
+                    return [i, true];
+                }
+                if (time > end) {
+                    return [i, false];
+                }
+            }
+        } else {
+            for (let i = start; i < array.length; i++) {
+                const { start, end } = array[i];
+                if (start <= time && time <= end) {
+                    return [i, true];
+                }
+                if (time < start) {
+                    return [i, false];
+                }
+            }
+        }
+        return [0, false];
+    }
+
+    return function update(time) {
+        let backwards = false;
+        if (currentIdx !== undefined) {
+            backwards = time < array[currentIdx].start;
+        }
+        const [i, found] = findTime(time, backwards);
+        if (i === currentIdx || !found) {
+            if (currentIdx !== undefined) {
+                return array[currentIdx].element;
+            }
+            return undefined;
+        }
+        if (currentIdx !== undefined) {
+            const oldEl = array[currentIdx].element;
+            oldEl.classList.remove("active");
+        }
+        const newEl = array[i].element;
+        newEl.classList.add("active");
+        currentIdx = i;
+        return newEl;
+    };
+}
+
+function createGoToCurrentTracker() {
+    let currentEl;
+
+    const viewportEl = document.getElementById("transcription");
+
+    const goToCurrentButton = document.createElement("button");
+    goToCurrentButton.id = "go-to-current";
+    goToCurrentButton.textContent = "Focus Current Time";
+    goToCurrentButton.onclick = function goToCurrent() {
+        if (currentEl) {
+            console.log("focus current time:", currentEl);
+            currentEl.scrollIntoView({ behavior: "smooth", block: "center" });
+        }
+    };
+    viewportEl.insertBefore(goToCurrentButton, viewportEl.firstChild);
+
+    function onIntersection(entries) {
+      entries.forEach(entry => {
+        goToCurrentButton.classList.toggle("visible", !entry.isIntersecting);
+      });
+    }
+
+    const observer = new IntersectionObserver(onIntersection, {
+      root: viewportEl,
+      threshold: 0.5,
+    });
+
+    return function update(el) {
+        if (currentEl === el) {
+            return;
+        }
+        if (currentEl) {
+            observer.unobserve(currentEl);
+        }
+        currentEl = el;
+        if (currentEl) {
+            observer.observe(currentEl);
+        }
+    };
+}
+
+function onLoad() {
+    const videoEl = document.getElementById("viewer");
+    videoEl.autoplay = true;
+    videoEl.controls = true;
+    videoEl.preload = "auto";
+
+    const goToCurrentTracker = createGoToCurrentTracker();
+
+    const segmentsTracker = createTimeActiveTracker(videoEl, "segment");
+    const wordsTracker = createTimeActiveTracker(videoEl, "word");
+
+    videoEl.ontimeupdate = () => {
+        const time = videoEl.currentTime;
+        segmentsTracker(time);
+        goToCurrentTracker(wordsTracker(time));
+    };
+}
+
+window.addEventListener("DOMContentLoaded", onLoad);
diff --git a/pf_video_transcribe/index_html/__init__.py b/pf_video_transcribe/index_html/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/index_html/__main__.py b/pf_video_transcribe/index_html/__main__.py
new file mode 100644
index 0000000..4e28416
--- /dev/null
+++ b/pf_video_transcribe/index_html/__main__.py
@@ -0,0 +1,3 @@
+from .cli import main
+
+main()
diff --git a/pf_video_transcribe/index_html/cli.py b/pf_video_transcribe/index_html/cli.py
new file mode 100644
index 0000000..da86ff6
--- /dev/null
+++ b/pf_video_transcribe/index_html/cli.py
@@ -0,0 +1,68 @@
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+from argparse import RawTextHelpFormatter
+
+from .. import log
+from ..abstract_subtitles import cli as abstract_cli
+from ..utils import check_dir_exists
+
+description = """\
+Lists all '.html' in a directory and creates an 'index.html'
+with link to them all.
+
+This can be used to generate a nice landing page for all generated videos.
+
+If '.jsonl' are found without matching '.html', the html (and vtt) will
+be generated automatically.
+"""
+
+
+def handle_command(args: Namespace) -> None:
+    # avoid loading heavy libraries in the command line
+    from .work import index_batch
+
+    index_batch(
+        args.directory,
+        args.force,
+        args.duration_threshold,
+    )
+
+
+def add_arguments(ap: ArgumentParser) -> None:
+    abstract_cli.add_arguments(ap, False)
+    ap.add_argument(
+        "directory",
+        nargs="+",
+        help="directory to be processed",
+        type=check_dir_exists,
+    )
+
+
+def add_sub_parser(sub: _SubParsersAction) -> ArgumentParser:
+    ap = sub.add_parser(
+        "index_html",
+        help="Creates index.html for the directories",
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    add_arguments(ap)
+    ap.set_defaults(handle=handle_command)
+    return ap
+
+
+def create_argument_parser() -> ArgumentParser:
+    ap = ArgumentParser(
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    log.add_arguments(ap)
+    add_arguments(ap)
+    return ap
+
+
+def main() -> None:
+    ap = create_argument_parser()
+    args = ap.parse_args()
+    log.config(args)
+    handle_command(args)
diff --git a/pf_video_transcribe/index_html/html_info.py b/pf_video_transcribe/index_html/html_info.py
new file mode 100644
index 0000000..2601cb8
--- /dev/null
+++ b/pf_video_transcribe/index_html/html_info.py
@@ -0,0 +1,79 @@
+from html.parser import HTMLParser
+from typing import NamedTuple
+
+
+class HtmlInfo(NamedTuple):
+    path: str
+    title: str
+    image: str
+    video: str
+
+
+class HtmlInfoParser(HTMLParser):
+    trail: list[tuple[str, list[tuple[str, str | None]]]]
+    title: str
+    image: str
+    video: str
+    finished_head: bool
+
+    def __init__(self, *, convert_charrefs: bool = True) -> None:
+        super().__init__(convert_charrefs=convert_charrefs)
+        self.trail = []
+        self.title = ""
+        self.image = ""
+        self.video = ""
+        self.finished_head = False
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self.trail.append((tag, attrs))
+
+    def handle_endtag(self, tag: str) -> None:
+        if self.trail and self.trail[-1][0] == tag:
+            tag, _ = self.trail.pop()
+            if tag == "head":
+                self.finished_head = True
+
+    def handle_data(self, data: str) -> None:
+        if len(self.trail) < 3:
+            return
+        if self.trail[-2][0] != "head":
+            return
+        tag, attrs_tuple = self.trail[-1]
+        if tag == "title":
+            self.title += data
+            return
+
+    def handle_startendtag(
+        self, tag: str, attrs_tuple: list[tuple[str, str | None]]
+    ) -> None:
+        if self.image and self.video:
+            return
+        if tag == "meta":
+            attrs = dict(attrs_tuple)
+            prop = attrs.get("property")
+            if not prop:
+                return
+            content = attrs.get("content")
+            if not content:
+                return
+            if prop == "og:image":
+                self.image = content
+            elif prop == "og:video":
+                self.video = content
+
+
+def parse_html_info(prefix_len: int, path: str) -> HtmlInfo:
+    with open(path) as file:
+        parser = HtmlInfoParser()
+        for line in file:
+            parser.feed(line)
+            if parser.finished_head:
+                break
+
+        rel_path = path[prefix_len:]
+        return HtmlInfo(
+            path=rel_path,
+            title=parser.title.strip() or rel_path,
+            image=parser.image.strip(),
+            video=parser.video.strip(),
+        )
diff --git a/pf_video_transcribe/index_html/work.py b/pf_video_transcribe/index_html/work.py
new file mode 100644
index 0000000..0d60e7b
--- /dev/null
+++ b/pf_video_transcribe/index_html/work.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import functools
+import logging
+import os
+from typing import Iterator
+from typing import Sequence
+
+from termcolor import colored
+
+from .html_info import HtmlInfo
+from .html_info import parse_html_info
+from ..html.converter import HTMLConverter
+from ..templates import get_template
+from ..vtt.converter import VTTConverter
+
+
+_logger = logging.getLogger(__name__.replace(".work", ""))
+_inf = functools.partial(_logger.log, logging.INFO)
+
+
+def collect(directory: str) -> dict[str, set[str]]:
+    collected: dict[str, set[str]] = {}
+
+    for root, dirs, files in os.walk(directory):
+        for dname in tuple(dirs):
+            if dname.startswith("."):
+                dirs.remove(dname)
+        for fname in files:
+            if fname.startswith(".") or fname == "index.html":
+                continue
+            path = os.path.join(root, fname)
+            ext = os.path.splitext(path)[1]
+            collected.setdefault(ext, set()).add(path)
+
+    return collected
+
+
+def generate_vtt(
+    jsonl_filenames: Sequence[str], force: bool, duration_threshold: float
+) -> Iterator[str]:
+    for c in VTTConverter.batch(
+        jsonl_filenames,
+        force,
+        duration_threshold=duration_threshold,
+    ):
+        yield c.filename
+
+
+def generate_html(jsonl_filenames: Sequence[str], force: bool) -> Iterator[str]:
+    for c in HTMLConverter.batch(jsonl_filenames, force):
+        yield c.filename
+
+
+def index(directory: str, force: bool, duration_threshold: float) -> None:
+    by_ext = collect(directory)
+    jsonl_filenames = tuple(by_ext[".jsonl"])
+
+    for f in generate_vtt(jsonl_filenames, force, duration_threshold):
+        by_ext[".vtt"].add(f)
+
+    for f in generate_html(jsonl_filenames, force):
+        by_ext[".html"].add(f)
+
+    html_paths = sorted(by_ext[".html"])
+    prefix_len = len(directory + os.path.sep)
+    groups: dict[str, list[HtmlInfo]] = {}
+    recent_mtime = 0.0
+    for path in html_paths:
+        dname = os.path.dirname(path)
+        groups.setdefault(dname, []).append(parse_html_info(prefix_len, path))
+        mtime = os.stat(path).st_mtime
+        if recent_mtime < mtime:
+            recent_mtime = mtime
+
+    filename = os.path.join(directory, "index.html")
+    try:
+        mtime = os.stat(filename).st_mtime
+    except OSError:
+        mtime = 0
+    if mtime > recent_mtime and not force:
+        _inf("Up to date: " + colored(filename, "green"))
+        return
+
+    tmpl = get_template("index.html.jinja2")
+    with open(filename, "w") as out:
+        for chunk in tmpl.generate(groups=sorted(groups.items())):
+            out.write(chunk)
+
+    _inf("Saved: " + colored(filename, "cyan"))
+
+
+def index_batch(
+    directories: Sequence[str], force: bool, duration_threshold: float
+) -> None:
+    for d in directories:
+        index(d, force, duration_threshold)
diff --git a/pf_video_transcribe/jsonl/__init__.py b/pf_video_transcribe/jsonl/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/jsonl/reader.py b/pf_video_transcribe/jsonl/reader.py
new file mode 100644
index 0000000..4119510
--- /dev/null
+++ b/pf_video_transcribe/jsonl/reader.py
@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+from typing import cast
+from typing import Iterator
+from typing import Optional
+from typing import Self
+from typing import TextIO
+
+from ..types import FinishedPayloadJson
+from ..types import HeaderInfoJson
+from ..types import HeaderLineJson
+from ..types import LineJson
+from ..types import SegmentPayloadJson
+
+
+class Reader:
+    ENCODER_VERSION = "1.0"
+
+    filename: str
+    _file: TextIO
+    info: HeaderInfoJson
+    media_filename: str
+    finished: Optional[FinishedPayloadJson]
+
+    def __init__(
+        self,
+        filename: str,
+    ) -> None:
+        self.filename = filename
+        self._file = open(self.filename, "r")
+        self.finished = None
+        self._read_header()
+
+    def __del__(self) -> None:
+        # object may have failed to open
+        file = getattr(self, "_file", None)
+        if file is not None and not file.closed:
+            file.close()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Any,
+        exc_value: Any,
+        traceback: Any,
+    ) -> None:
+        self._file.close()
+
+    def __iter__(self) -> Iterator[SegmentPayloadJson]:
+        return self
+
+    def __next__(self) -> SegmentPayloadJson:
+        while True:
+            data = self._read_line()
+            finished = data.get("finished")
+            if finished:
+                self.finished = cast(FinishedPayloadJson, finished)
+                raise StopIteration
+            segment = data.get("segment")
+            if segment:
+                return cast(SegmentPayloadJson, segment)
+
+    def _read_line(self) -> LineJson:
+        line = self._file.readline()
+        if not line:
+            raise StopIteration
+        return json.loads(line)
+
+    def _read_header(self) -> None:
+        data = cast(HeaderLineJson, self._read_line())
+        try:
+            header = data["header"]
+            version = header["encoder_version"]
+            if version != self.ENCODER_VERSION:
+                # TODO: whenever we change, add some migration
+                raise ValueError(f"unsupported encoder_version: {version}")
+            self.info = header["info"]
+            self.media_filename = os.path.join(
+                os.path.dirname(self.filename), header["media_filename"]
+            )
+        except (TypeError, KeyError) as e:
+            raise ValueError(f"Invalid header {data!r}: {e}") from e
+
+    @property
+    def language(self) -> str:
+        return self.info["language"]
diff --git a/pf_video_transcribe/jsonl/writer.py b/pf_video_transcribe/jsonl/writer.py
new file mode 100644
index 0000000..2719878
--- /dev/null
+++ b/pf_video_transcribe/jsonl/writer.py
@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import os.path
+from typing import Any
+from typing import Optional
+from typing import Self
+from typing import TextIO
+
+from ..types import HeaderInfoJson
+from ..types import LineJson
+from ..types import SegmentPayloadJson
+from ..types import WordJson
+from ..utils import format_timestamp
+from ..utils import merge_text
+from ..utils import replace_ext
+
+
+@dataclass(slots=True)
+class CoalescedSegment:
+    start: float
+    end: float
+    text: str
+    words: list[WordJson]
+
+    def __init__(self, init: SegmentPayloadJson) -> None:
+        self.start = init["start"]
+        self.end = init["end"]
+        self.text = init["text"]
+        self.words = list(init["words"])
+
+    def merge(self, other: SegmentPayloadJson) -> None:
+        self.end = other["end"]
+        self.text = merge_text(self.text, other["text"])
+        self.words += other["words"]
+
+    def tojson(self) -> SegmentPayloadJson:
+        return {
+            "start": self.start,
+            "end": self.end,
+            "text": self.text,
+            "words": self.words,
+        }
+
+    def __repr__(self) -> str:
+        start = format_timestamp(self.start)
+        end = format_timestamp(self.end)
+        return f"<{start}..{end} {self.text!r}>"
+
+
+class Writer:
+    ENCODER_VERSION = "1.0"
+
+    media_filename: str
+    filename: str
+    _segment: Optional[CoalescedSegment]
+    _file: TextIO
+
+    merge_threshold: float  # seconds between segments, if <=, then merge with previous
+
+    def __init__(
+        self,
+        media_filename: str,
+        info: HeaderInfoJson,
+        merge_threshold: float,
+    ) -> None:
+        self.media_filename = os.path.basename(media_filename)
+        self.merge_threshold = merge_threshold
+        self.filename = self.create_output_name(media_filename)
+        self._segment = None
+        self._file = open(self.filename, "w")
+        self._write_header(info)
+
+    @classmethod
+    def create_output_name(self, media_filename: str) -> str:
+        return replace_ext(media_filename, "jsonl")
+
+    def __del__(self) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if not self._file.closed:
+            self._finish(None)
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Any,
+        exc_value: Any,
+        traceback: Any,
+    ) -> None:
+        self._finish(exc_value)
+
+    def _write_header(self, info: HeaderInfoJson) -> None:
+        self._write(
+            {
+                "header": {
+                    "encoder_version": self.ENCODER_VERSION,
+                    "info": info,
+                    "media_filename": self.media_filename,
+                },
+            }
+        )
+
+    def _finish(self, exc_value: Any) -> None:
+        if self._file.closed:
+            return
+
+        self._flush_segment()
+        if exc_value is None:
+            self._write({"finished": {"ok": True}})
+        else:
+            self._write({"finished": {"ok": False, "exc": str(exc_value)}})
+        self._file.close()
+
+    def _write(self, line: LineJson) -> None:
+        json.dump(
+            line,
+            self._file,
+            ensure_ascii=False,
+            indent=None,
+            separators=(",", ":"),
+        )
+        self._file.write("\n")
+        self._file.flush()
+
+    def _flush_segment(self) -> None:
+        if self._segment is None:
+            return
+        self._write({"segment": self._segment.tojson()})
+        self._segment = None
+
+    def add(self, segment: SegmentPayloadJson) -> None:
+        if not self._segment:
+            self._segment = CoalescedSegment(segment)
+        else:
+            if segment["start"] - self._segment.end <= self.merge_threshold:
+                self._segment.merge(segment)
+            else:
+                self._flush_segment()
+                self._segment = CoalescedSegment(segment)
diff --git a/pf_video_transcribe/log.py b/pf_video_transcribe/log.py
new file mode 100644
index 0000000..ad5e23e
--- /dev/null
+++ b/pf_video_transcribe/log.py
@@ -0,0 +1,57 @@
+from argparse import ArgumentParser
+from argparse import Namespace
+import logging
+import textwrap
+
+from termcolor import colored
+
+
+class CustomFormatter(logging.Formatter):
+    sub_formatters = {
+        k: logging.Formatter(
+            colored("%(levelname)3.3s", v) + ":%(name)s: %(message)s",
+        )
+        for k, v in (
+            (logging.DEBUG, "blue"),
+            (logging.INFO, "cyan"),
+            (logging.WARNING, "yellow"),
+            (logging.ERROR, "red"),
+            (logging.CRITICAL, "light_red"),
+        )
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        formatter = self.sub_formatters.get(
+            record.levelno,
+            self.sub_formatters[logging.ERROR],
+        )
+        return formatter.format(record)
+
+
+def config(args: Namespace) -> None:
+    logger_stream_handler = logging.StreamHandler()
+    logger_stream_handler.setFormatter(CustomFormatter())
+    logger = logging.getLogger()
+    logger.addHandler(logger_stream_handler)
+    logger.setLevel("INFO")
+
+    for cfg in args.log:
+        parts = cfg.split(":", 1)
+        if len(parts) == 1:
+            logging.getLogger().setLevel(cfg)
+        else:
+            logging.getLogger(parts[0]).setLevel(parts[1])
+
+
+def add_arguments(ap: ArgumentParser) -> None:
+    ap.add_argument(
+        "--log",
+        action="append",
+        default=[],
+        help=textwrap.dedent(
+            """\
+            Configure the log level. If the string contains ":", then
+            it's assumed to be "domain:level"
+        """
+        ),
+    )
diff --git a/pf_video_transcribe/serve/__init__.py b/pf_video_transcribe/serve/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/serve/__main__.py b/pf_video_transcribe/serve/__main__.py
new file mode 100644
index 0000000..4e28416
--- /dev/null
+++ b/pf_video_transcribe/serve/__main__.py
@@ -0,0 +1,3 @@
+from .cli import main
+
+main()
diff --git a/pf_video_transcribe/serve/cli.py b/pf_video_transcribe/serve/cli.py
new file mode 100644
index 0000000..d3a4c3b
--- /dev/null
+++ b/pf_video_transcribe/serve/cli.py
@@ -0,0 +1,79 @@
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+from argparse import RawTextHelpFormatter
+import os.path
+
+from .. import log
+
+description = """\
+Serve HTTP for the given directory (where you place your videos).
+
+It's Python's http.server enabled to serve Range requests, required by
+browsers to implement video seek.
+
+NOTE: this server is meant to help during development and not to be used
+in production! For production use a proper server such as nginx, apache;
+or a CDN.
+"""
+
+
+def handle_command(args: Namespace) -> None:
+    # avoid loading heavy libraries in the command line
+    from .work import serve
+
+    serve(args.port, args.directory)
+
+
+def check_directory(s: str) -> str:
+    s = os.path.abspath(s)
+    s = os.path.relpath(s, os.getcwd())
+    if not os.path.isdir(s):
+        raise ValueError(f"not a directory: {s}")
+    return s
+
+
+def add_arguments(ap: ArgumentParser) -> None:
+    ap.add_argument(
+        "-p",
+        "--port",
+        type=int,
+        default=8000,
+        help="Port to start the HTTP server. Default: %(default)s",
+    )
+    ap.add_argument(
+        "directory",
+        nargs="?",
+        default="videos",
+        type=check_directory,
+        help="Directory/folder to serve. Default: %(default)s",
+    )
+
+
+def add_sub_parser(sub: _SubParsersAction) -> ArgumentParser:
+    ap = sub.add_parser(
+        "serve",
+        help="Serve static files (development helper)",
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    add_arguments(ap)
+    ap.set_defaults(handle=handle_command)
+    return ap
+
+
+def create_argument_parser() -> ArgumentParser:
+    ap = ArgumentParser(
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    log.add_arguments(ap)
+    add_arguments(ap)
+    return ap
+
+
+def main() -> None:
+    ap = create_argument_parser()
+    args = ap.parse_args()
+    log.config(args)
+    handle_command(args)
diff --git a/pf_video_transcribe/serve/work.py b/pf_video_transcribe/serve/work.py
new file mode 100644
index 0000000..8f6ef15
--- /dev/null
+++ b/pf_video_transcribe/serve/work.py
@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import datetime
+import email.utils
+import functools
+from http import HTTPStatus
+from http.server import SimpleHTTPRequestHandler
+from http.server import ThreadingHTTPServer
+import logging
+import os.path
+import re
+from typing import BinaryIO
+from typing import Union
+
+from termcolor import colored
+
+_logger = logging.getLogger(__name__.replace(".work", ""))
+_dbg = functools.partial(_logger.log, logging.DEBUG)
+_inf = functools.partial(_logger.log, logging.INFO)
+_wrn = functools.partial(_logger.log, logging.WARN)
+
+_range_re = re.compile(
+    r"bytes=(?P<start>\d+)-",
+)
+
+
+class RequestHandler(SimpleHTTPRequestHandler):
+    # Just SimpleHTTPRequestHandler handling "Range" requests,
+    # required by video seek, returning Content-Range
+    #
+    # Also generates pretty "/"" (main index), only for .html files
+    directory: str
+
+    def log_error(self, fmt: str, *args: object) -> None:
+        message = fmt % args
+        _wrn(colored(self.address_string(), "blue") + " " + colored(message, "red"))
+
+    def log_request(
+        self,
+        code: Union[str, int, HTTPStatus] = "-",
+        size: Union[str, int] = "-",
+    ) -> None:
+        if isinstance(code, HTTPStatus):
+            code = code.value
+
+        code_str = str(code)
+        code_color = "green"
+        if code_str[0] in ("4", "5"):
+            code_color = "red"
+
+        _inf(
+            colored(self.address_string(), "blue")
+            + " "
+            + colored(self.requestline, "cyan")
+            + " "
+            + colored(code_str, code_color)
+            + " "
+            + colored(str(size), "cyan")
+        )
+
+    def log_message(self, fmt: str, *args: object) -> None:
+        message = fmt % args
+        _dbg(colored(self.address_string(), "blue") + " " + colored(message, "cyan"))
+
+    def do_GET(self) -> None:
+        r = self.headers.get("Range")
+        if r:
+            m = _range_re.match(r)
+            path = self.translate_path(self.path)
+            if m and os.path.isfile(path):
+                start = int(m.group("start"))
+                try:
+                    with open(path, "rb") as f:
+                        self._do_GET_range(f, path, start)
+                        return
+                except Exception:
+                    pass
+
+        super().do_GET()
+
+    def _do_GET_range(self, f: BinaryIO, path: str, start: int) -> None:
+        # most of this code is similar to send_headers() handling files:
+        fs = os.fstat(f.fileno())
+
+        total_size = fs[6]
+        size = total_size - start
+        if size < 0:
+            self.send_response(HTTPStatus.REQUESTED_RANGE_NOT_SATISFIABLE)
+            self.end_headers()
+            return
+
+        # Use browser cache if possible
+        if "If-Modified-Since" in self.headers and "If-None-Match" not in self.headers:
+            # compare If-Modified-Since and time of last file modification
+            try:
+                ims = email.utils.parsedate_to_datetime(
+                    self.headers["If-Modified-Since"]
+                )
+            except (TypeError, IndexError, OverflowError, ValueError):
+                # ignore ill-formed values
+                pass
+            else:
+                if ims and ims.tzinfo is None:
+                    # obsolete format with no timezone, cf.
+                    # https://tools.ietf.org/html/rfc7231#section-7.1.1.1
+                    ims = ims.replace(tzinfo=datetime.timezone.utc)
+                if ims and ims.tzinfo is datetime.timezone.utc:
+                    # compare to UTC datetime of last modification
+                    last_modif = datetime.datetime.fromtimestamp(
+                        fs.st_mtime, datetime.timezone.utc
+                    )
+                    # remove microseconds, like in If-Modified-Since
+                    last_modif = last_modif.replace(microsecond=0)
+
+                    if last_modif <= ims:
+                        self.send_response(HTTPStatus.NOT_MODIFIED)
+                        self.end_headers()
+                        return
+
+        f.seek(start)
+        end = start + size - 1
+        ctype = self.guess_type(path)
+
+        self.send_response(HTTPStatus.PARTIAL_CONTENT)
+        self.send_header("Content-type", ctype)
+        self.send_header("Content-Length", str(size))
+        self.send_header("Content-Range", f"bytes {start}-{end}/{total_size}")
+        self.send_header("Last-Modified", self.date_time_string(int(fs.st_mtime)))
+        self.end_headers()
+        try:
+            self.copyfile(f, self.wfile)  # type: ignore
+        except BrokenPipeError:
+            self.log_error("Broken pipe, likely client closed the connection")
+
+
+class Server(ThreadingHTTPServer):
+    directory: str
+
+    def __init__(self, directory: str, port: int) -> None:
+        self.directory = directory
+        super().__init__(("", port), RequestHandler)
+
+    def finish_request(self, request: object, client_address: object) -> None:
+        self.RequestHandlerClass(
+            request, client_address, self, directory=self.directory  # type: ignore
+        )
+
+
+def serve(port: int, directory: str) -> None:
+    with Server(directory, port) as server:
+        host, port = server.socket.getsockname()[:2]
+        url_host = f"[{host}]" if ":" in host else host
+        _inf(
+            "Serving "
+            + colored(directory, "cyan")
+            + " at: "
+            + colored(f"http://{url_host}:{port}/", "cyan")
+        )
+        try:
+            server.serve_forever()
+        except KeyboardInterrupt:
+            _dbg("Keyboard interrupt received, exiting.")
diff --git a/pf_video_transcribe/srt/__init__.py b/pf_video_transcribe/srt/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/srt/__main__.py b/pf_video_transcribe/srt/__main__.py
new file mode 100644
index 0000000..4e28416
--- /dev/null
+++ b/pf_video_transcribe/srt/__main__.py
@@ -0,0 +1,3 @@
+from .cli import main
+
+main()
diff --git a/pf_video_transcribe/srt/cli.py b/pf_video_transcribe/srt/cli.py
new file mode 100644
index 0000000..7317fc6
--- /dev/null
+++ b/pf_video_transcribe/srt/cli.py
@@ -0,0 +1,57 @@
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+from argparse import RawTextHelpFormatter
+
+from .. import log
+from ..abstract_subtitles import cli as abstract_cli
+
+description = """\
+Loads transcribed jsonl (JSON Lines) file and generate SRT.
+
+SRT files can be used with media players such as VLC.
+"""
+
+
+def handle_command(args: Namespace) -> None:
+    # avoid loading heavy libraries in the command line
+    from .converter import SRTConverter
+
+    SRTConverter.batch(
+        args.file,
+        args.force,
+        duration_threshold=args.duration_threshold,
+    )
+
+
+def add_arguments(ap: ArgumentParser) -> None:
+    abstract_cli.add_arguments(ap, True)
+
+
+def add_sub_parser(sub: _SubParsersAction) -> ArgumentParser:
+    ap = sub.add_parser(
+        "srt",
+        help="Convert '.jsonl' into SRT (subtitles)",
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    add_arguments(ap)
+    ap.set_defaults(handle=handle_command)
+    return ap
+
+
+def create_argument_parser() -> ArgumentParser:
+    ap = ArgumentParser(
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    log.add_arguments(ap)
+    add_arguments(ap)
+    return ap
+
+
+def main() -> None:
+    ap = create_argument_parser()
+    args = ap.parse_args()
+    log.config(args)
+    handle_command(args)
diff --git a/pf_video_transcribe/srt/converter.py b/pf_video_transcribe/srt/converter.py
new file mode 100644
index 0000000..b14743b
--- /dev/null
+++ b/pf_video_transcribe/srt/converter.py
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import functools
+import logging
+
+from ..abstract_subtitles.converter import AbstractSubtitlesConverter
+
+
+_logger = logging.getLogger(__name__.replace(".converter", ""))
+_inf = functools.partial(_logger.log, logging.INFO)
+
+
+class SRTConverter(AbstractSubtitlesConverter):
+    ext = "srt"
+    template_name = "write.srt.jinja2"
+    logger = _inf
diff --git a/pf_video_transcribe/templates/__init__.py b/pf_video_transcribe/templates/__init__.py
new file mode 100644
index 0000000..868974a
--- /dev/null
+++ b/pf_video_transcribe/templates/__init__.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from jinja2 import Environment
+from jinja2 import PackageLoader
+
+from ..utils import format_timestamp
+
+env = Environment(loader=PackageLoader("pf_video_transcribe"))
+env.filters["format_timestamp"] = format_timestamp
+
+get_template = env.get_template
diff --git a/pf_video_transcribe/templates/index.html.jinja2 b/pf_video_transcribe/templates/index.html.jinja2
new file mode 100644
index 0000000..e718bfb
--- /dev/null
+++ b/pf_video_transcribe/templates/index.html.jinja2
@@ -0,0 +1,56 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>List of Videos</title>
+        <link
+            rel="preconnect"
+            crossorigin
+            href="https://fonts.gstatic.com"
+        />
+        <link
+            href="https://fonts.googleapis.com/css2?family=Exo+2:wght@100;400;700&display=swap"
+            rel="stylesheet"
+        />
+        <style type="text/css">
+            body {
+                font-family: "Exo 2", sans-serif;
+                font-size: 1rem;
+                line-height: 1.5rem;
+                color: #2f334b;
+                background-color: #fff;
+            }
+            a {
+                color: #63c3d1;
+            }
+            a:visited {
+                color: #2f334b;
+            }
+            span.index-label, .index-preview {
+                display: block;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>Index</h1>
+        {%- for name, items in groups %}
+        <h2 id="section/{{ name | urlencode }}">{{ name }}</h2>
+        <ul class="index-list">
+            {%- for info in items %}
+            <li>
+                <a href="{{ info.path }}">
+                    <span class="index-label">{{ info.title }}</span>
+                    {%- if info.image %}
+                    <img class="index-preview" src="{{ info.image }}" />
+                    {%- elif info.video %}
+                    <video class="index-preview" autoplay>
+                        <source src="{{ info.video }}" />
+                    </video>
+                    {% endif %}
+                </a>
+            </li>
+            {%- endfor %}
+        </ul>
+        {%- endfor %}
+    </body>
+</html>
diff --git a/pf_video_transcribe/templates/write.html.jinja2 b/pf_video_transcribe/templates/write.html.jinja2
new file mode 100644
index 0000000..89e5b9c
--- /dev/null
+++ b/pf_video_transcribe/templates/write.html.jinja2
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8" />
+        <title>{{ title }}</title>
+        {%- if image %}
+        <meta property="og:image" content="{{ image }}" />
+        {%- endif %}
+        {%- if video %}
+        <meta property="og:video" content="{{ video }}" />
+        {%- endif %}
+        <link href="{{ stylesheet }}" rel="stylesheet" />
+        {%- for entry in html_head_entry %}
+        {{ entry | safe }}
+        {%- endfor %}
+    </head>
+    <body>
+        <video id="viewer">
+            <source src="{{ media_filename }}"
+                {%- if mime_type %} type="{{ mime_type }}" {% endif -%}
+            />
+            <track kind="subtitles" srclang="{{ language }}" src="{{ vtt_filename }}" default />
+        </video>
+        <div id="transcription">
+        {%- for segment in segments %}
+            <div id="segment/{{ loop.index }}" class="segment" data-start="{{ segment.start }}" data-end="{{ segment.end }}">
+                <a class="timestamp" href="#segment/{{ loop.index }}">
+                    <span class="start">{{ segment.start | format_timestamp(decimal_marker=None) }}</span>
+                    <span class="end">{{ segment.end | format_timestamp(decimal_marker=None) }}</span>
+                </a>
+                <p class="text">
+                {%- for word in segment.words %}
+                    <span class="word" data-start="{{ word.start }}" data-end="{{ word.end }}">{{ word.text }}</span>
+                {%- endfor %}
+                </p>
+            </div>
+        {%- endfor %}
+        </div>
+        <script src="{{ javascript }}"></script>
+    </body>
+</html>
diff --git a/pf_video_transcribe/templates/write.srt.jinja2 b/pf_video_transcribe/templates/write.srt.jinja2
new file mode 100644
index 0000000..b94c515
--- /dev/null
+++ b/pf_video_transcribe/templates/write.srt.jinja2
@@ -0,0 +1,5 @@
+{% for seg in segments %}
+{{ loop.index }}
+{{ seg.start | format_timestamp(True, ",") }} --> {{ seg.end | format_timestamp(True, ",") }}
+{{ seg.text | trim }}
+{% endfor %}
diff --git a/pf_video_transcribe/templates/write.vtt.jinja2 b/pf_video_transcribe/templates/write.vtt.jinja2
new file mode 100644
index 0000000..808efe3
--- /dev/null
+++ b/pf_video_transcribe/templates/write.vtt.jinja2
@@ -0,0 +1,6 @@
+WEBVTT
+{% for seg in segments %}
+{{ loop.index }}
+{{ seg.start | format_timestamp(True, ".") }} --> {{ seg.end | format_timestamp(True, ".") }}
+{{ seg.text | trim }}
+{% endfor %}
diff --git a/pf_video_transcribe/thumbnail/__init__.py b/pf_video_transcribe/thumbnail/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/thumbnail/__main__.py b/pf_video_transcribe/thumbnail/__main__.py
new file mode 100644
index 0000000..4e28416
--- /dev/null
+++ b/pf_video_transcribe/thumbnail/__main__.py
@@ -0,0 +1,3 @@
+from .cli import main
+
+main()
diff --git a/pf_video_transcribe/thumbnail/cli.py b/pf_video_transcribe/thumbnail/cli.py
new file mode 100644
index 0000000..7e8951b
--- /dev/null
+++ b/pf_video_transcribe/thumbnail/cli.py
@@ -0,0 +1,96 @@
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+from argparse import RawTextHelpFormatter
+import textwrap
+
+from .. import log
+from ..types import Size
+from ..utils import check_file_exists
+from ..utils import parse_size
+
+description = """\
+Loads media files and generate an image thumbnail (JPEG).
+
+NOTE: this converter relies on ffmpeg being installed.
+"""
+
+
+def handle_command(args: Namespace) -> None:
+    # avoid loading heavy libraries in the command line
+    from .converter import ThumbnailConverter
+
+    ThumbnailConverter.batch(
+        args.file,
+        args.force,
+        size=args.size,
+    )
+
+
+def add_arguments(ap: ArgumentParser, add_files: bool = True) -> None:
+    ap.add_argument(
+        "--size",
+        type=parse_size,
+        default=Size(320, -1),
+        help=textwrap.dedent(
+            """\
+            Specify the thumbnail (JPEG) size.
+
+            Use format: WIDTHxHEIGHT.
+
+            If one of WIDTH or HEIGHT are -1, they will be calculated based
+            on the other dimension.
+
+            Default: %(default)s
+        """
+        ),
+    )
+    ap.add_argument(
+        "-f",
+        "--force",
+        default=False,
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+            Force regeneration of existing files.
+
+            By default, if the generated file timestamp (mtime) is newer than the
+            source (media), then it will be skipped.
+        """
+        ),
+    )
+    ap.add_argument(
+        "file",
+        nargs="+",
+        help="media or jsonl file to be processed",
+        type=check_file_exists,
+    )
+
+
+def add_sub_parser(sub: _SubParsersAction) -> ArgumentParser:
+    ap = sub.add_parser(
+        "thumbnail",
+        help="Create thumbnail (JPEG) of the given media file",
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    add_arguments(ap)
+    ap.set_defaults(handle=handle_command)
+    return ap
+
+
+def create_argument_parser() -> ArgumentParser:
+    ap = ArgumentParser(
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    log.add_arguments(ap)
+    add_arguments(ap)
+    return ap
+
+
+def main() -> None:
+    ap = create_argument_parser()
+    args = ap.parse_args()
+    log.config(args)
+    handle_command(args)
diff --git a/pf_video_transcribe/thumbnail/converter.py b/pf_video_transcribe/thumbnail/converter.py
new file mode 100644
index 0000000..96aa657
--- /dev/null
+++ b/pf_video_transcribe/thumbnail/converter.py
@@ -0,0 +1,57 @@
+import functools
+import logging
+
+import ffmpeg
+from termcolor import colored
+
+from ..converter import AbstractConverter
+from ..jsonl.reader import Reader
+from ..types import Size
+
+_logger = logging.getLogger(__name__.replace(".work", ""))
+_inf = functools.partial(_logger.log, logging.INFO)
+_err = functools.partial(_logger.log, logging.ERROR)
+
+
+def get_media_filename(f: str) -> str:
+    if f.endswith(".jsonl"):
+        return Reader(f).media_filename
+
+    return f
+
+
+class ThumbnailConverter(AbstractConverter):
+    ext = "jpeg"
+    logger = _inf
+
+    size: Size
+
+    def __init__(
+        self,
+        input_filename: str,
+        force: bool,
+        size: Size,
+    ) -> None:
+        self.size = size
+        super().__init__(get_media_filename(input_filename), force)
+
+    def generate(self) -> None:
+        pipeline = (
+            ffmpeg.input(self.input_filename)
+            .filter("scale", *self.size)
+            .filter("thumbnail", 60)
+            .output(self.filename, vframes=1)
+            .overwrite_output()
+            .global_args("-v", "error")
+            .global_args("-pattern_type", "none")
+        )
+        try:
+            pipeline.run(capture_stdout=True, capture_stderr=True)
+        except ffmpeg.Error as e:
+            _err(
+                "Could not generate: "
+                + colored(self.filename, "red")
+                + f" (from: {self.input_filename}): "
+                + colored(e.stderr.decode(), "red")
+            )
+            raise
diff --git a/pf_video_transcribe/transcribe/__init__.py b/pf_video_transcribe/transcribe/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/transcribe/__main__.py b/pf_video_transcribe/transcribe/__main__.py
new file mode 100644
index 0000000..4e28416
--- /dev/null
+++ b/pf_video_transcribe/transcribe/__main__.py
@@ -0,0 +1,3 @@
+from .cli import main
+
+main()
diff --git a/pf_video_transcribe/transcribe/cli.py b/pf_video_transcribe/transcribe/cli.py
new file mode 100644
index 0000000..c73e6b5
--- /dev/null
+++ b/pf_video_transcribe/transcribe/cli.py
@@ -0,0 +1,127 @@
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+from argparse import RawTextHelpFormatter
+import textwrap
+
+from .. import log
+from ..utils import check_file_exists
+
+description = """\
+Loads media files and transcribe their audio to JSONL (lines of json).
+
+NOTE: the model loading requires some time. If you plan to convert multiple
+files, use a single command with all the file paths at once.
+This will load the model only once.
+
+With the resulting ".jsonl" files, you can then convert to SRT, WebVTT, HTML
+and so on. See the other commands in this tool set.
+"""
+
+
+def handle_command(args: Namespace) -> None:
+    # avoid loading heavy libraries in the command line
+    from .work import transcribe_batch
+
+    transcribe_batch(
+        args.file,
+        args.force,
+        args.language,
+        args.merge_threshold,
+        args.local,
+        args.acceleration_device,
+    )
+
+
+def add_arguments(ap: ArgumentParser) -> None:
+    ap.add_argument(
+        "--acceleration-device",
+        default="auto",
+        help=textwrap.dedent(
+            """\
+            The hardware acceleration device to use, ex: cuda,cpu,auto
+
+            Defaults to auto-discovery
+
+            Note that these need specific libraries installed, see:
+            https://opennmt.net/CTranslate2/installation.html
+        """
+        ),
+    )
+    ap.add_argument(
+        "--local",
+        default=False,
+        help="Do not download any models or resources from the internet.",
+        action="store_true",
+    )
+    ap.add_argument(
+        "-l",
+        "--language",
+        help="Hint language the audio is in",
+    )
+    ap.add_argument(
+        "--merge-threshold",
+        type=float,
+        default=1.0,
+        help=textwrap.dedent(
+            """\
+        Audio Speech Recognition (ASR) models work on slices of the media,
+        producing segments that are smaller than an actual human language
+        sentence/phrase.
+
+        The merge threshold, specified in seconds, will merge sibling segments
+        if: next_segment.start - last_segment.end <= merge_threshold.
+
+        Default: %(default)s second
+        """
+        ),
+    )
+    ap.add_argument(
+        "-f",
+        "--force",
+        default=False,
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+            Force regeneration of existing files.
+
+            By default, if the generated file timestamp (mtime) is newer than the
+            source (media), then it will be skipped.
+        """
+        ),
+    )
+    ap.add_argument(
+        "file",
+        nargs="+",
+        help="media file to be processed",
+        type=check_file_exists,
+    )
+
+
+def add_sub_parser(sub: _SubParsersAction) -> ArgumentParser:
+    ap = sub.add_parser(
+        "transcribe",
+        help="Transcribe media files to '.jsonl'",
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    add_arguments(ap)
+    ap.set_defaults(handle=handle_command)
+    return ap
+
+
+def create_argument_parser() -> ArgumentParser:
+    ap = ArgumentParser(
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    log.add_arguments(ap)
+    add_arguments(ap)
+    return ap
+
+
+def main() -> None:
+    ap = create_argument_parser()
+    args = ap.parse_args()
+    log.config(args)
+    handle_command(args)
diff --git a/pf_video_transcribe/transcribe/work.py b/pf_video_transcribe/transcribe/work.py
new file mode 100644
index 0000000..5a619c1
--- /dev/null
+++ b/pf_video_transcribe/transcribe/work.py
@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import functools
+import logging
+from typing import Optional
+from typing import Sequence
+
+from faster_whisper import WhisperModel
+from faster_whisper.transcribe import Segment
+from faster_whisper.transcribe import TranscriptionInfo
+from faster_whisper.transcribe import Word
+from termcolor import colored
+from tqdm import tqdm
+
+from ..jsonl.writer import Writer
+from ..types import HeaderInfoJson
+from ..types import SegmentPayloadJson
+from ..types import WordJson
+from ..utils import format_color_prob
+from ..utils import format_timestamp
+from ..utils import needs_generate
+
+_logger = logging.getLogger(__name__.replace(".work", ""))
+_dbg = functools.partial(_logger.log, logging.DEBUG)
+_inf = functools.partial(_logger.log, logging.INFO)
+
+
+def _word_tojson(word: Word) -> WordJson:
+    return {
+        "start": word.start,
+        "end": word.end,
+        "text": word.word,
+        "probability": word.probability,
+    }
+
+
+def _segment_tojson(segment: Segment) -> SegmentPayloadJson:
+    return {
+        "start": segment.start,
+        "end": segment.end,
+        "text": segment.text,
+        "words": [_word_tojson(w) for w in (segment.words or ())],
+    }
+
+
+def _info_tojson(info: TranscriptionInfo) -> HeaderInfoJson:
+    return {
+        "duration": info.duration,
+        "language": info.language,
+        "language_probability": info.language_probability,
+        "all_language_probs": info.all_language_probs or [],
+    }
+
+
+def _show_info(method: str, info: TranscriptionInfo, outfile: str) -> None:
+    _inf(
+        f"{method} language: "
+        + colored(info.language, "cyan")
+        + format_color_prob(info.language_probability)
+        + " duration: "
+        + colored(format_timestamp(info.duration), "cyan")
+        + " writing to file: "
+        + colored(outfile, "cyan")
+    )
+    if info.all_language_probs:
+        _dbg("Other language probabilities:")
+        for lang, prob in info.all_language_probs:
+            if prob > 0.1:
+                _dbg("   " + colored(lang, "cyan") + format_color_prob(prob))
+
+
+def transcribe(
+    model: WhisperModel,
+    media_filename: str,
+    force: bool,
+    language: Optional[str],
+    merge_threshold: float,
+) -> str:
+    jsonl_filename = Writer.create_output_name(media_filename)
+    if not force and not needs_generate(media_filename, jsonl_filename):
+        _inf(
+            "Up to date: "
+            + colored(jsonl_filename, "green")
+            + f" (from: {media_filename})"
+        )
+        return jsonl_filename
+
+    _inf(
+        colored("transcribe: ", "blue")
+        + colored(media_filename, "cyan")
+        + ", language="
+        + colored(language or "auto", "cyan")
+        + ", merge_threshold="
+        + colored(str(merge_threshold), "cyan")
+        + ": "
+        + colored("preprocessing... it may take some time!", "yellow")
+    )
+
+    segments, info = model.transcribe(
+        media_filename,
+        language=language,
+        beam_size=5,
+        vad_filter=True,
+        word_timestamps=True,
+    )
+
+    info_json = _info_tojson(info)
+    with Writer(media_filename, info_json, merge_threshold) as writer:
+        _show_info("forced" if language else "detected", info, writer.filename)
+        with tqdm(segments, total=info.duration, unit="s") as pbar:
+            for segment in pbar:
+                pbar.update(segment.end)
+                _dbg(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")
+                writer.add(_segment_tojson(segment))
+
+            jsonl_filename = writer.filename
+            _inf(
+                "Saved: "
+                + colored(jsonl_filename, "cyan")
+                + f" (from: {media_filename})"
+            )
+            return jsonl_filename
+
+
+def transcribe_batch(
+    files: Sequence[str],
+    force: bool,
+    language: str,
+    merge_threshold: float,
+    local: bool,
+    acceleration_device: str,
+) -> None:
+    model_size = "large-v2"
+
+    download_text = "" if local else " and will download the models from the internet,"
+
+    _dbg(
+        "loading model "
+        + colored(model_size, "cyan")
+        + " on device "
+        + colored(acceleration_device, "cyan")
+        + colored(download_text + " it may take some time!", "yellow")
+    )
+    model = WhisperModel(
+        model_size,
+        device=acceleration_device,
+        local_files_only=local,
+    )
+
+    for filename in files:
+        transcribe(model, filename, force, language, merge_threshold)
diff --git a/pf_video_transcribe/types.py b/pf_video_transcribe/types.py
new file mode 100644
index 0000000..49ac37d
--- /dev/null
+++ b/pf_video_transcribe/types.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from typing import Literal
+from typing import NamedTuple
+from typing import Tuple
+from typing import TypedDict
+from typing import Union
+
+WordJson = TypedDict(
+    "WordJson",
+    {
+        "start": float,
+        "end": float,
+        "text": str,
+        "probability": float,
+    },
+)
+
+SegmentPayloadJson = TypedDict(
+    "SegmentPayloadJson",
+    {
+        "start": float,
+        "end": float,
+        "text": str,
+        "words": list[WordJson],
+    },
+)
+
+SegmentLineJson = TypedDict("SegmentLineJson", {"segment": SegmentPayloadJson})
+
+HeaderInfoJson = TypedDict(
+    "HeaderInfoJson",
+    {
+        "duration": float,
+        "language": str,
+        "language_probability": float,
+        "all_language_probs": list[Tuple[str, float]],
+    },
+)
+
+HeaderPayloadJson = TypedDict(
+    "HeaderPayloadJson",
+    {
+        "encoder_version": str,
+        "media_filename": str,
+        "info": HeaderInfoJson,
+    },
+)
+
+HeaderLineJson = TypedDict("HeaderLineJson", {"header": HeaderPayloadJson})
+
+FinishedOkPayloadJson = TypedDict(
+    "FinishedOkPayloadJson",
+    {
+        "ok": Literal[True],
+    },
+)
+
+FinishedFailedPayloadJson = TypedDict(
+    "FinishedFailedPayloadJson",
+    {
+        "ok": Literal[False],
+        "exc": str,
+    },
+)
+
+FinishedPayloadJson = Union[FinishedOkPayloadJson, FinishedFailedPayloadJson]
+
+FinishedLineJson = TypedDict("FinishedLineJson", {"finished": FinishedPayloadJson})
+
+LineJson = Union[HeaderLineJson, SegmentLineJson, FinishedLineJson]
+
+
+class Size(NamedTuple):
+    width: int
+    height: int
+
+    def __str__(self) -> str:
+        return f"{self.width}x{self.height}"
diff --git a/pf_video_transcribe/utils.py b/pf_video_transcribe/utils.py
new file mode 100644
index 0000000..d7ad1f3
--- /dev/null
+++ b/pf_video_transcribe/utils.py
@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import os.path
+from typing import Iterator
+from typing import Optional
+from typing import Sequence
+
+from termcolor import colored
+
+from .types import SegmentPayloadJson
+from .types import Size
+from .types import WordJson
+
+
+def color_prob(prob: float, low: float = 0.7, high: float = 0.8) -> str:
+    if prob < low:
+        return "red"
+    elif prob > high:
+        return "green"
+    else:
+        return "yellow"
+
+
+def format_color_prob(prob: float, low: float = 0.7, high: float = 0.8) -> str:
+    return colored(f" {prob * 100:.0f}%", color_prob(prob, low=low, high=high))
+
+
+def format_timestamp(
+    seconds: float,
+    always_include_hours: bool = False,
+    decimal_marker: Optional[str] = ".",
+) -> str:
+    milliseconds = round(seconds * 1000.0)
+
+    hours = milliseconds // 3_600_000
+    milliseconds -= hours * 3_600_000
+
+    minutes = milliseconds // 60_000
+    milliseconds -= minutes * 60_000
+
+    seconds = milliseconds // 1_000
+    milliseconds -= seconds * 1_000
+
+    hours_marker = f"{hours:02d}:" if always_include_hours or hours > 0 else ""
+    main_part = f"{hours_marker}{minutes:02d}:{seconds:02d}"
+    if not decimal_marker:
+        return main_part
+    return f"{main_part}{decimal_marker}{milliseconds:03d}"
+
+
+def check_file_exists(s: str) -> str:
+    if not os.path.isfile(s):
+        raise ValueError(f"not a file: {s}")
+    return s
+
+
+def check_dir_exists(s: str) -> str:
+    if not os.path.isdir(s):
+        raise ValueError(f"not a directory: {s}")
+    return s
+
+
+def needs_generate(src: str, dst: str) -> bool:
+    try:
+        src_stat = os.stat(src)
+        dst_stat = os.stat(dst)
+        return dst_stat.st_mtime < src_stat.st_mtime
+    except OSError:
+        return True
+
+
+def replace_ext(path: str, ext: str) -> str:
+    return os.path.splitext(path)[0] + os.path.extsep + ext
+
+
+def merge_text(text: str, other: str) -> str:
+    if not text.endswith(" ") and not other.startswith(" "):
+        other = " " + other
+    return text + other
+
+
+def add_word_to_segment(segment: SegmentPayloadJson, word: WordJson) -> None:
+    segment["end"] = word["end"]
+    segment["text"] = merge_text(segment["text"], word["text"])
+    segment["words"].append(word)
+
+
+def create_single_word_segment(word: WordJson) -> SegmentPayloadJson:
+    return {
+        "start": word["start"],
+        "end": word["end"],
+        "text": word["text"],
+        "words": [word],
+    }
+
+
+def merge_words(
+    words: Sequence[WordJson],
+    duration_threshold: float,
+) -> Iterator[SegmentPayloadJson]:
+    if not words:
+        return
+
+    segment = create_single_word_segment(words[0])
+    for word in words[1:]:
+        if word["end"] - segment["start"] > duration_threshold:
+            yield segment
+            segment = create_single_word_segment(word)
+        else:
+            add_word_to_segment(segment, word)
+
+
+def iter_split_segments(
+    iterator: Iterator[SegmentPayloadJson],
+    duration_threshold: float,
+) -> Iterator[SegmentPayloadJson]:
+    """Iterate over segments and split them whenever needed.
+
+    If segments are longer than ``duration_threshold``, then they will be
+    split based on words to fit in that duration. No words will be split.
+    """
+    for segment in iterator:
+        if segment["end"] - segment["start"] < duration_threshold:
+            yield segment
+        else:
+            for ms in merge_words(segment["words"], duration_threshold):
+                yield ms
+
+
+def parse_size(s: str) -> Size:
+    try:
+        width, height = s.split("x", 1)
+        return Size(int(width), int(height))
+    except (IndexError, TypeError) as e:
+        raise ValueError("invalid size") from e
diff --git a/pf_video_transcribe/vtt/__init__.py b/pf_video_transcribe/vtt/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/pf_video_transcribe/vtt/__main__.py b/pf_video_transcribe/vtt/__main__.py
new file mode 100644
index 0000000..4e28416
--- /dev/null
+++ b/pf_video_transcribe/vtt/__main__.py
@@ -0,0 +1,3 @@
+from .cli import main
+
+main()
diff --git a/pf_video_transcribe/vtt/cli.py b/pf_video_transcribe/vtt/cli.py
new file mode 100644
index 0000000..132f2ee
--- /dev/null
+++ b/pf_video_transcribe/vtt/cli.py
@@ -0,0 +1,58 @@
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+from argparse import RawTextHelpFormatter
+
+from .. import log
+from ..abstract_subtitles import cli as abstract_cli
+
+description = """\
+Loads transcribed jsonl (JSON Lines) file and generate WebVTT.
+
+WebVTT files can be used with Web Browsers, see
+https://developer.mozilla.org/en-US/docs/Web/API/WebVTT_API
+"""
+
+
+def handle_command(args: Namespace) -> None:
+    # avoid loading heavy libraries in the command line
+    from .converter import VTTConverter
+
+    VTTConverter.batch(
+        args.file,
+        args.force,
+        duration_threshold=args.duration_threshold,
+    )
+
+
+def add_arguments(ap: ArgumentParser) -> None:
+    abstract_cli.add_arguments(ap, True)
+
+
+def add_sub_parser(sub: _SubParsersAction) -> ArgumentParser:
+    ap = sub.add_parser(
+        "vtt",
+        help="Convert '.jsonl' into WebVTT (web browser subtitles)",
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    add_arguments(ap)
+    ap.set_defaults(handle=handle_command)
+    return ap
+
+
+def create_argument_parser() -> ArgumentParser:
+    ap = ArgumentParser(
+        description=description,
+        formatter_class=RawTextHelpFormatter,
+    )
+    log.add_arguments(ap)
+    add_arguments(ap)
+    return ap
+
+
+def main() -> None:
+    ap = create_argument_parser()
+    args = ap.parse_args()
+    log.config(args)
+    handle_command(args)
diff --git a/pf_video_transcribe/vtt/converter.py b/pf_video_transcribe/vtt/converter.py
new file mode 100644
index 0000000..ac3057e
--- /dev/null
+++ b/pf_video_transcribe/vtt/converter.py
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import functools
+import logging
+
+from ..abstract_subtitles.converter import AbstractSubtitlesConverter
+
+
+_logger = logging.getLogger(__name__.replace(".converter", ""))
+_inf = functools.partial(_logger.log, logging.INFO)
+
+
+class VTTConverter(AbstractSubtitlesConverter):
+    ext = "vtt"
+    template_name = "write.vtt.jinja2"
+    logger = _inf
diff --git a/poetry.lock b/poetry.lock
new file mode 100644
index 0000000..9e0f15e
--- /dev/null
+++ b/poetry.lock
@@ -0,0 +1,942 @@
+# This file is automatically @generated by Poetry 1.4.2 and should not be changed by hand.
+
+[[package]]
+name = "av"
+version = "10.0.0"
+description = "Pythonic bindings for FFmpeg's libraries."
+category = "main"
+optional = false
+python-versions = "*"
+files = [
+    {file = "av-10.0.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d19bb54197155d045a2b683d993026d4bcb06e31c2acad0327e3e8711571899c"},
+    {file = "av-10.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7dba96a85cd37315529998e6dbbe3fa05c2344eb19a431dc24996be030a904ee"},
+    {file = "av-10.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27d6d38c7c8d46d578c008ffcb8aad1eae14d0621fff41f4ad62395589045fe4"},
+    {file = "av-10.0.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:51037f4bde03daf924236af4f444e17345792ad7f6f70760a5e5863407e14f2b"},
+    {file = "av-10.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0577a38664e453b4ffb63d616a0d23c295827b16ae96a090e89527a753de8718"},
+    {file = "av-10.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:07c971573035d22ce50069d3f2bbdb4d6d02d626ab13db12fda3ce519cda3f22"},
+    {file = "av-10.0.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e5085d11345484c0097898994bb3f515002e7e1deeb43dd11d30dd6f45402c49"},
+    {file = "av-10.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:157bde3ffd1615a9006b56e4daf3b46848d3ee2bd46b0394f7568e43ed7ab5a9"},
+    {file = "av-10.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:115e144d5a1f205378a4b3a3657b7ed3e45918ebe5d2003a891e45984e8f443a"},
+    {file = "av-10.0.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7a7d6e2b3fbda6464f74fe010dbcff361394bb014b0cb4aa4dc9f2bb713ce882"},
+    {file = "av-10.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69fd5a38395191a0f4b71adf31057ff177c9f0762914d73d8797742339ad67d0"},
+    {file = "av-10.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:836d69a9543d284976b229cc8d4343ffcfc0bbaf05239e13fb7e613b13d5291d"},
+    {file = "av-10.0.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:eba192274538617bbe60097a013d83637f1a5ba9844bbbcf3ca7e43c6499b9d5"},
+    {file = "av-10.0.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1301e4cf1a2c899851073720cd541066c8539b64f9eb0d52216f8d0a59f20429"},
+    {file = "av-10.0.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eebd5aa9d8b1e33e715c5409544a712f13ec805bb0110d75f394ff28d2fb64ad"},
+    {file = "av-10.0.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04cd0ce13a87870fb0a0ea4673f04934af2b9ac7ae844eafe92e2c19c092ab11"},
+    {file = "av-10.0.0-cp37-cp37m-win_amd64.whl", hash = "sha256:10facb5b933551dd6a30d8015bc91eef5d1c864ee86aa3463ffbaff1a99f6c6a"},
+    {file = "av-10.0.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:088636ded03724a2ab51136f6f4be0bc457bdb3c0d2ac7158792fe81150d4c1a"},
+    {file = "av-10.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ff0f7d3b1003a9ed0d06038f3f521a5ff0d3e056ec5111e2a78e303f98b815a7"},
+    {file = "av-10.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ccaf786e747b126a5b3b9a8f5ffbb6a20c5f528775cc7084c95732ca72606fba"},
+    {file = "av-10.0.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c579d718b52beb812ea2a7bd68f812d0920b00937804d52d31d41bb71aa5557"},
+    {file = "av-10.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2cfd39baa5d82768d2a8898de7bfd450a083ef22b837d57e5dc1b6de3244218"},
+    {file = "av-10.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:81b5264d9752f49286bc1dc4d2cc66187418c4948a326dbed837c766c9892139"},
+    {file = "av-10.0.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:16bd82b63d0b4c1b855b3c36b13337f7cdc5925bd8284fab893bdf6c290fc3a9"},
+    {file = "av-10.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a6c8f3f8c26d35eefe45b849c81fd0816ba4b6f589baec7357c25b4c5537d3c4"},
+    {file = "av-10.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:91ea46fea7259abdfabe00b0ed3a9ca18e7fff7ce80d2a2c66a28f797cce838a"},
+    {file = "av-10.0.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a62edd533d330aa61902ae8cd82966affa487fa337a0c4f58ae8866ccb5d31c0"},
+    {file = "av-10.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b67b7d028c9cf68215376662fd2e0be6ca0cc02d32d3ed8514fec67b12db9cbd"},
+    {file = "av-10.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:0f9c88062ebfd2ce547c522b64f79e487ed2b0a6a9d6693c801b28df0d944607"},
+    {file = "av-10.0.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:63dbafcd02415127d97509523bc285f1ab260988f87b744d7fb1baee6ffbdf96"},
+    {file = "av-10.0.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2ea4424d0be62fe18c843420284a0907bcb38d577062d62c4b75a8e940e6057"},
+    {file = "av-10.0.0-pp37-pypy37_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8b6326fd0755761e3ee999e4bf90339e869fe71d548b679fee89157858b8d04a"},
+    {file = "av-10.0.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3fae238751ec0db6377b2106e13762ca84dbe104bd44c1ce9b424163aef4ab5"},
+    {file = "av-10.0.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:86bb3f6e8cce62ad18cd34eb2eadd091d99f51b40be81c929b53fbd8fecf6d90"},
+    {file = "av-10.0.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:f7b508813abbc100162d305a1ac9b2dd16e5128d56f2ac69639fc6a4b5aca69e"},
+    {file = "av-10.0.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:98cc376199c0aa6e9365d03e0f4e67cfb209e40fe9c0cf566372f9daf2a0c779"},
+    {file = "av-10.0.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1b459ca0ef25c1a0e370112556bdc5b7752f76dc9bd497acaf3e653171e4b946"},
+    {file = "av-10.0.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab930735112c1f788cc4d47c42c59ba0dd214d815aa906e1addf39af91d15194"},
+    {file = "av-10.0.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:13fe0b48b9211539323ecebbf84154c86c72d16723c6d0af76e29ae5c3a614b2"},
+    {file = "av-10.0.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c2eeec7beaebfe9e2213b3c94b482381187d0afdcb632f93239b44dc668b97df"},
+    {file = "av-10.0.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3dac2a8b0791c3373270e32f6cd27e6b60628565a188e40a5d9660d3aab05e33"},
+    {file = "av-10.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1cdede2325cb750b5bf79238bbf06f9c2a70b757b12726003769a43493b7233a"},
+    {file = "av-10.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:9788e6e15db0910fb8e1548ba7540799d07066177710590a5794a524c4910e05"},
+    {file = "av-10.0.0.tar.gz", hash = "sha256:8afd3d5610e1086f3b2d8389d66672ea78624516912c93612de64dcaa4c67e05"},
+]
+
+[[package]]
+name = "certifi"
+version = "2023.5.7"
+description = "Python package for providing Mozilla's CA Bundle."
+category = "main"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "certifi-2023.5.7-py3-none-any.whl", hash = "sha256:c6c2e98f5c7869efca1f8916fed228dd91539f9f1b444c314c06eef02980c716"},
+    {file = "certifi-2023.5.7.tar.gz", hash = "sha256:0f0d56dc5a6ad56fd4ba36484d6cc34451e1c6548c61daad8c320169f91eddc7"},
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.1.0"
+description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
+category = "main"
+optional = false
+python-versions = ">=3.7.0"
+files = [
+    {file = "charset-normalizer-3.1.0.tar.gz", hash = "sha256:34e0a2f9c370eb95597aae63bf85eb5e96826d81e3dcf88b8886012906f509b5"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e0ac8959c929593fee38da1c2b64ee9778733cdf03c482c9ff1d508b6b593b2b"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d7fc3fca01da18fbabe4625d64bb612b533533ed10045a2ac3dd194bfa656b60"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:04eefcee095f58eaabe6dc3cc2262f3bcd776d2c67005880894f447b3f2cb9c1"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:20064ead0717cf9a73a6d1e779b23d149b53daf971169289ed2ed43a71e8d3b0"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1435ae15108b1cb6fffbcea2af3d468683b7afed0169ad718451f8db5d1aff6f"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c84132a54c750fda57729d1e2599bb598f5fa0344085dbde5003ba429a4798c0"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:75f2568b4189dda1c567339b48cba4ac7384accb9c2a7ed655cd86b04055c795"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:11d3bcb7be35e7b1bba2c23beedac81ee893ac9871d0ba79effc7fc01167db6c"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:891cf9b48776b5c61c700b55a598621fdb7b1e301a550365571e9624f270c203"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:5f008525e02908b20e04707a4f704cd286d94718f48bb33edddc7d7b584dddc1"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:b06f0d3bf045158d2fb8837c5785fe9ff9b8c93358be64461a1089f5da983137"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:49919f8400b5e49e961f320c735388ee686a62327e773fa5b3ce6721f7e785ce"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:22908891a380d50738e1f978667536f6c6b526a2064156203d418f4856d6e86a"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-win32.whl", hash = "sha256:12d1a39aa6b8c6f6248bb54550efcc1c38ce0d8096a146638fd4738e42284448"},
+    {file = "charset_normalizer-3.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:65ed923f84a6844de5fd29726b888e58c62820e0769b76565480e1fdc3d062f8"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9a3267620866c9d17b959a84dd0bd2d45719b817245e49371ead79ed4f710d19"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6734e606355834f13445b6adc38b53c0fd45f1a56a9ba06c2058f86893ae8017"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f8303414c7b03f794347ad062c0516cee0e15f7a612abd0ce1e25caf6ceb47df"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aaf53a6cebad0eae578f062c7d462155eada9c172bd8c4d250b8c1d8eb7f916a"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3dc5b6a8ecfdc5748a7e429782598e4f17ef378e3e272eeb1340ea57c9109f41"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e1b25e3ad6c909f398df8921780d6a3d120d8c09466720226fc621605b6f92b1"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ca564606d2caafb0abe6d1b5311c2649e8071eb241b2d64e75a0d0065107e62"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b82fab78e0b1329e183a65260581de4375f619167478dddab510c6c6fb04d9b6"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:bd7163182133c0c7701b25e604cf1611c0d87712e56e88e7ee5d72deab3e76b5"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:11d117e6c63e8f495412d37e7dc2e2fff09c34b2d09dbe2bee3c6229577818be"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:cf6511efa4801b9b38dc5546d7547d5b5c6ef4b081c60b23e4d941d0eba9cbeb"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:abc1185d79f47c0a7aaf7e2412a0eb2c03b724581139193d2d82b3ad8cbb00ac"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cb7b2ab0188829593b9de646545175547a70d9a6e2b63bf2cd87a0a391599324"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-win32.whl", hash = "sha256:c36bcbc0d5174a80d6cccf43a0ecaca44e81d25be4b7f90f0ed7bcfbb5a00909"},
+    {file = "charset_normalizer-3.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:cca4def576f47a09a943666b8f829606bcb17e2bc2d5911a46c8f8da45f56755"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:0c95f12b74681e9ae127728f7e5409cbbef9cd914d5896ef238cc779b8152373"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fca62a8301b605b954ad2e9c3666f9d97f63872aa4efcae5492baca2056b74ab"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac0aa6cd53ab9a31d397f8303f92c42f534693528fafbdb997c82bae6e477ad9"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c3af8e0f07399d3176b179f2e2634c3ce9c1301379a6b8c9c9aeecd481da494f"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a5fc78f9e3f501a1614a98f7c54d3969f3ad9bba8ba3d9b438c3bc5d047dd28"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:628c985afb2c7d27a4800bfb609e03985aaecb42f955049957814e0491d4006d"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:74db0052d985cf37fa111828d0dd230776ac99c740e1a758ad99094be4f1803d"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:1e8fcdd8f672a1c4fc8d0bd3a2b576b152d2a349782d1eb0f6b8e52e9954731d"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:04afa6387e2b282cf78ff3dbce20f0cc071c12dc8f685bd40960cc68644cfea6"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:dd5653e67b149503c68c4018bf07e42eeed6b4e956b24c00ccdf93ac79cdff84"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d2686f91611f9e17f4548dbf050e75b079bbc2a82be565832bc8ea9047b61c8c"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-win32.whl", hash = "sha256:4155b51ae05ed47199dc5b2a4e62abccb274cee6b01da5b895099b61b1982974"},
+    {file = "charset_normalizer-3.1.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322102cdf1ab682ecc7d9b1c5eed4ec59657a65e1c146a0da342b78f4112db23"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e633940f28c1e913615fd624fcdd72fdba807bf53ea6925d6a588e84e1151531"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:3a06f32c9634a8705f4ca9946d667609f52cf130d5548881401f1eb2c39b1e2c"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7381c66e0561c5757ffe616af869b916c8b4e42b367ab29fedc98481d1e74e14"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3573d376454d956553c356df45bb824262c397c6e26ce43e8203c4c540ee0acb"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e89df2958e5159b811af9ff0f92614dabf4ff617c03a4c1c6ff53bf1c399e0e1"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:78cacd03e79d009d95635e7d6ff12c21eb89b894c354bd2b2ed0b4763373693b"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de5695a6f1d8340b12a5d6d4484290ee74d61e467c39ff03b39e30df62cf83a0"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c60b9c202d00052183c9be85e5eaf18a4ada0a47d188a83c8f5c5b23252f649"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f645caaf0008bacf349875a974220f1f1da349c5dbe7c4ec93048cdc785a3326"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ea9f9c6034ea2d93d9147818f17c2a0860d41b71c38b9ce4d55f21b6f9165a11"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:80d1543d58bd3d6c271b66abf454d437a438dff01c3e62fdbcd68f2a11310d4b"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:73dc03a6a7e30b7edc5b01b601e53e7fc924b04e1835e8e407c12c037e81adbd"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6f5c2e7bc8a4bf7c426599765b1bd33217ec84023033672c1e9a8b35eaeaaaf8"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-win32.whl", hash = "sha256:12a2b561af122e3d94cdb97fe6fb2bb2b82cef0cdca131646fdb940a1eda04f0"},
+    {file = "charset_normalizer-3.1.0-cp38-cp38-win_amd64.whl", hash = "sha256:3160a0fd9754aab7d47f95a6b63ab355388d890163eb03b2d2b87ab0a30cfa59"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:38e812a197bf8e71a59fe55b757a84c1f946d0ac114acafaafaf21667a7e169e"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6baf0baf0d5d265fa7944feb9f7451cc316bfe30e8df1a61b1bb08577c554f31"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8f25e17ab3039b05f762b0a55ae0b3632b2e073d9c8fc88e89aca31a6198e88f"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3747443b6a904001473370d7810aa19c3a180ccd52a7157aacc264a5ac79265e"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b116502087ce8a6b7a5f1814568ccbd0e9f6cfd99948aa59b0e241dc57cf739f"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d16fd5252f883eb074ca55cb622bc0bee49b979ae4e8639fff6ca3ff44f9f854"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fa558996782fc226b529fdd2ed7866c2c6ec91cee82735c98a197fae39f706"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f6c7a8a57e9405cad7485f4c9d3172ae486cfef1344b5ddd8e5239582d7355e"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ac3775e3311661d4adace3697a52ac0bab17edd166087d493b52d4f4f553f9f0"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:10c93628d7497c81686e8e5e557aafa78f230cd9e77dd0c40032ef90c18f2230"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:6f4f4668e1831850ebcc2fd0b1cd11721947b6dc7c00bf1c6bd3c929ae14f2c7"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:0be65ccf618c1e7ac9b849c315cc2e8a8751d9cfdaa43027d4f6624bd587ab7e"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:53d0a3fa5f8af98a1e261de6a3943ca631c526635eb5817a87a59d9a57ebf48f"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-win32.whl", hash = "sha256:a04f86f41a8916fe45ac5024ec477f41f886b3c435da2d4e3d2709b22ab02af1"},
+    {file = "charset_normalizer-3.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:830d2948a5ec37c386d3170c483063798d7879037492540f10a475e3fd6f244b"},
+    {file = "charset_normalizer-3.1.0-py3-none-any.whl", hash = "sha256:3d9098b479e78c85080c98e1e35ff40b4a31d8953102bb0fd7d1b6f8a2111a3d"},
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+description = "Cross-platform colored terminal text."
+category = "main"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+files = [
+    {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
+    {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
+]
+
+[[package]]
+name = "coloredlogs"
+version = "15.0.1"
+description = "Colored terminal output for Python's logging module"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+files = [
+    {file = "coloredlogs-15.0.1-py2.py3-none-any.whl", hash = "sha256:612ee75c546f53e92e70049c9dbfcc18c935a2b9a53b66085ce9ef6a6e5c0934"},
+    {file = "coloredlogs-15.0.1.tar.gz", hash = "sha256:7c991aa71a4577af2f82600d8f8f3a89f936baeaf9b50a9c197da014e5bf16b0"},
+]
+
+[package.dependencies]
+humanfriendly = ">=9.1"
+
+[package.extras]
+cron = ["capturer (>=2.4)"]
+
+[[package]]
+name = "ctranslate2"
+version = "3.13.0"
+description = "Fast inference engine for Transformer models"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "ctranslate2-3.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f88f9746f2e8359d843a8eaaa062fb65cf81f16107a3702915824895c2828b69"},
+    {file = "ctranslate2-3.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:56905b57115833716ef242a2c6140cfa39edea9ba62efc55a30fb92cd6a0bfc8"},
+    {file = "ctranslate2-3.13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a49883aa24265bd4a9a31325e46ae39e078dbc10b748a4b1917ace027184cd59"},
+    {file = "ctranslate2-3.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b669ec2d0f666d7a37eeed4b3bdf1e5efb53e0adf4b8c7ace7eef8fe70de20ea"},
+    {file = "ctranslate2-3.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:71471b2c43e1ad5ef901bdb7fe04d15d244c0a5deedd482030ad9587709d31bd"},
+    {file = "ctranslate2-3.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:940d87ea7b1845c963359181c2b9f9f9aee6e59208f6015c16da7bc62d1253ab"},
+    {file = "ctranslate2-3.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:60560e3f91a096264edd6a25d41c20968b4463327387db02271aee18eb634ee1"},
+    {file = "ctranslate2-3.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f028946d1a730b90852b7d64bb0905f7af571e74ca045e49213c19b31d8d0c94"},
+    {file = "ctranslate2-3.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d56336693482ded51aaba9c8e301d9bca25cd31f8cdaae9c949030f3aa40b390"},
+    {file = "ctranslate2-3.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:6fae72bc13500a11786e64be995492782d5498701a335e05a789ce0d27691552"},
+    {file = "ctranslate2-3.13.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c87533e902d82420c70312716d411f3addcefc18e1152c688fdb10b5ae497a9e"},
+    {file = "ctranslate2-3.13.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:af59d36c7f0faf14f49d1ad5a19271b0283507b427732d59e40a3dd352429733"},
+    {file = "ctranslate2-3.13.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c176d1b74601130eaa36a99d624db2d080c36bf91550ad8846d0990bdc7ad334"},
+    {file = "ctranslate2-3.13.0-cp37-cp37m-win_amd64.whl", hash = "sha256:1be09307d17424990c5a56f56f11cdcfaf80f799f4c91efa061949c13fe7028c"},
+    {file = "ctranslate2-3.13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:4978e22c2bb06f90eca74f51db55ca34a84d82bed5f3e4a8c36ae088e58fc0f4"},
+    {file = "ctranslate2-3.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:1941702a356c5d945524a4ce7f3576c62bf36128b3ef5e4275b22a813930f7e1"},
+    {file = "ctranslate2-3.13.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:beace18aeca98faf5a1fdc1fd50e3b33578bc2e1235b0b58b4f882204ab83249"},
+    {file = "ctranslate2-3.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d9ffbb5116888464452a86b41fa4fb464daf11b4b60b45d2395273a4102fb2a"},
+    {file = "ctranslate2-3.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:fcc19266f504dc06abd89d6cfaffb9c83daf0ae1291df0ad96f864eb53932742"},
+    {file = "ctranslate2-3.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9e769a9aec0b021dcf6eba6ec025bec73738e9b2ef67efc0abb146f26ed98336"},
+    {file = "ctranslate2-3.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d1a3911e5aa88d6bcf5176274bd52b9ec87f5675d26325312fa52958ff92099e"},
+    {file = "ctranslate2-3.13.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:015393bff04722ae7318def6236d2156282a6c52e2cc54dddfd26727bc215ebe"},
+    {file = "ctranslate2-3.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b23d1de46c7c206cb4f4c05af05d8e99b2f9ecd578dcca0103aee258ea8bdebb"},
+    {file = "ctranslate2-3.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:6d3e499cee4551c1759afa60ef9bcf62bf558e85ee4ce90e9aa112cc49b9cd05"},
+]
+
+[package.dependencies]
+numpy = "*"
+pyyaml = ">=5.3,<7"
+
+[[package]]
+name = "faster-whisper"
+version = "0.6.0"
+description = "Faster Whisper transcription with CTranslate2"
+category = "main"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "faster-whisper-0.6.0.tar.gz", hash = "sha256:f58f43c64f3c96f28ca9ab7e9a5c73e5db0e4671a794ac29b2a18d7e732e8ced"},
+    {file = "faster_whisper-0.6.0-py3-none-any.whl", hash = "sha256:6559a40ce7a54bc7437ba0e14e9fa80876bd2e0e511933f30e68738218fc40d9"},
+]
+
+[package.dependencies]
+av = ">=10.0.0,<11.0.0"
+ctranslate2 = ">=3.10,<4"
+huggingface-hub = ">=0.13"
+onnxruntime = ">=1.14,<2"
+tokenizers = ">=0.13.0,<0.14.0"
+
+[package.extras]
+conversion = ["transformers[torch] (>=4.23)"]
+dev = ["black (>=23.0.0,<24.0.0)", "flake8 (>=6.0.0,<7.0.0)", "isort (>=5.0.0,<6.0.0)", "pytest (>=7.0.0,<8.0.0)"]
+
+[[package]]
+name = "ffmpeg-python"
+version = "0.2.0"
+description = "Python bindings for FFmpeg - with complex filtering support"
+category = "main"
+optional = false
+python-versions = "*"
+files = [
+    {file = "ffmpeg-python-0.2.0.tar.gz", hash = "sha256:65225db34627c578ef0e11c8b1eb528bb35e024752f6f10b78c011f6f64c4127"},
+    {file = "ffmpeg_python-0.2.0-py3-none-any.whl", hash = "sha256:ac441a0404e053f8b6a1113a77c0f452f1cfc62f6344a769475ffdc0f56c23c5"},
+]
+
+[package.dependencies]
+future = "*"
+
+[package.extras]
+dev = ["Sphinx (==2.1.0)", "future (==0.17.1)", "numpy (==1.16.4)", "pytest (==4.6.1)", "pytest-mock (==1.10.4)", "tox (==3.12.1)"]
+
+[[package]]
+name = "filelock"
+version = "3.12.0"
+description = "A platform independent file lock."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "filelock-3.12.0-py3-none-any.whl", hash = "sha256:ad98852315c2ab702aeb628412cbf7e95b7ce8c3bf9565670b4eaecf1db370a9"},
+    {file = "filelock-3.12.0.tar.gz", hash = "sha256:fc03ae43288c013d2ea83c8597001b1129db351aad9c57fe2409327916b8e718"},
+]
+
+[package.extras]
+docs = ["furo (>=2023.3.27)", "sphinx (>=6.1.3)", "sphinx-autodoc-typehints (>=1.23,!=1.23.4)"]
+testing = ["covdefaults (>=2.3)", "coverage (>=7.2.3)", "diff-cover (>=7.5)", "pytest (>=7.3.1)", "pytest-cov (>=4)", "pytest-mock (>=3.10)", "pytest-timeout (>=2.1)"]
+
+[[package]]
+name = "flake8"
+version = "6.0.0"
+description = "the modular source code checker: pep8 pyflakes and co"
+category = "dev"
+optional = false
+python-versions = ">=3.8.1"
+files = [
+    {file = "flake8-6.0.0-py2.py3-none-any.whl", hash = "sha256:3833794e27ff64ea4e9cf5d410082a8b97ff1a06c16aa3d2027339cd0f1195c7"},
+    {file = "flake8-6.0.0.tar.gz", hash = "sha256:c61007e76655af75e6785a931f452915b371dc48f56efd765247c8fe68f2b181"},
+]
+
+[package.dependencies]
+mccabe = ">=0.7.0,<0.8.0"
+pycodestyle = ">=2.10.0,<2.11.0"
+pyflakes = ">=3.0.0,<3.1.0"
+
+[[package]]
+name = "flatbuffers"
+version = "23.5.9"
+description = "The FlatBuffers serialization format for Python"
+category = "main"
+optional = false
+python-versions = "*"
+files = [
+    {file = "flatbuffers-23.5.9-py2.py3-none-any.whl", hash = "sha256:a02eb8c2d61cba153cd211937de8f8f7764b6a7510971b2c4684ed8b02e6e571"},
+    {file = "flatbuffers-23.5.9.tar.gz", hash = "sha256:93a506b6ab771c79ce816e7b35a93ed08ec5b4c9edb811101a22c44a4152f018"},
+]
+
+[[package]]
+name = "fsspec"
+version = "2023.5.0"
+description = "File-system specification"
+category = "main"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "fsspec-2023.5.0-py3-none-any.whl", hash = "sha256:51a4ad01a5bb66fcc58036e288c0d53d3975a0df2a5dc59a93b59bade0391f2a"},
+    {file = "fsspec-2023.5.0.tar.gz", hash = "sha256:b3b56e00fb93ea321bc9e5d9cf6f8522a0198b20eb24e02774d329e9c6fb84ce"},
+]
+
+[package.extras]
+abfs = ["adlfs"]
+adl = ["adlfs"]
+arrow = ["pyarrow (>=1)"]
+dask = ["dask", "distributed"]
+devel = ["pytest", "pytest-cov"]
+dropbox = ["dropbox", "dropboxdrivefs", "requests"]
+full = ["adlfs", "aiohttp (!=4.0.0a0,!=4.0.0a1)", "dask", "distributed", "dropbox", "dropboxdrivefs", "fusepy", "gcsfs", "libarchive-c", "ocifs", "panel", "paramiko", "pyarrow (>=1)", "pygit2", "requests", "s3fs", "smbprotocol", "tqdm"]
+fuse = ["fusepy"]
+gcs = ["gcsfs"]
+git = ["pygit2"]
+github = ["requests"]
+gs = ["gcsfs"]
+gui = ["panel"]
+hdfs = ["pyarrow (>=1)"]
+http = ["aiohttp (!=4.0.0a0,!=4.0.0a1)", "requests"]
+libarchive = ["libarchive-c"]
+oci = ["ocifs"]
+s3 = ["s3fs"]
+sftp = ["paramiko"]
+smb = ["smbprotocol"]
+ssh = ["paramiko"]
+tqdm = ["tqdm"]
+
+[[package]]
+name = "future"
+version = "0.18.3"
+description = "Clean single-source support for Python 3 and 2"
+category = "main"
+optional = false
+python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*"
+files = [
+    {file = "future-0.18.3.tar.gz", hash = "sha256:34a17436ed1e96697a86f9de3d15a3b0be01d8bc8de9c1dffd59fb8234ed5307"},
+]
+
+[[package]]
+name = "huggingface-hub"
+version = "0.14.1"
+description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub"
+category = "main"
+optional = false
+python-versions = ">=3.7.0"
+files = [
+    {file = "huggingface_hub-0.14.1-py3-none-any.whl", hash = "sha256:9fc619170d800ff3793ad37c9757c255c8783051e1b5b00501205eb43ccc4f27"},
+    {file = "huggingface_hub-0.14.1.tar.gz", hash = "sha256:9ab899af8e10922eac65e290d60ab956882ab0bf643e3d990b1394b6b47b7fbc"},
+]
+
+[package.dependencies]
+filelock = "*"
+fsspec = "*"
+packaging = ">=20.9"
+pyyaml = ">=5.1"
+requests = "*"
+tqdm = ">=4.42.1"
+typing-extensions = ">=3.7.4.3"
+
+[package.extras]
+all = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "black (>=23.1,<24.0)", "gradio", "jedi", "mypy (==0.982)", "pytest", "pytest-cov", "pytest-env", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3"]
+cli = ["InquirerPy (==0.3.4)"]
+dev = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "black (>=23.1,<24.0)", "gradio", "jedi", "mypy (==0.982)", "pytest", "pytest-cov", "pytest-env", "pytest-xdist", "ruff (>=0.0.241)", "soundfile", "types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3"]
+fastai = ["fastai (>=2.4)", "fastcore (>=1.3.27)", "toml"]
+quality = ["black (>=23.1,<24.0)", "mypy (==0.982)", "ruff (>=0.0.241)"]
+tensorflow = ["graphviz", "pydot", "tensorflow"]
+testing = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "gradio", "jedi", "pytest", "pytest-cov", "pytest-env", "pytest-xdist", "soundfile"]
+torch = ["torch"]
+typing = ["types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3"]
+
+[[package]]
+name = "humanfriendly"
+version = "10.0"
+description = "Human friendly output for text interfaces using Python"
+category = "main"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+files = [
+    {file = "humanfriendly-10.0-py2.py3-none-any.whl", hash = "sha256:1697e1a8a8f550fd43c2865cd84542fc175a61dcb779b6fee18cf6b6ccba1477"},
+    {file = "humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc"},
+]
+
+[package.dependencies]
+pyreadline3 = {version = "*", markers = "sys_platform == \"win32\" and python_version >= \"3.8\""}
+
+[[package]]
+name = "idna"
+version = "3.4"
+description = "Internationalized Domain Names in Applications (IDNA)"
+category = "main"
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "idna-3.4-py3-none-any.whl", hash = "sha256:90b77e79eaa3eba6de819a0c442c0b4ceefc341a7a2ab77d7562bf49f425c5c2"},
+    {file = "idna-3.4.tar.gz", hash = "sha256:814f528e8dead7d329833b91c5faa87d60bf71824cd12a7530b5526063d02cb4"},
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.2"
+description = "A very fast and expressive template engine."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "Jinja2-3.1.2-py3-none-any.whl", hash = "sha256:6088930bfe239f0e6710546ab9c19c9ef35e29792895fed6e6e31a023a182a61"},
+    {file = "Jinja2-3.1.2.tar.gz", hash = "sha256:31351a702a408a9e7595a8fc6150fc3f43bb6bf7e319770cbc0db9df9437e852"},
+]
+
+[package.dependencies]
+MarkupSafe = ">=2.0"
+
+[package.extras]
+i18n = ["Babel (>=2.7)"]
+
+[[package]]
+name = "markupsafe"
+version = "2.1.2"
+description = "Safely add untrusted strings to HTML/XML markup."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:665a36ae6f8f20a4676b53224e33d456a6f5a72657d9c83c2aa00765072f31f7"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:340bea174e9761308703ae988e982005aedf427de816d1afe98147668cc03036"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22152d00bf4a9c7c83960521fc558f55a1adbc0631fbb00a9471e097b19d72e1"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28057e985dace2f478e042eaa15606c7efccb700797660629da387eb289b9323"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ca244fa73f50a800cf8c3ebf7fd93149ec37f5cb9596aa8873ae2c1d23498601"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d9d971ec1e79906046aa3ca266de79eac42f1dbf3612a05dc9368125952bd1a1"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:7e007132af78ea9df29495dbf7b5824cb71648d7133cf7848a2a5dd00d36f9ff"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7313ce6a199651c4ed9d7e4cfb4aa56fe923b1adf9af3b420ee14e6d9a73df65"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-win32.whl", hash = "sha256:c4a549890a45f57f1ebf99c067a4ad0cb423a05544accaf2b065246827ed9603"},
+    {file = "MarkupSafe-2.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:835fb5e38fd89328e9c81067fd642b3593c33e1e17e2fdbf77f5676abb14a156"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2ec4f2d48ae59bbb9d1f9d7efb9236ab81429a764dedca114f5fdabbc3788013"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:608e7073dfa9e38a85d38474c082d4281f4ce276ac0010224eaba11e929dd53a"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:65608c35bfb8a76763f37036547f7adfd09270fbdbf96608be2bead319728fcd"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2bfb563d0211ce16b63c7cb9395d2c682a23187f54c3d79bfec33e6705473c6"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da25303d91526aac3672ee6d49a2f3db2d9502a4a60b55519feb1a4c7714e07d"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:9cad97ab29dfc3f0249b483412c85c8ef4766d96cdf9dcf5a1e3caa3f3661cf1"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:085fd3201e7b12809f9e6e9bc1e5c96a368c8523fad5afb02afe3c051ae4afcc"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1bea30e9bf331f3fef67e0a3877b2288593c98a21ccb2cf29b74c581a4eb3af0"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-win32.whl", hash = "sha256:7df70907e00c970c60b9ef2938d894a9381f38e6b9db73c5be35e59d92e06625"},
+    {file = "MarkupSafe-2.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:e55e40ff0cc8cc5c07996915ad367fa47da6b3fc091fdadca7f5403239c5fec3"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a6e40afa7f45939ca356f348c8e23048e02cb109ced1eb8420961b2f40fb373a"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf877ab4ed6e302ec1d04952ca358b381a882fbd9d1b07cccbfd61783561f98a"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63ba06c9941e46fa389d389644e2d8225e0e3e5ebcc4ff1ea8506dce646f8c8a"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f1cd098434e83e656abf198f103a8207a8187c0fc110306691a2e94a78d0abb2"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:55f44b440d491028addb3b88f72207d71eeebfb7b5dbf0643f7c023ae1fba619"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:a6f2fcca746e8d5910e18782f976489939d54a91f9411c32051b4aab2bd7c513"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:0b462104ba25f1ac006fdab8b6a01ebbfbce9ed37fd37fd4acd70c67c973e460"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-win32.whl", hash = "sha256:7668b52e102d0ed87cb082380a7e2e1e78737ddecdde129acadb0eccc5423859"},
+    {file = "MarkupSafe-2.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6d6607f98fcf17e534162f0709aaad3ab7a96032723d8ac8750ffe17ae5a0666"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a806db027852538d2ad7555b203300173dd1b77ba116de92da9afbc3a3be3eed"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a4abaec6ca3ad8660690236d11bfe28dfd707778e2442b45addd2f086d6ef094"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f03a532d7dee1bed20bc4884194a16160a2de9ffc6354b3878ec9682bb623c54"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4cf06cdc1dda95223e9d2d3c58d3b178aa5dacb35ee7e3bbac10e4e1faacb419"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22731d79ed2eb25059ae3df1dfc9cb1546691cc41f4e3130fe6bfbc3ecbbecfa"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:f8ffb705ffcf5ddd0e80b65ddf7bed7ee4f5a441ea7d3419e861a12eaf41af58"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8db032bf0ce9022a8e41a22598eefc802314e81b879ae093f36ce9ddf39ab1ba"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2298c859cfc5463f1b64bd55cb3e602528db6fa0f3cfd568d3605c50678f8f03"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-win32.whl", hash = "sha256:50c42830a633fa0cf9e7d27664637532791bfc31c731a87b202d2d8ac40c3ea2"},
+    {file = "MarkupSafe-2.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:bb06feb762bade6bf3c8b844462274db0c76acc95c52abe8dbed28ae3d44a147"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:99625a92da8229df6d44335e6fcc558a5037dd0a760e11d84be2260e6f37002f"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8bca7e26c1dd751236cfb0c6c72d4ad61d986e9a41bbf76cb445f69488b2a2bd"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40627dcf047dadb22cd25ea7ecfe9cbf3bbbad0482ee5920b582f3809c97654f"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40dfd3fefbef579ee058f139733ac336312663c6706d1163b82b3003fb1925c4"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:090376d812fb6ac5f171e5938e82e7f2d7adc2b629101cec0db8b267815c85e2"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2e7821bffe00aa6bd07a23913b7f4e01328c3d5cc0b40b36c0bd81d362faeb65"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:c0a33bc9f02c2b17c3ea382f91b4db0e6cde90b63b296422a939886a7a80de1c"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b8526c6d437855442cdd3d87eede9c425c4445ea011ca38d937db299382e6fa3"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-win32.whl", hash = "sha256:137678c63c977754abe9086a3ec011e8fd985ab90631145dfb9294ad09c102a7"},
+    {file = "MarkupSafe-2.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:0576fe974b40a400449768941d5d0858cc624e3249dfd1e0c33674e5c7ca7aed"},
+    {file = "MarkupSafe-2.1.2.tar.gz", hash = "sha256:abcabc8c2b26036d62d4c746381a6f7cf60aafcc653198ad678306986b09450d"},
+]
+
+[[package]]
+name = "mccabe"
+version = "0.7.0"
+description = "McCabe checker, plugin for flake8"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
+    {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
+]
+
+[[package]]
+name = "mpmath"
+version = "1.3.0"
+description = "Python library for arbitrary-precision floating-point arithmetic"
+category = "main"
+optional = false
+python-versions = "*"
+files = [
+    {file = "mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c"},
+    {file = "mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f"},
+]
+
+[package.extras]
+develop = ["codecov", "pycodestyle", "pytest (>=4.6)", "pytest-cov", "wheel"]
+docs = ["sphinx"]
+gmpy = ["gmpy2 (>=2.1.0a4)"]
+tests = ["pytest (>=4.6)"]
+
+[[package]]
+name = "mypy"
+version = "1.3.0"
+description = "Optional static typing for Python"
+category = "dev"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "mypy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c1eb485cea53f4f5284e5baf92902cd0088b24984f4209e25981cc359d64448d"},
+    {file = "mypy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4c99c3ecf223cf2952638da9cd82793d8f3c0c5fa8b6ae2b2d9ed1e1ff51ba85"},
+    {file = "mypy-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:550a8b3a19bb6589679a7c3c31f64312e7ff482a816c96e0cecec9ad3a7564dd"},
+    {file = "mypy-1.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:cbc07246253b9e3d7d74c9ff948cd0fd7a71afcc2b77c7f0a59c26e9395cb152"},
+    {file = "mypy-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:a22435632710a4fcf8acf86cbd0d69f68ac389a3892cb23fbad176d1cddaf228"},
+    {file = "mypy-1.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6e33bb8b2613614a33dff70565f4c803f889ebd2f859466e42b46e1df76018dd"},
+    {file = "mypy-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7d23370d2a6b7a71dc65d1266f9a34e4cde9e8e21511322415db4b26f46f6b8c"},
+    {file = "mypy-1.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:658fe7b674769a0770d4b26cb4d6f005e88a442fe82446f020be8e5f5efb2fae"},
+    {file = "mypy-1.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:6e42d29e324cdda61daaec2336c42512e59c7c375340bd202efa1fe0f7b8f8ca"},
+    {file = "mypy-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:d0b6c62206e04061e27009481cb0ec966f7d6172b5b936f3ead3d74f29fe3dcf"},
+    {file = "mypy-1.3.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:76ec771e2342f1b558c36d49900dfe81d140361dd0d2df6cd71b3db1be155409"},
+    {file = "mypy-1.3.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ebc95f8386314272bbc817026f8ce8f4f0d2ef7ae44f947c4664efac9adec929"},
+    {file = "mypy-1.3.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:faff86aa10c1aa4a10e1a301de160f3d8fc8703b88c7e98de46b531ff1276a9a"},
+    {file = "mypy-1.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:8c5979d0deb27e0f4479bee18ea0f83732a893e81b78e62e2dda3e7e518c92ee"},
+    {file = "mypy-1.3.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c5d2cc54175bab47011b09688b418db71403aefad07cbcd62d44010543fc143f"},
+    {file = "mypy-1.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:87df44954c31d86df96c8bd6e80dfcd773473e877ac6176a8e29898bfb3501cb"},
+    {file = "mypy-1.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:473117e310febe632ddf10e745a355714e771ffe534f06db40702775056614c4"},
+    {file = "mypy-1.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:74bc9b6e0e79808bf8678d7678b2ae3736ea72d56eede3820bd3849823e7f305"},
+    {file = "mypy-1.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:44797d031a41516fcf5cbfa652265bb994e53e51994c1bd649ffcd0c3a7eccbf"},
+    {file = "mypy-1.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:ddae0f39ca146972ff6bb4399f3b2943884a774b8771ea0a8f50e971f5ea5ba8"},
+    {file = "mypy-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1c4c42c60a8103ead4c1c060ac3cdd3ff01e18fddce6f1016e08939647a0e703"},
+    {file = "mypy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e86c2c6852f62f8f2b24cb7a613ebe8e0c7dc1402c61d36a609174f63e0ff017"},
+    {file = "mypy-1.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:f9dca1e257d4cc129517779226753dbefb4f2266c4eaad610fc15c6a7e14283e"},
+    {file = "mypy-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:95d8d31a7713510685b05fbb18d6ac287a56c8f6554d88c19e73f724a445448a"},
+    {file = "mypy-1.3.0-py3-none-any.whl", hash = "sha256:a8763e72d5d9574d45ce5881962bc8e9046bf7b375b0abf031f3e6811732a897"},
+    {file = "mypy-1.3.0.tar.gz", hash = "sha256:e1f4d16e296f5135624b34e8fb741eb0eadedca90862405b1f1fde2040b9bd11"},
+]
+
+[package.dependencies]
+mypy-extensions = ">=1.0.0"
+typing-extensions = ">=3.10"
+
+[package.extras]
+dmypy = ["psutil (>=4.0)"]
+install-types = ["pip"]
+python2 = ["typed-ast (>=1.4.0,<2)"]
+reports = ["lxml"]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+description = "Type system extensions for programs checked with the mypy type checker."
+category = "dev"
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
+    {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
+]
+
+[[package]]
+name = "numpy"
+version = "1.24.3"
+description = "Fundamental package for array computing in Python"
+category = "main"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "numpy-1.24.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3c1104d3c036fb81ab923f507536daedc718d0ad5a8707c6061cdfd6d184e570"},
+    {file = "numpy-1.24.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:202de8f38fc4a45a3eea4b63e2f376e5f2dc64ef0fa692838e31a808520efaf7"},
+    {file = "numpy-1.24.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8535303847b89aa6b0f00aa1dc62867b5a32923e4d1681a35b5eef2d9591a463"},
+    {file = "numpy-1.24.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2d926b52ba1367f9acb76b0df6ed21f0b16a1ad87c6720a1121674e5cf63e2b6"},
+    {file = "numpy-1.24.3-cp310-cp310-win32.whl", hash = "sha256:f21c442fdd2805e91799fbe044a7b999b8571bb0ab0f7850d0cb9641a687092b"},
+    {file = "numpy-1.24.3-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f23af8c16022663a652d3b25dcdc272ac3f83c3af4c02eb8b824e6b3ab9d7"},
+    {file = "numpy-1.24.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9a7721ec204d3a237225db3e194c25268faf92e19338a35f3a224469cb6039a3"},
+    {file = "numpy-1.24.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d6cc757de514c00b24ae8cf5c876af2a7c3df189028d68c0cb4eaa9cd5afc2bf"},
+    {file = "numpy-1.24.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76e3f4e85fc5d4fd311f6e9b794d0c00e7002ec122be271f2019d63376f1d385"},
+    {file = "numpy-1.24.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1d3c026f57ceaad42f8231305d4653d5f05dc6332a730ae5c0bea3513de0950"},
+    {file = "numpy-1.24.3-cp311-cp311-win32.whl", hash = "sha256:c91c4afd8abc3908e00a44b2672718905b8611503f7ff87390cc0ac3423fb096"},
+    {file = "numpy-1.24.3-cp311-cp311-win_amd64.whl", hash = "sha256:5342cf6aad47943286afa6f1609cad9b4266a05e7f2ec408e2cf7aea7ff69d80"},
+    {file = "numpy-1.24.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7776ea65423ca6a15255ba1872d82d207bd1e09f6d0894ee4a64678dd2204078"},
+    {file = "numpy-1.24.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ae8d0be48d1b6ed82588934aaaa179875e7dc4f3d84da18d7eae6eb3f06c242c"},
+    {file = "numpy-1.24.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ecde0f8adef7dfdec993fd54b0f78183051b6580f606111a6d789cd14c61ea0c"},
+    {file = "numpy-1.24.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4749e053a29364d3452c034827102ee100986903263e89884922ef01a0a6fd2f"},
+    {file = "numpy-1.24.3-cp38-cp38-win32.whl", hash = "sha256:d933fabd8f6a319e8530d0de4fcc2e6a61917e0b0c271fded460032db42a0fe4"},
+    {file = "numpy-1.24.3-cp38-cp38-win_amd64.whl", hash = "sha256:56e48aec79ae238f6e4395886b5eaed058abb7231fb3361ddd7bfdf4eed54289"},
+    {file = "numpy-1.24.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4719d5aefb5189f50887773699eaf94e7d1e02bf36c1a9d353d9f46703758ca4"},
+    {file = "numpy-1.24.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0ec87a7084caa559c36e0a2309e4ecb1baa03b687201d0a847c8b0ed476a7187"},
+    {file = "numpy-1.24.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea8282b9bcfe2b5e7d491d0bf7f3e2da29700cec05b49e64d6246923329f2b02"},
+    {file = "numpy-1.24.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:210461d87fb02a84ef243cac5e814aad2b7f4be953b32cb53327bb49fd77fbb4"},
+    {file = "numpy-1.24.3-cp39-cp39-win32.whl", hash = "sha256:784c6da1a07818491b0ffd63c6bbe5a33deaa0e25a20e1b3ea20cf0e43f8046c"},
+    {file = "numpy-1.24.3-cp39-cp39-win_amd64.whl", hash = "sha256:d5036197ecae68d7f491fcdb4df90082b0d4960ca6599ba2659957aafced7c17"},
+    {file = "numpy-1.24.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:352ee00c7f8387b44d19f4cada524586f07379c0d49270f87233983bc5087ca0"},
+    {file = "numpy-1.24.3-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a7d6acc2e7524c9955e5c903160aa4ea083736fde7e91276b0e5d98e6332812"},
+    {file = "numpy-1.24.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:35400e6a8d102fd07c71ed7dcadd9eb62ee9a6e84ec159bd48c28235bbb0f8e4"},
+    {file = "numpy-1.24.3.tar.gz", hash = "sha256:ab344f1bf21f140adab8e47fdbc7c35a477dc01408791f8ba00d018dd0bc5155"},
+]
+
+[[package]]
+name = "onnxruntime"
+version = "1.15.0"
+description = "ONNX Runtime is a runtime accelerator for Machine Learning models"
+category = "main"
+optional = false
+python-versions = "*"
+files = [
+    {file = "onnxruntime-1.15.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:a61c6ff118e01d0800b19cbed8aa64cf687edd60e6d0cc39f0e9900ad324c212"},
+    {file = "onnxruntime-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:413495938e389f087c1dbc61168fbb4c5460610c0bac542c7ec3bcfba64b6bfd"},
+    {file = "onnxruntime-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbcd117186826a7b81afa10a2a4bb3882302149b07351ab5add367daf8e245cf"},
+    {file = "onnxruntime-1.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:34caf6e11b12d199c4029b6717fc679d12b41ef05a8d34badff3977eb459d5ac"},
+    {file = "onnxruntime-1.15.0-cp310-cp310-win32.whl", hash = "sha256:3155fcfa546db5d31859235a4ab21c70d10a933a3df8354a1269d3a6def1b743"},
+    {file = "onnxruntime-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:1ffde3e22d2969aeb9ab8fea3adfd7a568d28e6a2f05c369e562056a52510857"},
+    {file = "onnxruntime-1.15.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:3c89bceb1dd172ab8b288fca48eb0ac3d68796041abcd49537108581a14748ad"},
+    {file = "onnxruntime-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3216524f10b805831ac606718966c5623f001762c1fb70aa107691e03b20e8ae"},
+    {file = "onnxruntime-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99c34478cf34d64d72ed5fb0642c9e19d1bc1a42be9ffeda31420dc23a4d0af2"},
+    {file = "onnxruntime-1.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ff833c740a5054e9eba734eb1c13d6925d5a84adf1102179e46b20effe5e1a6"},
+    {file = "onnxruntime-1.15.0-cp311-cp311-win32.whl", hash = "sha256:cd3bbdb6cff207a3696c5a370717280bc04f0824de27dc03b51292b23fcff0ad"},
+    {file = "onnxruntime-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:335f26b663295f50921437f74620bc0ee8b25707a1a8987a8142452d5283d098"},
+    {file = "onnxruntime-1.15.0-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:563c56bbf7331686cb72d93b47fa96f4fdf883dbdf7398dc07ba6011a4311c40"},
+    {file = "onnxruntime-1.15.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:de66cd57e8db8be3783ce478eaade75c07e9b1ce0f3c12500b34d1683d6c13e5"},
+    {file = "onnxruntime-1.15.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:101310d7ed44b43f35d1158033266b9df4994b80691ded7517f389d7fc281353"},
+    {file = "onnxruntime-1.15.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3df38690e495c57ae3d160210c3567a53f0b38dcc4526983af69e89a6f762d9"},
+    {file = "onnxruntime-1.15.0-cp38-cp38-win32.whl", hash = "sha256:84ad51d1be998a250acd93e61f1db699628b523caf12c3bf863c3204e9e6ceda"},
+    {file = "onnxruntime-1.15.0-cp38-cp38-win_amd64.whl", hash = "sha256:4d443c544370e28d2ad2d5e472ba32eb7cbc62ef7e315e66ec75c3292f47cee5"},
+    {file = "onnxruntime-1.15.0-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:80861aa47817fa0db29f5e818e567afd2b0013373418413435cc3dd361458fe8"},
+    {file = "onnxruntime-1.15.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:df402e46432fb038fca9bfe8d1a489396b54b6253ec26398f6d8b0322276fc99"},
+    {file = "onnxruntime-1.15.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5c5afc01e0109f26a06ea19e132f7b934878ec81fac4557d35c5f3d01ca2a17"},
+    {file = "onnxruntime-1.15.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67bbb583d7f6f98c831945f664a5d302a65c3cc9dc8da793d2acce0260650927"},
+    {file = "onnxruntime-1.15.0-cp39-cp39-win32.whl", hash = "sha256:b21438216c0a9985c224938431259959ddf71c7949f9e5759d6ad68fb5f61717"},
+    {file = "onnxruntime-1.15.0-cp39-cp39-win_amd64.whl", hash = "sha256:e83521ddbeef421c3e697a7cc803e826a0d1b7a40446a857572700b6ab5f4083"},
+]
+
+[package.dependencies]
+coloredlogs = "*"
+flatbuffers = "*"
+numpy = ">=1.21.6"
+packaging = "*"
+protobuf = "*"
+sympy = "*"
+
+[[package]]
+name = "packaging"
+version = "23.1"
+description = "Core utilities for Python packages"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "packaging-23.1-py3-none-any.whl", hash = "sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61"},
+    {file = "packaging-23.1.tar.gz", hash = "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"},
+]
+
+[[package]]
+name = "protobuf"
+version = "4.23.1"
+description = ""
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "protobuf-4.23.1-cp310-abi3-win32.whl", hash = "sha256:410bcc0a5b279f634d3e16082ce221dfef7c3392fac723500e2e64d1806dd2be"},
+    {file = "protobuf-4.23.1-cp310-abi3-win_amd64.whl", hash = "sha256:32e78beda26d7a101fecf15d7a4a792278a0d26a31bc327ff05564a9d68ab8ee"},
+    {file = "protobuf-4.23.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f9510cac91e764e86acd74e2b7f7bc5e6127a7f3fb646d7c8033cfb84fd1176a"},
+    {file = "protobuf-4.23.1-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:346990f634272caac1f09efbcfbbacb23098b1f606d172534c6fa2d9758bb436"},
+    {file = "protobuf-4.23.1-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:3ce113b3f3362493bddc9069c2163a38f240a9ed685ff83e7bcb756b05e1deb0"},
+    {file = "protobuf-4.23.1-cp37-cp37m-win32.whl", hash = "sha256:2036a3a1e7fc27f973fa0a7888dce712393af644f4695385f117886abc792e39"},
+    {file = "protobuf-4.23.1-cp37-cp37m-win_amd64.whl", hash = "sha256:3b8905eafe4439076e1f58e9d1fa327025fd2777cf90f14083092ae47f77b0aa"},
+    {file = "protobuf-4.23.1-cp38-cp38-win32.whl", hash = "sha256:5b9cd6097e6acae48a68cb29b56bc79339be84eca65b486910bb1e7a30e2b7c1"},
+    {file = "protobuf-4.23.1-cp38-cp38-win_amd64.whl", hash = "sha256:decf119d54e820f298ee6d89c72d6b289ea240c32c521f00433f9dc420595f38"},
+    {file = "protobuf-4.23.1-cp39-cp39-win32.whl", hash = "sha256:91fac0753c3c4951fbb98a93271c43cc7cf3b93cf67747b3e600bb1e5cc14d61"},
+    {file = "protobuf-4.23.1-cp39-cp39-win_amd64.whl", hash = "sha256:ac50be82491369a9ec3710565777e4da87c6d2e20404e0abb1f3a8f10ffd20f0"},
+    {file = "protobuf-4.23.1-py3-none-any.whl", hash = "sha256:65f0ac96ef67d7dd09b19a46aad81a851b6f85f89725577f16de38f2d68ad477"},
+    {file = "protobuf-4.23.1.tar.gz", hash = "sha256:95789b569418a3e32a53f43d7763be3d490a831e9c08042539462b6d972c2d7e"},
+]
+
+[[package]]
+name = "pycodestyle"
+version = "2.10.0"
+description = "Python style guide checker"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "pycodestyle-2.10.0-py2.py3-none-any.whl", hash = "sha256:8a4eaf0d0495c7395bdab3589ac2db602797d76207242c17d470186815706610"},
+    {file = "pycodestyle-2.10.0.tar.gz", hash = "sha256:347187bdb476329d98f695c213d7295a846d1152ff4fe9bacb8a9590b8ee7053"},
+]
+
+[[package]]
+name = "pyflakes"
+version = "3.0.1"
+description = "passive checker of Python programs"
+category = "dev"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "pyflakes-3.0.1-py2.py3-none-any.whl", hash = "sha256:ec55bf7fe21fff7f1ad2f7da62363d749e2a470500eab1b555334b67aa1ef8cf"},
+    {file = "pyflakes-3.0.1.tar.gz", hash = "sha256:ec8b276a6b60bd80defed25add7e439881c19e64850afd9b346283d4165fd0fd"},
+]
+
+[[package]]
+name = "pyreadline3"
+version = "3.4.1"
+description = "A python implementation of GNU readline."
+category = "main"
+optional = false
+python-versions = "*"
+files = [
+    {file = "pyreadline3-3.4.1-py3-none-any.whl", hash = "sha256:b0efb6516fd4fb07b45949053826a62fa4cb353db5be2bbb4a7aa1fdd1e345fb"},
+    {file = "pyreadline3-3.4.1.tar.gz", hash = "sha256:6f3d1f7b8a31ba32b73917cefc1f28cc660562f39aea8646d30bd6eff21f7bae"},
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0"
+description = "YAML parser and emitter for Python"
+category = "main"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "PyYAML-6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4db7c7aef085872ef65a8fd7d6d09a14ae91f691dec3e87ee5ee0539d516f53"},
+    {file = "PyYAML-6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9df7ed3b3d2e0ecfe09e14741b857df43adb5a3ddadc919a2d94fbdf78fea53c"},
+    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77f396e6ef4c73fdc33a9157446466f1cff553d979bd00ecb64385760c6babdc"},
+    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a80a78046a72361de73f8f395f1f1e49f956c6be882eed58505a15f3e430962b"},
+    {file = "PyYAML-6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:f84fbc98b019fef2ee9a1cb3ce93e3187a6df0b2538a651bfb890254ba9f90b5"},
+    {file = "PyYAML-6.0-cp310-cp310-win32.whl", hash = "sha256:2cd5df3de48857ed0544b34e2d40e9fac445930039f3cfe4bcc592a1f836d513"},
+    {file = "PyYAML-6.0-cp310-cp310-win_amd64.whl", hash = "sha256:daf496c58a8c52083df09b80c860005194014c3698698d1a57cbcfa182142a3a"},
+    {file = "PyYAML-6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d4b0ba9512519522b118090257be113b9468d804b19d63c71dbcf4a48fa32358"},
+    {file = "PyYAML-6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:81957921f441d50af23654aa6c5e5eaf9b06aba7f0a19c18a538dc7ef291c5a1"},
+    {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afa17f5bc4d1b10afd4466fd3a44dc0e245382deca5b3c353d8b757f9e3ecb8d"},
+    {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dbad0e9d368bb989f4515da330b88a057617d16b6a8245084f1b05400f24609f"},
+    {file = "PyYAML-6.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:432557aa2c09802be39460360ddffd48156e30721f5e8d917f01d31694216782"},
+    {file = "PyYAML-6.0-cp311-cp311-win32.whl", hash = "sha256:bfaef573a63ba8923503d27530362590ff4f576c626d86a9fed95822a8255fd7"},
+    {file = "PyYAML-6.0-cp311-cp311-win_amd64.whl", hash = "sha256:01b45c0191e6d66c470b6cf1b9531a771a83c1c4208272ead47a3ae4f2f603bf"},
+    {file = "PyYAML-6.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:897b80890765f037df3403d22bab41627ca8811ae55e9a722fd0392850ec4d86"},
+    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50602afada6d6cbfad699b0c7bb50d5ccffa7e46a3d738092afddc1f9758427f"},
+    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:48c346915c114f5fdb3ead70312bd042a953a8ce5c7106d5bfb1a5254e47da92"},
+    {file = "PyYAML-6.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:98c4d36e99714e55cfbaaee6dd5badbc9a1ec339ebfc3b1f52e293aee6bb71a4"},
+    {file = "PyYAML-6.0-cp36-cp36m-win32.whl", hash = "sha256:0283c35a6a9fbf047493e3a0ce8d79ef5030852c51e9d911a27badfde0605293"},
+    {file = "PyYAML-6.0-cp36-cp36m-win_amd64.whl", hash = "sha256:07751360502caac1c067a8132d150cf3d61339af5691fe9e87803040dbc5db57"},
+    {file = "PyYAML-6.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:819b3830a1543db06c4d4b865e70ded25be52a2e0631ccd2f6a47a2822f2fd7c"},
+    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:473f9edb243cb1935ab5a084eb238d842fb8f404ed2193a915d1784b5a6b5fc0"},
+    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ce82d761c532fe4ec3f87fc45688bdd3a4c1dc5e0b4a19814b9009a29baefd4"},
+    {file = "PyYAML-6.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:231710d57adfd809ef5d34183b8ed1eeae3f76459c18fb4a0b373ad56bedcdd9"},
+    {file = "PyYAML-6.0-cp37-cp37m-win32.whl", hash = "sha256:c5687b8d43cf58545ade1fe3e055f70eac7a5a1a0bf42824308d868289a95737"},
+    {file = "PyYAML-6.0-cp37-cp37m-win_amd64.whl", hash = "sha256:d15a181d1ecd0d4270dc32edb46f7cb7733c7c508857278d3d378d14d606db2d"},
+    {file = "PyYAML-6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0b4624f379dab24d3725ffde76559cff63d9ec94e1736b556dacdfebe5ab6d4b"},
+    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:213c60cd50106436cc818accf5baa1aba61c0189ff610f64f4a3e8c6726218ba"},
+    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9fa600030013c4de8165339db93d182b9431076eb98eb40ee068700c9c813e34"},
+    {file = "PyYAML-6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:277a0ef2981ca40581a47093e9e2d13b3f1fbbeffae064c1d21bfceba2030287"},
+    {file = "PyYAML-6.0-cp38-cp38-win32.whl", hash = "sha256:d4eccecf9adf6fbcc6861a38015c2a64f38b9d94838ac1810a9023a0609e1b78"},
+    {file = "PyYAML-6.0-cp38-cp38-win_amd64.whl", hash = "sha256:1e4747bc279b4f613a09eb64bba2ba602d8a6664c6ce6396a4d0cd413a50ce07"},
+    {file = "PyYAML-6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:055d937d65826939cb044fc8c9b08889e8c743fdc6a32b33e2390f66013e449b"},
+    {file = "PyYAML-6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e61ceaab6f49fb8bdfaa0f92c4b57bcfbea54c09277b1b4f7ac376bfb7a7c174"},
+    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d67d839ede4ed1b28a4e8909735fc992a923cdb84e618544973d7dfc71540803"},
+    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cba8c411ef271aa037d7357a2bc8f9ee8b58b9965831d9e51baf703280dc73d3"},
+    {file = "PyYAML-6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:40527857252b61eacd1d9af500c3337ba8deb8fc298940291486c465c8b46ec0"},
+    {file = "PyYAML-6.0-cp39-cp39-win32.whl", hash = "sha256:b5b9eccad747aabaaffbc6064800670f0c297e52c12754eb1d976c57e4f74dcb"},
+    {file = "PyYAML-6.0-cp39-cp39-win_amd64.whl", hash = "sha256:b3d267842bf12586ba6c734f89d1f5b871df0273157918b0ccefa29deb05c21c"},
+    {file = "PyYAML-6.0.tar.gz", hash = "sha256:68fb519c14306fec9720a2a5b45bc9f0c8d1b9c72adf45c37baedfcd949c35a2"},
+]
+
+[[package]]
+name = "requests"
+version = "2.31.0"
+description = "Python HTTP for Humans."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"},
+    {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"},
+]
+
+[package.dependencies]
+certifi = ">=2017.4.17"
+charset-normalizer = ">=2,<4"
+idna = ">=2.5,<4"
+urllib3 = ">=1.21.1,<3"
+
+[package.extras]
+socks = ["PySocks (>=1.5.6,!=1.5.7)"]
+use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
+
+[[package]]
+name = "sympy"
+version = "1.12"
+description = "Computer algebra system (CAS) in Python"
+category = "main"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "sympy-1.12-py3-none-any.whl", hash = "sha256:c3588cd4295d0c0f603d0f2ae780587e64e2efeedb3521e46b9bb1d08d184fa5"},
+    {file = "sympy-1.12.tar.gz", hash = "sha256:ebf595c8dac3e0fdc4152c51878b498396ec7f30e7a914d6071e674d49420fb8"},
+]
+
+[package.dependencies]
+mpmath = ">=0.19"
+
+[[package]]
+name = "termcolor"
+version = "2.3.0"
+description = "ANSI color formatting for output in terminal"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "termcolor-2.3.0-py3-none-any.whl", hash = "sha256:3afb05607b89aed0ffe25202399ee0867ad4d3cb4180d98aaf8eefa6a5f7d475"},
+    {file = "termcolor-2.3.0.tar.gz", hash = "sha256:b5b08f68937f138fe92f6c089b99f1e2da0ae56c52b78bf7075fd95420fd9a5a"},
+]
+
+[package.extras]
+tests = ["pytest", "pytest-cov"]
+
+[[package]]
+name = "tokenizers"
+version = "0.13.3"
+description = "Fast and Customizable Tokenizers"
+category = "main"
+optional = false
+python-versions = "*"
+files = [
+    {file = "tokenizers-0.13.3-cp310-cp310-macosx_10_11_x86_64.whl", hash = "sha256:f3835c5be51de8c0a092058a4d4380cb9244fb34681fd0a295fbf0a52a5fdf33"},
+    {file = "tokenizers-0.13.3-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:4ef4c3e821730f2692489e926b184321e887f34fb8a6b80b8096b966ba663d07"},
+    {file = "tokenizers-0.13.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5fd1a6a25353e9aa762e2aae5a1e63883cad9f4e997c447ec39d071020459bc"},
+    {file = "tokenizers-0.13.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ee0b1b311d65beab83d7a41c56a1e46ab732a9eed4460648e8eb0bd69fc2d059"},
+    {file = "tokenizers-0.13.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ef4215284df1277dadbcc5e17d4882bda19f770d02348e73523f7e7d8b8d396"},
+    {file = "tokenizers-0.13.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a4d53976079cff8a033f778fb9adca2d9d69d009c02fa2d71a878b5f3963ed30"},
+    {file = "tokenizers-0.13.3-cp310-cp310-win32.whl", hash = "sha256:1f0e3b4c2ea2cd13238ce43548959c118069db7579e5d40ec270ad77da5833ce"},
+    {file = "tokenizers-0.13.3-cp310-cp310-win_amd64.whl", hash = "sha256:89649c00d0d7211e8186f7a75dfa1db6996f65edce4b84821817eadcc2d3c79e"},
+    {file = "tokenizers-0.13.3-cp311-cp311-macosx_10_11_universal2.whl", hash = "sha256:56b726e0d2bbc9243872b0144515ba684af5b8d8cd112fb83ee1365e26ec74c8"},
+    {file = "tokenizers-0.13.3-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:cc5c022ce692e1f499d745af293ab9ee6f5d92538ed2faf73f9708c89ee59ce6"},
+    {file = "tokenizers-0.13.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f55c981ac44ba87c93e847c333e58c12abcbb377a0c2f2ef96e1a266e4184ff2"},
+    {file = "tokenizers-0.13.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f247eae99800ef821a91f47c5280e9e9afaeed9980fc444208d5aa6ba69ff148"},
+    {file = "tokenizers-0.13.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4b3e3215d048e94f40f1c95802e45dcc37c5b05eb46280fc2ccc8cd351bff839"},
+    {file = "tokenizers-0.13.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ba2b0bf01777c9b9bc94b53764d6684554ce98551fec496f71bc5be3a03e98b"},
+    {file = "tokenizers-0.13.3-cp311-cp311-win32.whl", hash = "sha256:cc78d77f597d1c458bf0ea7c2a64b6aa06941c7a99cb135b5969b0278824d808"},
+    {file = "tokenizers-0.13.3-cp311-cp311-win_amd64.whl", hash = "sha256:ecf182bf59bd541a8876deccf0360f5ae60496fd50b58510048020751cf1724c"},
+    {file = "tokenizers-0.13.3-cp37-cp37m-macosx_10_11_x86_64.whl", hash = "sha256:0527dc5436a1f6bf2c0327da3145687d3bcfbeab91fed8458920093de3901b44"},
+    {file = "tokenizers-0.13.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07cbb2c307627dc99b44b22ef05ff4473aa7c7cc1fec8f0a8b37d8a64b1a16d2"},
+    {file = "tokenizers-0.13.3-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4560dbdeaae5b7ee0d4e493027e3de6d53c991b5002d7ff95083c99e11dd5ac0"},
+    {file = "tokenizers-0.13.3-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:64064bd0322405c9374305ab9b4c07152a1474370327499911937fd4a76d004b"},
+    {file = "tokenizers-0.13.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8c6e2ab0f2e3d939ca66aa1d596602105fe33b505cd2854a4c1717f704c51de"},
+    {file = "tokenizers-0.13.3-cp37-cp37m-win32.whl", hash = "sha256:6cc29d410768f960db8677221e497226e545eaaea01aa3613fa0fdf2cc96cff4"},
+    {file = "tokenizers-0.13.3-cp37-cp37m-win_amd64.whl", hash = "sha256:fc2a7fdf864554a0dacf09d32e17c0caa9afe72baf9dd7ddedc61973bae352d8"},
+    {file = "tokenizers-0.13.3-cp38-cp38-macosx_10_11_x86_64.whl", hash = "sha256:8791dedba834c1fc55e5f1521be325ea3dafb381964be20684b92fdac95d79b7"},
+    {file = "tokenizers-0.13.3-cp38-cp38-macosx_12_0_arm64.whl", hash = "sha256:d607a6a13718aeb20507bdf2b96162ead5145bbbfa26788d6b833f98b31b26e1"},
+    {file = "tokenizers-0.13.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3791338f809cd1bf8e4fee6b540b36822434d0c6c6bc47162448deee3f77d425"},
+    {file = "tokenizers-0.13.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c2f35f30e39e6aab8716f07790f646bdc6e4a853816cc49a95ef2a9016bf9ce6"},
+    {file = "tokenizers-0.13.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:310204dfed5aa797128b65d63538a9837cbdd15da2a29a77d67eefa489edda26"},
+    {file = "tokenizers-0.13.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0f9b92ea052305166559f38498b3b0cae159caea712646648aaa272f7160963"},
+    {file = "tokenizers-0.13.3-cp38-cp38-win32.whl", hash = "sha256:9a3fa134896c3c1f0da6e762d15141fbff30d094067c8f1157b9fdca593b5806"},
+    {file = "tokenizers-0.13.3-cp38-cp38-win_amd64.whl", hash = "sha256:8e7b0cdeace87fa9e760e6a605e0ae8fc14b7d72e9fc19c578116f7287bb873d"},
+    {file = "tokenizers-0.13.3-cp39-cp39-macosx_10_11_x86_64.whl", hash = "sha256:00cee1e0859d55507e693a48fa4aef07060c4bb6bd93d80120e18fea9371c66d"},
+    {file = "tokenizers-0.13.3-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:a23ff602d0797cea1d0506ce69b27523b07e70f6dda982ab8cf82402de839088"},
+    {file = "tokenizers-0.13.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70ce07445050b537d2696022dafb115307abdffd2a5c106f029490f84501ef97"},
+    {file = "tokenizers-0.13.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:280ffe95f50eaaf655b3a1dc7ff1d9cf4777029dbbc3e63a74e65a056594abc3"},
+    {file = "tokenizers-0.13.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97acfcec592f7e9de8cadcdcda50a7134423ac8455c0166b28c9ff04d227b371"},
+    {file = "tokenizers-0.13.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd7730c98a3010cd4f523465867ff95cd9d6430db46676ce79358f65ae39797b"},
+    {file = "tokenizers-0.13.3-cp39-cp39-win32.whl", hash = "sha256:48625a108029cb1ddf42e17a81b5a3230ba6888a70c9dc14e81bc319e812652d"},
+    {file = "tokenizers-0.13.3-cp39-cp39-win_amd64.whl", hash = "sha256:bc0a6f1ba036e482db6453571c9e3e60ecd5489980ffd95d11dc9f960483d783"},
+    {file = "tokenizers-0.13.3.tar.gz", hash = "sha256:2e546dbb68b623008a5442353137fbb0123d311a6d7ba52f2667c8862a75af2e"},
+]
+
+[package.extras]
+dev = ["black (==22.3)", "datasets", "numpy", "pytest", "requests"]
+docs = ["setuptools-rust", "sphinx", "sphinx-rtd-theme"]
+testing = ["black (==22.3)", "datasets", "numpy", "pytest", "requests"]
+
+[[package]]
+name = "tqdm"
+version = "4.65.0"
+description = "Fast, Extensible Progress Meter"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "tqdm-4.65.0-py3-none-any.whl", hash = "sha256:c4f53a17fe37e132815abceec022631be8ffe1b9381c2e6e30aa70edc99e9671"},
+    {file = "tqdm-4.65.0.tar.gz", hash = "sha256:1871fb68a86b8fb3b59ca4cdd3dcccbc7e6d613eeed31f4c332531977b89beb5"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
+[package.extras]
+dev = ["py-make (>=0.1.0)", "twine", "wheel"]
+notebook = ["ipywidgets (>=6)"]
+slack = ["slack-sdk"]
+telegram = ["requests"]
+
+[[package]]
+name = "typing-extensions"
+version = "4.6.2"
+description = "Backported and Experimental Type Hints for Python 3.7+"
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "typing_extensions-4.6.2-py3-none-any.whl", hash = "sha256:3a8b36f13dd5fdc5d1b16fe317f5668545de77fa0b8e02006381fd49d731ab98"},
+    {file = "typing_extensions-4.6.2.tar.gz", hash = "sha256:06006244c70ac8ee83fa8282cb188f697b8db25bc8b4df07be1873c43897060c"},
+]
+
+[[package]]
+name = "urllib3"
+version = "2.0.2"
+description = "HTTP library with thread-safe connection pooling, file post, and more."
+category = "main"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "urllib3-2.0.2-py3-none-any.whl", hash = "sha256:d055c2f9d38dc53c808f6fdc8eab7360b6fdbbde02340ed25cfbcd817c62469e"},
+    {file = "urllib3-2.0.2.tar.gz", hash = "sha256:61717a1095d7e155cdb737ac7bb2f4324a858a1e2e6466f6d03ff630ca68d3cc"},
+]
+
+[package.extras]
+brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
+secure = ["certifi", "cryptography (>=1.9)", "idna (>=2.0.0)", "pyopenssl (>=17.1.0)", "urllib3-secure-extra"]
+socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
+zstd = ["zstandard (>=0.18.0)"]
+
+[metadata]
+lock-version = "2.0"
+python-versions = "^3.11"
+content-hash = "676cd6a816cb0857852cddee75205a81e6cccda3eeafb1bf431714626a2122ee"
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..8fd320d
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,48 @@
+[tool.poetry]
+name = "pf-video-transcribe"
+version = "0.1.0"
+description = "Transcribe videos and create html pages with that"
+authors = ["Gustavo Sverzut Barbieri <barbieri@profusion.mobi>"]
+license = "MIT"
+readme = "README.rst"
+packages = [{include = "pf_video_transcribe"}]
+
+[tool.poetry.scripts]
+pf-video-transcribe = "pf_video_transcribe.__main__:cli"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+faster-whisper = "^0.6.0"
+termcolor = "^2.3.0"
+tqdm = "^4.65.0"
+jinja2 = "^3.1.2"
+ffmpeg-python = "^0.2.0"
+
+[tool.poetry.group.dev.dependencies]
+flake8 = "^6.0.0"
+mypy = "^1.2"
+
+[tool.mypy]
+packages = ["pf_video_transcribe"]
+disallow_untyped_calls = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+
+[tool.black]
+line-length = 88
+target-version = ['py311']
+
+# disable isort, for IDEs that just default isort to be turned on, e.g. vscode.
+# we use flake8-import-order for import sorting, using zimports to actually
+# reformat code.  isort is nicer in many ways but doesn't have our
+# "import *" fixer and also is not 100% compatible with flake8-import-order.
+[tool.isort]
+skip_glob=['*']
+
+[tool.zimports]
+black-line-length = 88
+keep-unused-type-checking = true
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000..57ae0ef
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,23 @@
+[flake8]
+show-source = true
+max-line-length = 88
+enable-extensions = G
+# E203 is due to https://github.com/PyCQA/pycodestyle/issues/373
+ignore =
+    A003,
+    D,
+    E203,E266,E305,E711,E712,E721,E722,E741,
+    N801,N802,N806,
+    RST304,RST303,RST299,RST399,
+    W503,W504
+exclude =
+    .venv,
+    .git,
+    .tox,
+    dist/,
+    build/,
+    *egg
+import-order-style = google
+application-import-names = pf_video_transcribe
+per-file-ignores =
+    **/__init__.py:F401,F403