parse-avidemux-project 0.1.0__tar.gz

parse_avidemux_project-0.1.0/LICENSE

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

parse_avidemux_project-0.1.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: parse-avidemux-project
+Version: 0.1.0
+Summary: Parser for Avidemux TinyPY project scripts
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ferrous-lux/parse_avidemux_project
+Project-URL: Source, https://github.com/ferrous-lux/parse_avidemux_project
+Project-URL: BugTracker, https://github.com/ferrous-lux/parse_avidemux_project/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# parse-avidemux-project
+
+Standalone Python library for parsing [Avidemux](https://avidemux.sourceforge.net/) TinyPY project scripts into structured data (video path, segments, filters, audio tracks, etc.). No ffmpeg, ccextractor, or Avidemux CLI required.
+
+## Installation
+
+```bash
+pip install parse-avidemux-project
+```
+
+## CLI Usage
+
+```bash
+parse-avidemux-project input.py -o output.json
+```
+
+Omitting `-o` prints the JSON to stdout.
+
+## Python API
+
+```python
+from parse_avidemux_project import (
+    AvidemuxProject,
+    Segment,
+    AudioTrack,
+    parse_project,
+    parse_project_file,
+    us_to_iso_time,
+)
+
+# Parse a file
+project: AvidemuxProject = parse_project_file("project.py")
+
+# Or parse a string
+project = parse_project('''
+    adm = Avidemux()
+    if not adm.loadVideo("/path/to/video.mkv"):
+        raise
+    adm.addSegment(0, 1000000, 5000000)
+    adm.markerA = 0
+    adm.markerB = 6000000
+''')
+
+print(project.video_file)       # /path/to/video.mkv
+print(project.segments)         # [Segment(start=1000000, duration=5000000)]
+print(project.segments[0].end)  # 6000000 (computed property)
+
+# Convert to dict for JSON serialization
+print(project.to_dict())
+
+# Microsecond to ISO time conversion
+print(us_to_iso_time(3661000000))  # 01:01:01.000
+```
+
+### Data model
+
+| Attribute | Type | Description |
+|---|---|---|
+| `video_file` | `str \| None` | Path to the source video |
+| `segments` | `list[Segment]` | List of cut segments (each has `start`, `duration`, and `end` property) |
+| `marker_a`, `marker_b` | `int \| None` | A/B markers in microseconds |
+| `video_codec` | `str \| None` | Output video codec |
+| `container` | `str \| None` | Output container format |
+| `container_options` | `dict[str, str]` | Container options |
+| `audio_tracks` | `list[AudioTrack]` | Audio track configs (each has `index`, `language`, `codec`) |
+| `hdr_config` | `tuple[int, ...]` | HDR parameters |
+
+## License
+
+MIT

parse_avidemux_project-0.1.0/README.md

@@ -0,0 +1,70 @@
+# parse-avidemux-project
+
+Standalone Python library for parsing [Avidemux](https://avidemux.sourceforge.net/) TinyPY project scripts into structured data (video path, segments, filters, audio tracks, etc.). No ffmpeg, ccextractor, or Avidemux CLI required.
+
+## Installation
+
+```bash
+pip install parse-avidemux-project
+```
+
+## CLI Usage
+
+```bash
+parse-avidemux-project input.py -o output.json
+```
+
+Omitting `-o` prints the JSON to stdout.
+
+## Python API
+
+```python
+from parse_avidemux_project import (
+    AvidemuxProject,
+    Segment,
+    AudioTrack,
+    parse_project,
+    parse_project_file,
+    us_to_iso_time,
+)
+
+# Parse a file
+project: AvidemuxProject = parse_project_file("project.py")
+
+# Or parse a string
+project = parse_project('''
+    adm = Avidemux()
+    if not adm.loadVideo("/path/to/video.mkv"):
+        raise
+    adm.addSegment(0, 1000000, 5000000)
+    adm.markerA = 0
+    adm.markerB = 6000000
+''')
+
+print(project.video_file)       # /path/to/video.mkv
+print(project.segments)         # [Segment(start=1000000, duration=5000000)]
+print(project.segments[0].end)  # 6000000 (computed property)
+
+# Convert to dict for JSON serialization
+print(project.to_dict())
+
+# Microsecond to ISO time conversion
+print(us_to_iso_time(3661000000))  # 01:01:01.000
+```
+
+### Data model
+
+| Attribute | Type | Description |
+|---|---|---|
+| `video_file` | `str \| None` | Path to the source video |
+| `segments` | `list[Segment]` | List of cut segments (each has `start`, `duration`, and `end` property) |
+| `marker_a`, `marker_b` | `int \| None` | A/B markers in microseconds |
+| `video_codec` | `str \| None` | Output video codec |
+| `container` | `str \| None` | Output container format |
+| `container_options` | `dict[str, str]` | Container options |
+| `audio_tracks` | `list[AudioTrack]` | Audio track configs (each has `index`, `language`, `codec`) |
+| `hdr_config` | `tuple[int, ...]` | HDR parameters |
+
+## License
+
+MIT

parse_avidemux_project-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=75"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "parse-avidemux-project"
+version = "0.1.0"
+description = "Parser for Avidemux TinyPY project scripts"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/ferrous-lux/parse_avidemux_project"
+Source = "https://github.com/ferrous-lux/parse_avidemux_project"
+BugTracker = "https://github.com/ferrous-lux/parse_avidemux_project/issues"
+
+[project.scripts]
+parse-avidemux-project = "parse_avidemux_project.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+exclude = ["tests/fixtures"]
+
+[tool.mypy]
+exclude = ["tests/fixtures/"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

parse_avidemux_project-0.1.0/setup.cfg

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

parse_avidemux_project-0.1.0/src/parse_avidemux_project/__init__.py

@@ -0,0 +1,11 @@
+from .models import AudioTrack, AvidemuxProject, Segment
+from .parser import parse_project, parse_project_file, us_to_iso_time
+
+__all__ = [
+    "AudioTrack",
+    "AvidemuxProject",
+    "Segment",
+    "parse_project",
+    "parse_project_file",
+    "us_to_iso_time",
+]

parse_avidemux_project-0.1.0/src/parse_avidemux_project/cli.py

@@ -0,0 +1,38 @@
+import argparse
+import json
+import sys
+
+from . import parse_project_file
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Parse an Avidemux TinyPY project file to JSON."
+    )
+    parser.add_argument("input", help="Path to the Avidemux project file (.py)")
+    parser.add_argument(
+        "-o", "--output",
+        help="Path to write JSON output (default: stdout)",
+    )
+    args = parser.parse_args()
+
+    try:
+        project = parse_project_file(args.input)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except ValueError as e:
+        print(f"Parse error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    output = json.dumps(project.to_dict(), indent=4)
+
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as f:
+            f.write(output)
+    else:
+        print(output)
+
+
+if __name__ == "__main__":
+    main()

parse_avidemux_project-0.1.0/src/parse_avidemux_project/models.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass, field, asdict
+
+
+@dataclass
+class Segment:
+    start: int
+    duration: int
+
+    @property
+    def end(self) -> int:
+        return self.start + self.duration
+
+
+@dataclass
+class AudioTrack:
+    index: int
+    language: str | None = None
+    codec: str | None = None
+
+
+@dataclass
+class AvidemuxProject:
+    video_file: str | None = None
+    segments: list[Segment] = field(default_factory=list)
+    marker_a: int | None = None
+    marker_b: int | None = None
+    video_codec: str | None = None
+    container: str | None = None
+    container_options: dict[str, str] = field(default_factory=dict)
+    audio_tracks: list[AudioTrack] = field(default_factory=list)
+    hdr_config: tuple[int, ...] = field(default_factory=tuple)
+
+    def to_dict(self) -> dict:
+        return {
+            "video_file": self.video_file,
+            "segments": [asdict(s) | {"end": s.end} for s in self.segments],
+            "marker_a": self.marker_a,
+            "marker_b": self.marker_b,
+            "video_codec": self.video_codec,
+            "container": self.container,
+            "container_options": self.container_options,
+            "audio_tracks": [asdict(t) for t in self.audio_tracks],
+            "hdr_config": list(self.hdr_config),
+        }

parse_avidemux_project-0.1.0/src/parse_avidemux_project/parser.py

@@ -0,0 +1,163 @@
+import re
+
+from .models import AudioTrack, AvidemuxProject, Segment
+
+
+def parse_project(content: str) -> AvidemuxProject:
+    """
+    Parse an Avidemux TinyPY script into a structured AvidemuxProject object.
+
+    Parameters:
+    content (str): The full text of an Avidemux TinyPY project file.
+
+    Returns:
+    AvidemuxProject: Structured representation of the project.
+
+    Raises:
+    ValueError: If the content cannot be parsed as a valid Avidemux project.
+    """
+    video_file = _parse_video_file(content)
+    segments = _parse_segments(content)
+
+    if video_file is None and not segments:
+        raise ValueError("No Avidemux project data found in content")
+
+    return AvidemuxProject(
+        video_file=video_file,
+        segments=segments,
+        marker_a=_parse_marker(content, "A"),
+        marker_b=_parse_marker(content, "B"),
+        video_codec=_parse_video_codec(content),
+        container=_parse_container(content),
+        container_options=_parse_container_options(content),
+        audio_tracks=_parse_audio_tracks(content),
+        hdr_config=_parse_hdr_config(content),
+    )
+
+
+def parse_project_file(path: str) -> AvidemuxProject:
+    """
+    Read and parse an Avidemux TinyPY project file.
+
+    Parameters:
+    path (str): Filesystem path to a TinyPY project file.
+
+    Returns:
+    AvidemuxProject: Structured representation of the project.
+    """
+    with open(path, encoding="utf-8") as f:
+        return parse_project(f.read())
+
+
+def us_to_iso_time(us: int) -> str:
+    """
+    Convert microseconds to the format HH:MM:SS.mmm.
+
+    Parameters:
+    us (int): Microseconds to convert.
+
+    Returns:
+    str: Formatted time string.
+    """
+    ms = int(us) // 1000
+    hours = ms // 3600000
+    minutes = (ms % 3600000) // 60000
+    seconds = (ms % 60000) // 1000
+    milliseconds = ms % 1000
+    return f"{hours:02}:{minutes:02}:{seconds:02}.{milliseconds:03}"
+
+
+_PATTERN_VIDEO = re.compile(
+    r"adm = Avidemux\(\)\s*\n"
+    r'if not adm\.loadVideo\("(.+?)"\):\s*raise'
+)
+
+_PATTERN_SEGMENT = re.compile(r"adm\.addSegment\(0, (\d+), (\d+)\)")
+
+_PATTERN_MARKER = re.compile(r"adm\.marker([AB])\s*=\s*(\d+)")
+
+_PATTERN_VIDEO_CODEC = re.compile(r'adm\.videoCodec\("(.+?)"\)')
+
+_PATTERN_CONTAINER = re.compile(r"adm\.setContainer\(([^)]+)\)")
+
+_PATTERN_HDR_CONFIG = re.compile(r"adm\.setHDRConfig\(([^)]+)\)")
+
+_PATTERN_SOURCE_LANG = re.compile(r'adm\.setSourceTrackLanguage\((\d+),"(.+?)"\)')
+
+_PATTERN_AUDIO_ADD = re.compile(r"adm\.audioAddTrack\((\d+)\)")
+
+_PATTERN_AUDIO_CODEC = re.compile(r'adm\.audioCodec\((\d+), "(.+?)"\)')
+
+
+def _parse_video_file(content: str) -> str | None:
+    match = _PATTERN_VIDEO.search(content)
+    return match.group(1) if match else None
+
+
+def _parse_segments(content: str) -> list[Segment]:
+    matches = _PATTERN_SEGMENT.findall(content)
+    return [Segment(start=int(start), duration=int(duration)) for start, duration in matches]
+
+
+def _parse_marker(content: str, marker: str) -> int | None:
+    for m, val in _PATTERN_MARKER.findall(content):
+        if m == marker:
+            return int(val)
+    return None
+
+
+def _parse_video_codec(content: str) -> str | None:
+    match = _PATTERN_VIDEO_CODEC.search(content)
+    return match.group(1) if match else None
+
+
+def _parse_container(content: str) -> str | None:
+    match = _PATTERN_CONTAINER.search(content)
+    if not match:
+        return None
+    parts = re.findall(r'"([^"]*)"', match.group(1))
+    return parts[0] if parts else None
+
+
+def _parse_container_options(content: str) -> dict[str, str]:
+    match = _PATTERN_CONTAINER.search(content)
+    if not match:
+        return {}
+    parts = re.findall(r'"([^"]*)"', match.group(1))
+    options = {}
+    for part in parts[1:]:
+        if "=" in part:
+            key, value = part.split("=", 1)
+            options[key] = value
+    return options
+
+
+def _parse_hdr_config(content: str) -> tuple[int, ...]:
+    match = _PATTERN_HDR_CONFIG.search(content)
+    if not match:
+        return ()
+    return tuple(int(x.strip()) for x in match.group(1).split(","))
+
+
+def _parse_audio_tracks(content: str) -> list[AudioTrack]:
+    source_languages = {
+        int(index): lang
+        for index, lang in _PATTERN_SOURCE_LANG.findall(content)
+    }
+    codecs = {
+        int(index): codec
+        for index, codec in _PATTERN_AUDIO_CODEC.findall(content)
+    }
+    track_indices = sorted({
+        int(index)
+        for index in _PATTERN_AUDIO_ADD.findall(content)
+    }.union(codecs.keys()))
+
+    tracks = []
+    for idx in track_indices:
+        tracks.append(AudioTrack(
+            index=idx,
+            language=source_languages.get(idx),
+            codec=codecs.get(idx),
+        ))
+    return tracks

parse_avidemux_project-0.1.0/src/parse_avidemux_project.egg-info/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: parse-avidemux-project
+Version: 0.1.0
+Summary: Parser for Avidemux TinyPY project scripts
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ferrous-lux/parse_avidemux_project
+Project-URL: Source, https://github.com/ferrous-lux/parse_avidemux_project
+Project-URL: BugTracker, https://github.com/ferrous-lux/parse_avidemux_project/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# parse-avidemux-project
+
+Standalone Python library for parsing [Avidemux](https://avidemux.sourceforge.net/) TinyPY project scripts into structured data (video path, segments, filters, audio tracks, etc.). No ffmpeg, ccextractor, or Avidemux CLI required.
+
+## Installation
+
+```bash
+pip install parse-avidemux-project
+```
+
+## CLI Usage
+
+```bash
+parse-avidemux-project input.py -o output.json
+```
+
+Omitting `-o` prints the JSON to stdout.
+
+## Python API
+
+```python
+from parse_avidemux_project import (
+    AvidemuxProject,
+    Segment,
+    AudioTrack,
+    parse_project,
+    parse_project_file,
+    us_to_iso_time,
+)
+
+# Parse a file
+project: AvidemuxProject = parse_project_file("project.py")
+
+# Or parse a string
+project = parse_project('''
+    adm = Avidemux()
+    if not adm.loadVideo("/path/to/video.mkv"):
+        raise
+    adm.addSegment(0, 1000000, 5000000)
+    adm.markerA = 0
+    adm.markerB = 6000000
+''')
+
+print(project.video_file)       # /path/to/video.mkv
+print(project.segments)         # [Segment(start=1000000, duration=5000000)]
+print(project.segments[0].end)  # 6000000 (computed property)
+
+# Convert to dict for JSON serialization
+print(project.to_dict())
+
+# Microsecond to ISO time conversion
+print(us_to_iso_time(3661000000))  # 01:01:01.000
+```
+
+### Data model
+
+| Attribute | Type | Description |
+|---|---|---|
+| `video_file` | `str \| None` | Path to the source video |
+| `segments` | `list[Segment]` | List of cut segments (each has `start`, `duration`, and `end` property) |
+| `marker_a`, `marker_b` | `int \| None` | A/B markers in microseconds |
+| `video_codec` | `str \| None` | Output video codec |
+| `container` | `str \| None` | Output container format |
+| `container_options` | `dict[str, str]` | Container options |
+| `audio_tracks` | `list[AudioTrack]` | Audio track configs (each has `index`, `language`, `codec`) |
+| `hdr_config` | `tuple[int, ...]` | HDR parameters |
+
+## License
+
+MIT

parse_avidemux_project-0.1.0/src/parse_avidemux_project.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/parse_avidemux_project/__init__.py
+src/parse_avidemux_project/cli.py
+src/parse_avidemux_project/models.py
+src/parse_avidemux_project/parser.py
+src/parse_avidemux_project.egg-info/PKG-INFO
+src/parse_avidemux_project.egg-info/SOURCES.txt
+src/parse_avidemux_project.egg-info/dependency_links.txt
+src/parse_avidemux_project.egg-info/entry_points.txt
+src/parse_avidemux_project.egg-info/requires.txt
+src/parse_avidemux_project.egg-info/top_level.txt
+tests/test_parser.py

parse_avidemux_project-0.1.0/src/parse_avidemux_project.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

parse_avidemux_project-0.1.0/src/parse_avidemux_project.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+parse-avidemux-project = parse_avidemux_project.cli:main

parse_avidemux_project-0.1.0/src/parse_avidemux_project.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=8

parse_avidemux_project-0.1.0/src/parse_avidemux_project.egg-info/top_level.txt

@@ -0,0 +1 @@
+parse_avidemux_project

parse_avidemux_project-0.1.0/tests/test_parser.py

@@ -0,0 +1,231 @@
+from pathlib import Path
+
+import pytest
+
+from parse_avidemux_project import (
+    AudioTrack,
+    AvidemuxProject,
+    Segment,
+    parse_project,
+    parse_project_file,
+    us_to_iso_time,
+)
+
+FIXTURES = Path(__file__).parent / "fixtures"
+
+
+def test_parse_project_file_adm1():
+    project = parse_project_file(str(FIXTURES / "test-adm.py"))
+    assert project.video_file == "/tmp/test.mkv"
+    assert len(project.segments) == 5
+    assert project.marker_a == 0
+    assert project.marker_b == 2597779000
+    assert project.video_codec == "Copy"
+    assert project.container == "MKV"
+    assert len(project.container_options) == 8
+    assert project.container_options["forceAspectRatio"] == "False"
+    assert project.container_options["displayWidth"] == "1280"
+    assert project.container_options["colMatrixCoeff"] == "2"
+    assert len(project.audio_tracks) == 2
+    assert project.audio_tracks[0] == AudioTrack(index=0, language="eng", codec="copy")
+    assert project.audio_tracks[1] == AudioTrack(index=1, language="spa", codec="copy")
+    assert project.hdr_config == (1, 1, 1, 1, 0)
+
+
+def test_parse_project_file_adm2():
+    project = parse_project_file(str(FIXTURES / "test2-adm.py"))
+    assert project.video_file == "/tmp/test-video2.mkv"
+    assert len(project.segments) == 10
+    assert project.marker_a == 0
+    assert project.marker_b == 4905816000
+    assert project.video_codec == "Copy"
+    assert project.container == "MKV"
+    assert len(project.container_options) == 8
+    assert len(project.audio_tracks) == 2
+    assert project.audio_tracks[0] == AudioTrack(index=0, language="eng", codec="copy")
+    assert project.audio_tracks[1] == AudioTrack(index=1, language="spa", codec="copy")
+    assert project.hdr_config == (1, 1, 1, 1, 0)
+
+
+def test_segment_end():
+    seg = Segment(start=1000000, duration=5000000)
+    assert seg.end == 6000000
+    assert seg.start == 1000000
+    assert seg.duration == 5000000
+
+
+def test_segment_zero_duration():
+    seg = Segment(start=5000, duration=0)
+    assert seg.end == 5000
+
+
+def test_parse_project_invalid_content():
+    with pytest.raises(ValueError, match="No Avidemux project data found"):
+        parse_project("not an avidemux file")
+
+
+def test_parse_project_empty_string():
+    with pytest.raises(ValueError, match="No Avidemux project data found"):
+        parse_project("")
+
+
+def test_parse_project_just_segments():
+    project = parse_project("adm.addSegment(0, 1000, 2000)")
+    assert project.video_file is None
+    assert len(project.segments) == 1
+    assert project.segments[0] == Segment(start=1000, duration=2000)
+
+
+def test_parse_project_just_video():
+    content = (
+        "adm = Avidemux()\n"
+        'if not adm.loadVideo("/path/to/video.mkv"):\n'
+        "    raise\n"
+    )
+    project = parse_project(content)
+    assert project.video_file == "/path/to/video.mkv"
+    assert len(project.segments) == 0
+
+
+def test_parse_project_no_segments():
+    content = (
+        "adm = Avidemux()\n"
+        'if not adm.loadVideo("/path/to/video.mkv"):\n'
+        "    raise\n"
+        "adm.markerA = 0\n"
+    )
+    project = parse_project(content)
+    assert project.video_file == "/path/to/video.mkv"
+    assert len(project.segments) == 0
+    assert project.marker_a == 0
+
+
+def test_parse_project_no_video():
+    project = parse_project("adm.addSegment(0, 1000, 2000)\nadm.addSegment(0, 5000, 3000)")
+    assert project.video_file is None
+    assert len(project.segments) == 2
+
+
+def test_parse_project_no_hdr():
+    content = (
+        "adm = Avidemux()\n"
+        'if not adm.loadVideo("/path/to/video.mkv"):\n'
+        "    raise\n"
+    )
+    project = parse_project(content)
+    assert project.hdr_config == ()
+
+
+def test_parse_project_no_container():
+    content = (
+        "adm = Avidemux()\n"
+        'if not adm.loadVideo("/path/to/video.mkv"):\n'
+        "    raise\n"
+    )
+    project = parse_project(content)
+    assert project.container is None
+    assert project.container_options == {}
+
+
+def test_parse_project_no_audio():
+    content = (
+        "adm = Avidemux()\n"
+        'if not adm.loadVideo("/path/to/video.mkv"):\n'
+        "    raise\n"
+    )
+    project = parse_project(content)
+    assert project.audio_tracks == []
+
+
+def test_parse_project_no_codec():
+    content = (
+        "adm = Avidemux()\n"
+        'if not adm.loadVideo("/path/to/video.mkv"):\n'
+        "    raise\n"
+    )
+    project = parse_project(content)
+    assert project.video_codec is None
+
+
+def test_parse_project_no_markers():
+    content = (
+        "adm = Avidemux()\n"
+        'if not adm.loadVideo("/path/to/video.mkv"):\n'
+        "    raise\n"
+    )
+    project = parse_project(content)
+    assert project.marker_a is None
+    assert project.marker_b is None
+
+
+def test_us_to_iso_time_zero():
+    assert us_to_iso_time(0) == "00:00:00.000"
+
+
+def test_us_to_iso_time_one_second():
+    assert us_to_iso_time(1_000_000) == "00:00:01.000"
+
+
+def test_us_to_iso_time_one_minute():
+    assert us_to_iso_time(60_000_000) == "00:01:00.000"
+
+
+def test_us_to_iso_time_one_hour():
+    assert us_to_iso_time(3_600_000_000) == "01:00:00.000"
+
+
+def test_us_to_iso_time_milliseconds():
+    assert us_to_iso_time(1_500_000) == "00:00:01.500"
+
+
+def test_us_to_iso_time_complex():
+    assert us_to_iso_time(9_999_999_999) == "02:46:39.999"
+
+
+def test_to_dict_shape():
+    project = AvidemuxProject(
+        video_file="/path/to/video.mkv",
+        segments=[Segment(start=1000, duration=2000)],
+        marker_a=0,
+        marker_b=5000,
+        video_codec="Copy",
+        container="MKV",
+        container_options={"forceAspectRatio": "False"},
+        audio_tracks=[AudioTrack(index=0, language="eng", codec="copy")],
+        hdr_config=(1, 1, 1, 1, 0),
+    )
+    d = project.to_dict()
+    assert d["video_file"] == "/path/to/video.mkv"
+    assert d["segments"] == [{"start": 1000, "duration": 2000, "end": 3000}]
+    assert d["marker_a"] == 0
+    assert d["marker_b"] == 5000
+    assert d["video_codec"] == "Copy"
+    assert d["container"] == "MKV"
+    assert d["container_options"] == {"forceAspectRatio": "False"}
+    assert d["audio_tracks"] == [{"index": 0, "language": "eng", "codec": "copy"}]
+    assert d["hdr_config"] == [1, 1, 1, 1, 0]
+
+
+def test_to_dict_empty_project():
+    d = AvidemuxProject().to_dict()
+    assert d["video_file"] is None
+    assert d["segments"] == []
+    assert d["marker_a"] is None
+    assert d["marker_b"] is None
+    assert d["video_codec"] is None
+    assert d["container"] is None
+    assert d["container_options"] == {}
+    assert d["audio_tracks"] == []
+    assert d["hdr_config"] == []
+
+
+def test_audio_track_equality():
+    t1 = AudioTrack(index=0, language="eng", codec="copy")
+    t2 = AudioTrack(index=0, language="eng", codec="copy")
+    assert t1 == t2
+
+
+def test_segment_equality():
+    s1 = Segment(start=1000, duration=2000)
+    s2 = Segment(start=1000, duration=2000)
+    assert s1 == s2