bdmvkit 0.2.0__py3-none-any.whl

bdmvkit/pgs.py

@@ -0,0 +1,260 @@
+"""Blu-ray subtitles: cues -> a PGS (Presentation Graphics) stream (.sup).
+
+A text cue is a picture of white text with a black outline on a
+transparent HD frame (RGBA, drawn by the caller); indexed() keeps 64
+colours of it: 8 steps from the outline to the fill colour, each at 8
+levels of opacity, so edges stay smooth, and palette() gives them in the
+cue's own fill and outline colours. A picture cue keeps its own colours
+(picture_palette). Palettes are BT.709 YCbCr, as Blu-ray HD pictures are.
+
+A cue becomes a display set at its start (presentation composition, window,
+palette and the run-length coded object) and an empty composition at its
+end, which clears it. The stream begins with an empty composition at time 0
+so that ffmpeg, which starts every input at 0, keeps the cue times.
+"""
+
+import re
+import struct
+
+
+PCS, WDS, PDS, ODS, END = 0x16, 0x17, 0x14, 0x15, 0x80
+EPOCH_START, NORMAL = 0x80, 0x00
+STEPS = 8                       # fill/outline mix steps and opacity levels
+MAX_SEGMENT = 65535
+MIN_GAP = 0.2                   # seconds between two cues the decoder needs (about 5 frames)
+
+# per byte value: the step (0-7) of a lightness or an opacity
+_STEP = bytes(min(STEPS - 1, v * STEPS // 256) for v in range(256))
+_VISIBLE = bytes(1 if a >= 16 else 0 for a in range(256))
+
+
+def _rgb(value):
+    """'#RRGGBB' -> (r, g, b)."""
+    s = value.lstrip("#")
+    return int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16)
+
+
+def ycbcr(rgb):
+    """BT.709, studio range (what HD Blu-ray players expect)."""
+    r, g, b = (c / 255 for c in rgb)
+    y = 0.2126 * r + 0.7152 * g + 0.0722 * b
+    cb, cr = (b - y) / 1.8556, (r - y) / 1.5748
+    return (round(16 + 219 * y), round(128 + 224 * cb), round(128 + 224 * cr))
+
+
+def palette(fill, outline):
+    """Entries (index, Y, Cr, Cb, alpha): 0 transparent, then 1 + 8 * mix +
+    opacity, mix 0 = outline .. 7 = fill."""
+    f, o = _rgb(fill), _rgb(outline)
+    out = [(0, 16, 128, 128, 0)]
+    for m in range(STEPS):
+        t = m / (STEPS - 1)
+        rgb = tuple(round(oc + (fc - oc) * t) for fc, oc in zip(f, o))
+        y, cb, cr = ycbcr(rgb)
+        for a in range(STEPS):
+            alpha = round((a + 1) * 255 / STEPS)
+            out.append((1 + STEPS * m + a, y, cr, cb, alpha))
+    return out
+
+
+def picture_palette(colours):
+    """Entries for a picture's own colours [(r, g, b, a)]: index k for the
+    k-th (0 transparent)."""
+    return [(0, 16, 128, 128, 0)] + [(k, *_ycrcb(c[:3]), c[3])
+                                     for k, c in enumerate(colours, 1)]
+
+
+def _ycrcb(rgb):
+    y, cb, cr = ycbcr(rgb)
+    return y, cr, cb
+
+
+def indexed(rgba, W, H):
+    """RGBA (white text, black outline) -> (index bytes, w, h, x, y) cropped
+    to what is visible, or None for an empty picture. Runs at C speed: the
+    two steps are combined as big integers (no byte overflows into the next)."""
+    alpha = rgba[3::4]
+    vis = alpha.translate(_VISIBLE)
+    first, last = vis.find(1), vis.rfind(1)
+    if first < 0:
+        return None
+    y0, y1 = first // W, last // W
+    x0, x1 = W, -1
+    for yy in range(y0, y1 + 1):
+        row = vis[yy * W:(yy + 1) * W]
+        a, b = row.find(1), row.rfind(1)
+        if a >= 0:
+            x0, x1 = min(x0, a), max(x1, b)
+    w, h = x1 - x0 + 1, y1 - y0 + 1
+    rows_l, rows_a, rows_v = [], [], []
+    red = rgba[0::4]
+    for yy in range(y0, y1 + 1):
+        s = slice(yy * W + x0, yy * W + x1 + 1)
+        v = vis[s]
+        rows_v.append(v)
+        # invisible pixels get step 0 in both, and no +1 below
+        rows_l.append(_mask(red[s].translate(_STEP), v))
+        rows_a.append(_mask(alpha[s].translate(_STEP), v))
+    n = w * h
+    lum = int.from_bytes(b"".join(rows_l), "big")
+    opa = int.from_bytes(b"".join(rows_a), "big")
+    one = int.from_bytes(b"".join(rows_v), "big")
+    idx = (lum * STEPS + opa + one).to_bytes(n, "big")
+    return idx, w, h, x0, y0
+
+
+def _mask(steps, visible):
+    """Steps where visible, 0 elsewhere (multiplying by the 0/1 mask)."""
+    n = len(steps)
+    if not n:
+        return steps
+    s = int.from_bytes(steps, "big")
+    v = int.from_bytes(visible, "big")
+    # visible bytes are 0 or 1; spread each to 0x00 / 0xFF and AND
+    return (s & (v * 0xFF)).to_bytes(n, "big")
+
+
+_RUN = re.compile(rb"(.)\1*", re.S)
+
+
+def rle(idx, w, h):
+    """PGS run-length coding, line by line (colour 0 = transparent)."""
+    out = bytearray()
+    for y in range(h):
+        row = idx[y * w:(y + 1) * w]
+        for m in _RUN.finditer(row):
+            c, n = m.group()[0], m.end() - m.start()
+            while n:
+                k = min(n, 16383)
+                if c == 0:
+                    out += bytes([0, k]) if k < 64 else bytes([0, 0x40 | k >> 8, k & 0xFF])
+                elif k < 3:
+                    out += bytes([c]) * k
+                elif k < 64:
+                    out += bytes([0, 0x80 | k, c])
+                else:
+                    out += bytes([0, 0xC0 | k >> 8, k & 0xFF, c])
+                n -= k
+        out += b"\0\0"
+    return bytes(out)
+
+
+def _segment(kind, pts, data):
+    return b"PG" + struct.pack(">IIBH", pts & 0xFFFFFFFF, 0, kind, len(data)) + data
+
+
+def _pcs(size, number, state, objects):
+    W, H = size
+    data = struct.pack(">HHBHBBBB", W, H, 0x10, number & 0xFFFF, state, 0, 0, len(objects))
+    for x, y in objects:
+        data += struct.pack(">HBBHH", 0, 0, 0, x, y)
+    return data
+
+
+def display_set(pts, size, number, pic, entries):
+    """Show `pic` (index bytes, w, h, x, y) from pts (90 kHz)."""
+    idx, w, h, x, y = pic
+    out = _segment(PCS, pts, _pcs(size, number, EPOCH_START, [(x, y)]))
+    out += _segment(WDS, pts, struct.pack(">BBHHHH", 1, 0, x, y, w, h))
+    out += _segment(PDS, pts, bytes([0, 0]) + b"".join(bytes(e) for e in entries))
+    coded = rle(idx, w, h)
+    data = (len(coded) + 4).to_bytes(3, "big") + struct.pack(">HH", w, h) + coded
+    first = MAX_SEGMENT - 4
+    chunks = [data[:first]] + [data[i:i + MAX_SEGMENT - 4]
+                               for i in range(first, len(data), MAX_SEGMENT - 4)]
+    for k, chunk in enumerate(chunks):
+        flags = (0x80 if k == 0 else 0) | (0x40 if k == len(chunks) - 1 else 0)
+        out += _segment(ODS, pts, struct.pack(">HBB", 0, 0, flags) + chunk)
+    return out + _segment(END, pts, b"")
+
+
+def clear_set(pts, size, number, window):
+    out = _segment(PCS, pts, _pcs(size, number, NORMAL if window else EPOCH_START, []))
+    if window:
+        x, y, w, h = window
+        out += _segment(WDS, pts, struct.pack(">BBHHHH", 1, 0, x, y, w, h))
+    else:
+        out += _segment(WDS, pts, b"\0")             # no windows
+    return out + _segment(END, pts, b"")
+
+
+def timeline(cues):
+    """(start, end) per cue, each ending MIN_GAP before the next one starts so
+    the player has time to decode it; cues left with no time are dropped."""
+    out = []
+    for i, c in enumerate(cues):
+        end = c.end
+        if i + 1 < len(cues):
+            end = min(end, round(cues[i + 1].start - MIN_GAP, 6))
+        out.append((c.start, end) if end > c.start else None)
+    return out
+
+
+def write_sup(path, pictures, size):
+    """pictures: [(start s, end s, pic or None, palette entries)]."""
+    data = clear_set(0, size, 0, None)
+    n = 1
+    for start, end, pic, entries in pictures:
+        if pic is None:
+            continue
+        a, b = round(start * 90000), round(end * 90000)
+        data += display_set(a, size, n, pic, entries)
+        data += clear_set(b, size, n + 1, (pic[3], pic[4], pic[1], pic[2]))
+        n += 2
+    with open(path, "wb") as f:
+        f.write(data)
+    return path
+
+
+def decode(data):
+    """Read a .sup back: [(pts, [(x, y, w, h, index bytes)], palette)] per
+    composition. For tests and checks."""
+    out, pos, pal, objs, wins, comp, buf = [], 0, {}, [], {}, None, b""
+    while pos < len(data):
+        assert data[pos:pos + 2] == b"PG", "segment magic"
+        pts, _, kind, size = struct.unpack(">IIBH", data[pos + 2:pos + 13])
+        body = data[pos + 13:pos + 13 + size]
+        pos += 13 + size
+        if kind == PCS:
+            n = body[10]
+            comp = (pts, [struct.unpack(">HBBHH", body[11 + 8 * i:19 + 8 * i])[3:]
+                          for i in range(n)])
+            objs = []
+        elif kind == PDS:
+            pal = {body[i]: tuple(body[i + 1:i + 5]) for i in range(2, len(body), 5)}
+        elif kind == ODS:
+            flags = body[3]
+            buf = (body[4:] if flags & 0x80 else buf + body[4:])
+            if flags & 0x40:
+                w, h = struct.unpack(">HH", buf[3:7])
+                objs.append((w, h, unrle(buf[7:], w, h)))
+        elif kind == END:
+            pics = [(x, y, w, h, px) for (x, y), (w, h, px) in zip(comp[1], objs)]
+            out.append((comp[0], pics, dict(pal)))
+    return out
+
+
+def unrle(data, w, h):
+    out, i, row = bytearray(), 0, 0
+    while i < len(data) and row < h:
+        b = data[i]
+        i += 1
+        if b:
+            out.append(b)
+            continue
+        f = data[i]
+        i += 1
+        if f == 0:
+            row += 1
+            continue
+        n = f & 0x3F
+        if f & 0x40:
+            n = n << 8 | data[i]
+            i += 1
+        c = 0
+        if f & 0x80:
+            c = data[i]
+            i += 1
+        out += bytes([c]) * n
+    assert len(out) == w * h, (len(out), w * h)
+    return bytes(out)

bdmvkit/playlist.py

@@ -0,0 +1,62 @@
+"""Playlists (.mpls): play items with their streams, and chapter marks."""
+
+from .formats import (AUDIO_PID, CODING_H264, CODING_IG, CODING_PG, IG_PID, PG_PID, VERSION,
+                      VIDEO_PID)
+from .hdmv import _u8, _u16, _u32
+
+
+def _video_attr(video_format, frame_rate):
+    return bytes([CODING_H264, video_format << 4 | frame_rate, 0, 0, 0])
+
+
+def _audio_attr(track):
+    coding, channels, lang = track
+    fmt = 6 if channels > 2 else 3
+    return bytes([coding, fmt << 4 | 1]) + lang.encode("ascii")
+
+
+def _pg_attr(lang, coding=CODING_PG):
+    return bytes([coding]) + lang.encode("ascii") + b"\0"
+
+
+def mpls(items, marks, uo=0):
+    """A playlist. items: [(clip name, in, out, video_format, frame_rate,
+    audio, pg, ig, still[, uo])] played one after the other, times in 45 kHz
+    on each clip's time line, audio [(coding, channels, lang3)], pg [lang3]
+    (subtitles), ig: the clip carries menu buttons, still: 2 holds the
+    last picture (a still menu), (1, s) holds it for s seconds, uo: the
+    item's UO mask; marks: chapter marks as (item index, time); uo: the
+    whole playlist's UO mask (the remote keys it does not allow)."""
+    app = _u32(14) + bytes([0, 1]) + _u16(0) + uo.to_bytes(8, "big") + _u16(0)
+    body = b""
+    for it in items:
+        clip, in_time, out_time, video_format, frame_rate, audio, pg, ig, still = it[:9]
+        item_uo = it[9] if len(it) > 9 else 0
+        stn = _u16(0) + bytes([1, len(audio), len(pg), int(ig), 0, 0, 0, 0]) + bytes(4)
+        entry = _u8(1) + _u16(VIDEO_PID) + bytes(6)
+        stn += _u8(len(entry)) + entry + _u8(5) + _video_attr(video_format, frame_rate)
+        for k, tr in enumerate(audio):
+            entry = _u8(1) + _u16(AUDIO_PID + k) + bytes(6)
+            stn += _u8(len(entry)) + entry + _u8(5) + _audio_attr(tr)
+        for k, lang in enumerate(pg):
+            entry = _u8(1) + _u16(PG_PID + k) + bytes(6)
+            stn += _u8(len(entry)) + entry + _u8(5) + _pg_attr(lang)
+        if ig:
+            entry = _u8(1) + _u16(IG_PID) + bytes(6)
+            stn += _u8(len(entry)) + entry + _u8(5) + _pg_attr("und", CODING_IG)
+        still_mode, still_time = still if isinstance(still, tuple) else (still, 0)
+        # connection_condition 1: the clips are not seamless; STC id 0
+        item = clip.encode("ascii") + b"M2TS" + _u16(1) + _u8(0) + _u32(in_time) + \
+            _u32(out_time) + item_uo.to_bytes(8, "big") + _u8(0) + _u8(still_mode) + _u16(still_time) + \
+            _u16(len(stn)) + stn
+        body += _u16(len(item)) + item
+    playlist = _u16(0) + _u16(len(items)) + _u16(0) + body
+    playlist = _u32(len(playlist)) + playlist
+    mark = _u16(len(marks))
+    for ref, t in marks:
+        mark += _u8(0) + _u8(1) + _u16(ref) + _u32(t) + _u16(0xFFFF) + _u32(0)
+    mark = _u32(len(mark)) + mark
+    list_pos = 40 + len(app)
+    mark_pos = list_pos + len(playlist)
+    return b"MPLS" + VERSION + _u32(list_pos) + _u32(mark_pos) + _u32(0) + bytes(20) + app + \
+        playlist + mark

bdmvkit-0.2.0.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: bdmvkit
+Version: 0.2.0
+Summary: Blu-ray (BDMV) authoring in pure Python: playlists, clip information, HDMV navigation, PGS subtitles
+Author: kajisho5
+License-Expression: LGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/kajisho5/bdmvkit
+Keywords: blu-ray,bdmv,mpls,clpi,hdmv,pgs,authoring
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: COPYING
+License-File: COPYING.LESSER
+Dynamic: license-file
+
+<p><img src="docs/images/logo/lockup-dark.svg" alt="bdmvkit" height="56"></p>
+
+# bdmvkit
+
+**Blu-ray (BDMV) authoring in pure Python.** bdmvkit writes the files a
+Blu-ray player navigates by:
+
+* playlists with chapter marks (`.mpls`);
+* clip information with the entry-point map players seek with (`.clpi`);
+* `index.bdmv` and `MovieObject.bdmv` with HDMV navigation commands;
+* menus: Interactive Graphics streams with buttons, the arrow keys between
+  them and the commands they run;
+* PGS subtitle streams (`.sup`).
+
+It also encodes the clips with ffmpeg and x264, using the Blu-ray settings.
+There are no dependencies beyond the standard library, and ffmpeg is needed
+only to encode.
+
+日本語の説明は [README.ja.md](README.ja.md) にあります。
+
+**Status: 0.2.** Titles with chapters, sound and subtitle tracks, and menus
+whose buttons start titles, chapters and other menus. Pop-up menus (over a
+playing title) and menus with motion or music come next; they already work
+in [oncemore](https://github.com/kajisho5/oncemore), where this code comes
+from.
+
+## Why
+
+Open-source Blu-ray tools mux streams into a BDMV folder (tsMuxer, for one),
+but they stop short of the navigation layer: menus, movie objects, playlists
+and commands. bdmvkit writes that layer itself, and is tested by playing
+every disc back with libbluray.
+
+## Install
+
+```sh
+pip install bdmvkit
+```
+
+A release is made by the version: when the version in `pyproject.toml`
+(and `bdmvkit/__init__.py`) reaches `main` without a tag of its own,
+`.github/workflows/release.yml` runs the tests, builds the package, makes
+the GitHub release with its tag and publishes to PyPI (trusted publishing,
+environment `pypi`). Merging the version bump is all it takes.
+
+## Use
+
+```python
+from bdmvkit import Disc
+from bdmvkit.encode import encode_clip
+
+encode_clip("feature.mov", "feature.m2ts", chapters=[0, 300, 600])   # key frames at the chapters
+encode_clip("extras.mp4", "extras.m2ts", fps=(25, 1))
+
+disc = Disc()
+disc.add_title("feature.m2ts", chapters=[0, 300, 600], audio=[("ac3", 2, "en")])
+disc.add_title("extras.m2ts", fps=(25, 1))
+disc.write("out")                       # out/BDMV/...
+```
+
+A menu is a picture and its buttons. Each button is a picture of how it
+looks when selected (and, if given, when activated and before it is
+selected), placed on the 1920 x 1080 menu, and a link:
+
+```python
+from bdmvkit import Disc, MenuButton
+
+disc = Disc()
+disc.add_title("feature.m2ts", chapters=[0, 300, 600], end="menu:main")
+disc.add_menu("main", "menu.png", [
+    MenuButton("play", 160, 700, "play-lit.png", "play-on.png", action="title:1"),
+    MenuButton("scene2", 160, 800, "scene2-lit.png", action="chapter:1:2"),
+])
+disc.write("out")
+```
+
+Links are `title:<n>`, `chapter:<n>:<c>` and `menu:<id>`; a title's `end`
+takes the same. The arrow keys go to the nearest button that way unless a
+button's `nav` says (`{"down": "scene2"}`). `bdmvkit.igs` makes the button
+stream on its own, for other tools.
+
+```sh
+bdmvkit encode feature.mov feature.m2ts --chapters 0,300,600
+bdmvkit build disc.json out
+```
+
+`disc.json` looks like this:
+
+```json
+{"titles": [{"clip": "feature.m2ts", "fps": "24000/1001", "chapters": [0, 300, 600],
+             "audio": [["ac3", 2, "en"]], "subtitles": ["ja"], "end": "menu:main"}],
+ "menus": [{"id": "main", "background": "menu.png",
+            "buttons": [{"id": "play", "x": 160, "y": 700, "selected": "play-lit.png",
+                         "action": "title:1"}]}],
+ "play_all": true}
+```
+
+How the disc is laid out:
+
+* Frame rates are 23.976 (1080p), 25 and 29.97. The last two are coded as
+  progressive frames in a 1080i stream, as the format asks.
+* Sound is AC-3, LPCM or DTS.
+* Subtitles are PGS streams muxed into the clip. `pgs.write_sup` makes them
+  from pictures, and `encode_clip(..., sups=[...])` muxes them in.
+* First play and the Top Menu key open the first menu, or start title 1
+  when there is none.
+* A menu is an interactive title after the titles: its picture held as a
+  still, with its buttons as an Interactive Graphics stream in its clip.
+  The menus are encoded when the disc is written (ffmpeg).
+
+To make a disc image of the folder, use
+[udfkit](https://github.com/kajisho5/udfkit) (UDF 2.50):
+`udfkit bluray out disc.iso --label MY_DISC`.
+
+## Tests
+
+```sh
+python -m unittest discover -s tests -t .
+```
+
+The tests encode real clips, write a disc, and read it back with
+**libbluray**, the library VLC, mpv and Kodi play Blu-ray with. They check:
+
+* the titles and their lengths;
+* the chapter positions;
+* the video, audio and subtitle streams and their languages;
+* that running the disc from first play reaches the titles and chapters in
+  order;
+* that a menu's buttons, chosen and pressed with the remote's keys, start
+  the titles, chapters and menus they link to.
+
+The files' fixed bytes are checked as well.
+
+## Support
+
+bdmvkit is free and stays free. If it saves you time, you can support its
+development through [GitHub Sponsors](https://github.com/sponsors/kajisho5)
+(the **Sponsor** button at the top of this repository). Bug reports help just
+as much: [Issues](https://github.com/kajisho5/bdmvkit/issues).
+
+The logo, colours and writing rules: [docs/DESIGN.md](docs/DESIGN.md).
+
+## License
+
+GNU Lesser General Public License, version 3 or later. See
+[COPYING.LESSER](COPYING.LESSER) and [COPYING](COPYING). You may use
+bdmvkit in programs under any license. Changes to bdmvkit itself stay under
+the LGPL.

bdmvkit-0.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+bdmvkit/__init__.py,sha256=dUjhMn39PM5g-7DxWKHCDVtLpSltg8KM7K1Cg-lqKHA,691
+bdmvkit/__main__.py,sha256=50a2lAnbH7WUOlR5HzAinfHuZjM5BOHDrZJoGOU1wSk,3767
+bdmvkit/clip.py,sha256=nZsAiIpUKZQbXXsgwSroGVu79dR3oWnr6VXo5JDTbL0,3492
+bdmvkit/disc.py,sha256=A7uEfGO4ICpKJFCtWYHIBNIYyfabNh3JUjUTTGUMXUg,12655
+bdmvkit/encode.py,sha256=KaGbBDIrchLvRi3y1SbtgTqpyElZGBbNPTAXEnqyPxo,7523
+bdmvkit/errors.py,sha256=zQ_18MUQJYgJioYO4uHSLWZmtRwqIPG_DyUTyWmMZDw,214
+bdmvkit/formats.py,sha256=Rbytess5vOrLTJb31iE2JPk9DeFnh87Rurzqshaw-MY,1813
+bdmvkit/hdmv.py,sha256=jJd0XAwKuFQGxwNoZfnwgfxy8JRfXs5vywLYkzYR_qc,4549
+bdmvkit/igs.py,sha256=w9z8WbXAT4-O1PqJjQgEuZvNXhBGE0fz4p_PkJ9CqcI,10644
+bdmvkit/m2ts.py,sha256=1PiWorH_DcdRGJ8QaOKQksAjYpZIHXUkddaqnP4OPMA,3011
+bdmvkit/pgs.py,sha256=8GPY57yugIGea47lDwjcHTWRoGNVVRL98RUto6QoLys,9309
+bdmvkit/playlist.py,sha256=emB7TN2vax9KDVZ_liGZ8rRW36FmeQOK34VyIJwjuBM,2991
+bdmvkit-0.2.0.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+bdmvkit-0.2.0.dist-info/licenses/COPYING.LESSER,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+bdmvkit-0.2.0.dist-info/METADATA,sha256=cDbNKbg4aO-XyP9ClLOn_STqcwRZ9mRgGFD1nlmuqXU,6052
+bdmvkit-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+bdmvkit-0.2.0.dist-info/entry_points.txt,sha256=qBL1KfAN9ym2yMsO49KD4LslfR7jiW9SC7vQ2DOEVXc,50
+bdmvkit-0.2.0.dist-info/top_level.txt,sha256=jEuoAleUJJak9d70JUB7ySd2VRD_B5Wk5oHlzjM4hNQ,8
+bdmvkit-0.2.0.dist-info/RECORD,,

bdmvkit-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bdmvkit-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bdmvkit = bdmvkit.__main__:main