auto-editor 23.20.1__tar.gz → 23.21.1__tar.gz

{auto-editor-23.20.1 → auto-editor-23.21.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 23.20.1
+Version: 23.21.1
 Summary: Auto-Editor: Effort free video editing!
 Home-page: https://auto-editor.com
 Author: WyattBlue

auto-editor-23.21.1/auto_editor/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "23.21.1"
+version = "23w21a"

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor/formats/fcp7.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-import os.path
 import xml.etree.ElementTree as ET
 from fractions import Fraction
+from io import StringIO
 from math import ceil
 from typing import TYPE_CHECKING
 from xml.etree.ElementTree import Element
@@ -34,16 +34,63 @@ DEPTH = "16"
 
 
 def uri_to_path(uri: str) -> str:
-    from urllib.parse import urlparse
-    from urllib.request import url2pathname
-
-    parsed = urlparse(uri)
-    s = os.path.sep
-    host = f"{s}{s}{parsed.netloc}{s}"
-    return os.path.normpath(os.path.join(host, url2pathname(parsed.path)))
+    def de_norm(s: str) -> str:
+        uri_escape = {
+            "3C": "<",
+            "3E": ">",
+            "23": "#",
+            "25": "%",
+            "2B": "+",
+            "7B": "{",
+            "7D": "}",
+            "7C": "|",
+            "5C": "\\",
+            "5E": "^",
+            "7E": "~",
+            "5B": "[",
+            "5D": "]",
+            "60": "`",
+            "3F": "?",
+            "3A": ":",
+            "40": "@",
+            "3D": "=",
+            "2A": "*",
+            "29": ")",
+            "28": "(",
+            "27": "'",
+            "26": "&",
+            "24": "$",
+            "22": '"',
+            "21": "!",
+            "20": " ",
+        }
+        buf = StringIO()
+        i = 0
+        while i < len(s):
+            if s[i] == "%" and len(s) > i + 3:
+                tag = s[i + 1 : i + 3]
+                if tag in uri_escape:
+                    buf.write(uri_escape[tag])
+                    i += 3
+                else:
+                    buf.write(s[i])
+                    i += 1
+            else:
+                buf.write(s[i])
+                i += 1
+        return buf.getvalue()
+
+    if uri.startswith("file://localhost/"):
+        return de_norm(uri[16:])
+    if uri.startswith("file://"):
+        if uri[9] == ":":  # Handle Windows-style paths
+            return de_norm(uri[8:])
+        return de_norm(uri[7:])
+    return uri
 
     # /Users/wyattblue/projects/auto-editor/example.mp4
     # file:///Users/wyattblue/projects/auto-editor/example.mp4
+    # file:///C:/Users/WyattBlue/projects/auto-editor/example.mp4
     # file://localhost/Users/wyattblue/projects/auto-editor/example.mp4
 
 
@@ -307,6 +354,9 @@ def media_def(
     ET.SubElement(rate, "timebase").text = f"{tb}"
     ET.SubElement(rate, "ntsc").text = ntsc
 
+    # DaVinci Resolve needs this tag even though it's blank
+    ET.SubElement(filedef, "duration").text = ""
+
     mediadef = ET.SubElement(filedef, "media")
 
     if len(src.videos) > 0:

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor/formats/shotcut.py

@@ -38,7 +38,7 @@ def shotcut_write_mlt(output: str, tl: v3) -> None:
     tb = tl.tb
     src = tl.v1.source
 
-    profile = ET.SubElement(
+    ET.SubElement(
         mlt,
         "profile",
         attrib={

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor/lang/json.py

@@ -121,7 +121,7 @@ class Lexer:
             self.advance()
 
         if self.char is None:
-            self.error(f'Expected a closing `"`')
+            self.error('Expected a closing `"`')
 
         self.advance()
         return result.getvalue()

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor/lang/palet.py

@@ -134,7 +134,7 @@ class Lexer:
             self.advance()
 
         if self.char is None:
-            self.close_err(f'Expected a closing `"`')
+            self.close_err('Expected a closing `"`')
 
         self.advance()
         return result.getvalue()
@@ -214,7 +214,7 @@ class Lexer:
         if result == "hash":
             self.advance()
             if self.char is None or self.char not in "([{":
-                self.error(f"Expected an opening bracket after #hash")
+                self.error("Expected an opening bracket after #hash")
 
             brac_type = self.char
             self.advance()
@@ -754,7 +754,9 @@ class Syntax:
     def __call__(self, env: Env, node: list) -> Any:
         return self.syn(env, node)
 
-    __str__: Callable[[Syntax], str] = lambda self: "#<syntax>"
+    def __str__(self) -> str:
+        return "#<syntax>"
+
     __repr__ = __str__
 
 

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor/lib/data_structs.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from fractions import Fraction
 from io import StringIO
-from typing import Callable
 
 import numpy as np
 
@@ -14,7 +13,9 @@ class Sym:
         self.val = val
         self.hash = hash(val)
 
-    __str__: Callable[[Sym], str] = lambda self: self.val
+    def __str__(self) -> str:
+        return self.val
+
     __repr__ = __str__
 
     def __hash__(self) -> int:
@@ -34,7 +35,8 @@ class Char:
             assert type(val) is str and len(val) == 1
             self.val = val
 
-    __str__: Callable[[Char], str] = lambda self: self.val
+    def __str__(self) -> str:
+        return self.val
 
     def __repr__(self) -> str:
         names = {" ": "space", "\n": "newline", "\t": "tab"}

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor/render/audio.py

@@ -182,10 +182,10 @@ def make_new_audio(
     if not tl.a or not tl.a[0]:
         log.error("Trying to render empty audio timeline")
 
-    for l, layer in enumerate(tl.a):
+    for i, layer in enumerate(tl.a):
         bar.start(len(layer), "Creating new audio")
 
-        path = Path(temp, f"new{l}.wav")
+        path = Path(temp, f"new{i}.wav")
         output.append(f"{path}")
         arr: AudioData | None = None
 

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor/subcommands/test.py

@@ -610,7 +610,7 @@ def main(sys_args: list[str] | None = None):
 
     def audio_norm_ebu():
         return run.main(
-            ["example.mp4"], ["--audio-normalize", f"ebu:i=-5,lra=20,gain=5,tp=-1"]
+            ["example.mp4"], ["--audio-normalize", "ebu:i=-5,lra=20,gain=5,tp=-1"]
         )
 
     def palet():

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor/wavfile.py

@@ -16,13 +16,17 @@ Endian = Literal[">", "<"]  # Big Endian, Little Endian
 ByteOrd = Literal["big", "little"]
 
 
+class WavError(Exception):
+    pass
+
+
 def _read_fmt_chunk(
     fid: io.BufferedReader, bytes_order: ByteOrd
 ) -> tuple[int, int, int, int, int]:
     size = int.from_bytes(fid.read(4), bytes_order)
 
     if size < 16:
-        raise ValueError("Binary structure of wave file is not compliant")
+        raise WavError("Binary structure of wave file is not compliant")
 
     format_tag = int.from_bytes(fid.read(2), bytes_order)
     channels = int.from_bytes(fid.read(2), bytes_order)
@@ -47,10 +51,10 @@ def _read_fmt_chunk(
             if raw_guid.endswith(tail):
                 format_tag = int.from_bytes(raw_guid[:4], bytes_order)
         else:
-            raise ValueError("Binary structure of wave file is not compliant")
+            raise WavError("Binary structure of wave file is not compliant")
 
     if format_tag not in {PCM, IEEE_FLOAT}:
-        raise ValueError(
+        raise WavError(
             f"Encountered unknown format tag: {format_tag:#06x}, while reading fmt chunk."
         )
 
@@ -83,7 +87,7 @@ def _read_data_chunk(
     bytes_per_sample = block_align // channels
 
     if bytes_per_sample in (3, 5, 6, 7):
-        raise ValueError(f"Unsupported bytes per sample: {bytes_per_sample}")
+        raise WavError(f"Unsupported bytes per sample: {bytes_per_sample}")
 
     if format_tag == PCM:
         if 1 <= bit_depth <= 8:
@@ -91,21 +95,20 @@ def _read_data_chunk(
         elif bit_depth <= 64:
             dtype = f"{en}i{bytes_per_sample}"
         else:
-            raise ValueError(
+            raise WavError(
                 f"Unsupported bit depth: the WAV file has {bit_depth}-bit integer data."
             )
     elif format_tag == IEEE_FLOAT:
         if bit_depth in (32, 64):
             dtype = f"{en}f{bytes_per_sample}"
         else:
-            raise ValueError(
+            raise WavError(
                 f"Unsupported bit depth: the WAV file has {bit_depth}-bit floating-point data."
             )
     else:
-        raise ValueError(
+        raise WavError(
             f"Unknown wave file format: {format_tag:#06x}. Supported formats: PCM, IEEE_FLOAT"
         )
-
     if size % 2 == 0:
         n_samples = size // block_align
     else:
@@ -121,10 +124,20 @@ def _read_data_chunk(
 
 
 def _skip_unknown_chunk(fid: io.BufferedReader, en: Endian) -> None:
-    if data := fid.read(4):
+    data = fid.read(4)
+
+    if len(data) == 4:
         size = struct.unpack(f"{en}I", data)[0]
+        if size == 0:
+            raise WavError("Unknown chunk size is 0")
         fid.seek(size, 1)
         _handle_pad_byte(fid, size)
+    elif len(data) == 0:
+        pass  # It's okay, we've hit EOF
+    else:
+        raise WavError(
+            f"Unknown chunk size has wrong length, expected 4, got {len(data)}"
+        )
 
 
 def _read_rf64_chunk(fid: io.BufferedReader) -> tuple[int, int, Endian]:
@@ -133,7 +146,7 @@ def _read_rf64_chunk(fid: io.BufferedReader) -> tuple[int, int, Endian]:
 
     heading = fid.read(12)
     if heading != b"\xff\xff\xff\xffWAVEds64":
-        raise ValueError(f"Invalid heading for rf64 chunk: {heading!r}")
+        raise WavError(f"Invalid heading for rf64 chunk: {heading!r}")
 
     chunk_size = fid.read(4)
 
@@ -163,7 +176,7 @@ def _read_riff_chunk(sig: bytes, fid: io.BufferedReader) -> tuple[None, int, End
 
     form = fid.read(4)
     if form != b"WAVE":
-        raise ValueError(f"Not a WAV file. RIFF form type is {form!r}.")
+        raise WavError(f"Not a WAV file. RIFF form type is {form!r}.")
 
     return None, file_size, en
 
@@ -176,78 +189,64 @@ def _handle_pad_byte(fid: io.BufferedReader, size: int) -> None:
 def read(filename: str) -> tuple[int, AudioData]:
     fid = open(filename, "rb")
 
-    try:
-        file_sig = fid.read(4)
-        if file_sig in (b"RIFF", b"RIFX"):
-            data_size, file_size, en = _read_riff_chunk(file_sig, fid)
-        elif file_sig == b"RF64":
-            data_size, file_size, en = _read_rf64_chunk(fid)
-        else:
-            raise ValueError(f"File format {file_sig!r} not supported.")
-
-        fmt_chunk_received = False
-        data_chunk_received = False
-        while fid.tell() < file_size:
-            chunk_id = fid.read(4)
-
-            if not chunk_id:
-                if data_chunk_received:
-                    break  # EOF but data successfully read
-                raise ValueError("Unexpected end of file.")
-
-            elif len(chunk_id) < 4 and not (fmt_chunk_received and data_chunk_received):
-                raise ValueError(f"Incomplete chunk ID: {chunk_id!r}")
-
-            if chunk_id == b"fmt ":
-                fmt_chunk_received = True
-                bytes_order: ByteOrd = "big" if en == ">" else "little"
-                format_tag, channels, sr, block_align, bit_depth = _read_fmt_chunk(
-                    fid, bytes_order
-                )
-            elif chunk_id == b"data":
-                data_chunk_received = True
-                if not fmt_chunk_received:
-                    raise ValueError("No fmt chunk before data")
-
-                data = _read_data_chunk(
-                    fid,
-                    format_tag,
-                    channels,
-                    bit_depth,
-                    en,
-                    block_align,
-                    data_size,
-                )
-            else:
-                _skip_unknown_chunk(fid, en)
+    file_sig = fid.read(4)
+    if file_sig in (b"RIFF", b"RIFX"):
+        data_size, file_size, en = _read_riff_chunk(file_sig, fid)
+    elif file_sig == b"RF64":
+        data_size, file_size, en = _read_rf64_chunk(fid)
+    else:
+        raise WavError(f"File format {file_sig!r} not supported.")
 
-    finally:
-        fid.seek(0)
+    bytes_order: ByteOrd = "big" if en == ">" else "little"
+    fmt_chunk_received = False
 
-    return sr, data
+    while fid.tell() < file_size:
+        chunk_id = fid.read(4)
 
+        if not chunk_id:
+            raise WavError("Unexpected end of file.")
+        if len(chunk_id) < 4:
+            raise WavError(f"Incomplete chunk ID: {chunk_id!r}")
 
-def write(fid: io.BufferedWriter, sr: int, arr: AudioData) -> None:
-    # Write RIFF WAV Header
-    fid.write(b"RIFF\x00\x00\x00\x00WAVE")
+        if chunk_id == b"fmt ":
+            fmt_chunk_received = True
+            format_tag, channels, sr, block_align, bit_depth = _read_fmt_chunk(
+                fid, bytes_order
+            )
+        elif chunk_id == b"data":
+            if not fmt_chunk_received:
+                raise WavError("No fmt chunk before data")
+
+            data = _read_data_chunk(
+                fid,
+                format_tag,
+                channels,
+                bit_depth,
+                en,
+                block_align,
+                data_size,
+            )
 
-    # Write RF64 WAV Header
-    # fid.write(b"RF64\xff\xff\xff\xffWAVEds64")
+            fid.seek(0)
+            return sr, data
 
-    # #  - chunk_size
-    # fid.write(b'\x1c\x00\x00\x00')  # Value based on bit-depth + '# of samples'
+        elif chunk_id == b"\x00\x00\x00\x00":
+            raise WavError("Invalid chunk ID")
+        else:
+            _skip_unknown_chunk(fid, en)
 
-    # # - bw_size, Declaring Little Endian
-    # fid.write(b'j@|\x00')
-    # fid.write(b'\x00\x00\x00\x00')
+    raise WavError("Found no data")
 
-    # Write 'fmt' Header
-    dkind = arr.dtype.kind
 
+def write(fid: io.BufferedWriter, sr: int, arr: AudioData) -> None:
+    # Write RIFF WAV Header
+    fid.write(b"RIFF\x00\x00\x00\x00WAVE")
     header_data = b"fmt "
 
+    dkind = arr.dtype.kind
     format_tag = IEEE_FLOAT if dkind == "f" else PCM
     channels = 1 if arr.ndim == 1 else arr.shape[1]
+
     bit_depth = arr.dtype.itemsize * 8
     bit_rate = sr * (bit_depth // 8) * channels
     block_align = channels * (bit_depth // 8)
@@ -256,20 +255,11 @@ def write(fid: io.BufferedWriter, sr: int, arr: AudioData) -> None:
         "<HHIIHH", format_tag, channels, sr, bit_rate, block_align, bit_depth
     )
 
-    if not (dkind == "i" or dkind == "u"):
-        # add cbSize field for non-PCM files
-        fmt_chunk_data += b"\x00\x00"
-
     header_data += struct.pack("<I", len(fmt_chunk_data))
     header_data += fmt_chunk_data
 
-    # fact chunk (non-PCM files)
-    if not (dkind == "i" or dkind == "u"):
-        header_data += b"fact"
-        header_data += struct.pack("<II", 4, arr.shape[0])
-
     if len(header_data) + arr.nbytes > 0xFFFFFFFF:
-        raise ValueError("Data exceeds wave file size limit")
+        raise WavError("Data exceeds wave file size limit")
 
     fid.write(header_data)
 

{auto-editor-23.20.1 → auto-editor-23.21.1}/auto_editor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: auto-editor
-Version: 23.20.1
+Version: 23.21.1
 Summary: Auto-Editor: Effort free video editing!
 Home-page: https://auto-editor.com
 Author: WyattBlue

auto-editor-23.20.1/auto_editor/__init__.py

@@ -1,2 +0,0 @@
-__version__ = "23.20.1"
-version = "23w20a"