Use new Enum syntax

av/codec/codec.pyi

@@ -1,6 +1,6 @@
 from enum import Flag, IntEnum
 from fractions import Fraction
-from typing import ClassVar, Literal, overload
+from typing import ClassVar, Literal, cast, overload
 
 from av.audio.codeccontext import AudioCodecContext
 from av.audio.format import AudioFormat
@@ -12,37 +12,37 @@ from av.video.format import VideoFormat
 from .context import CodecContext
 
 class Properties(Flag):
-    NONE: ClassVar[Properties]
-    INTRA_ONLY: ClassVar[Properties]
-    LOSSY: ClassVar[Properties]
-    LOSSLESS: ClassVar[Properties]
-    REORDER: ClassVar[Properties]
-    BITMAP_SUB: ClassVar[Properties]
-    TEXT_SUB: ClassVar[Properties]
+    NONE = cast(ClassVar[Properties], ...)
+    INTRA_ONLY = cast(ClassVar[Properties], ...)
+    LOSSY = cast(ClassVar[Properties], ...)
+    LOSSLESS = cast(ClassVar[Properties], ...)
+    REORDER = cast(ClassVar[Properties], ...)
+    BITMAP_SUB = cast(ClassVar[Properties], ...)
+    TEXT_SUB = cast(ClassVar[Properties], ...)
 
 class Capabilities(IntEnum):
-    none: int
-    draw_horiz_band: int
-    dr1: int
-    hwaccel: int
-    delay: int
-    small_last_frame: int
-    hwaccel_vdpau: int
-    subframes: int
-    experimental: int
-    channel_conf: int
-    neg_linesizes: int
-    frame_threads: int
-    slice_threads: int
-    param_change: int
-    auto_threads: int
-    variable_frame_size: int
-    avoid_probing: int
-    hardware: int
-    hybrid: int
-    encoder_reordered_opaque: int
-    encoder_flush: int
-    encoder_recon_frame: int
+    none = cast(int, ...)
+    draw_horiz_band = cast(int, ...)
+    dr1 = cast(int, ...)
+    hwaccel = cast(int, ...)
+    delay = cast(int, ...)
+    small_last_frame = cast(int, ...)
+    hwaccel_vdpau = cast(int, ...)
+    subframes = cast(int, ...)
+    experimental = cast(int, ...)
+    channel_conf = cast(int, ...)
+    neg_linesizes = cast(int, ...)
+    frame_threads = cast(int, ...)
+    slice_threads = cast(int, ...)
+    param_change = cast(int, ...)
+    auto_threads = cast(int, ...)
+    variable_frame_size = cast(int, ...)
+    avoid_probing = cast(int, ...)
+    hardware = cast(int, ...)
+    hybrid = cast(int, ...)
+    encoder_reordered_opaque = cast(int, ...)
+    encoder_flush = cast(int, ...)
+    encoder_recon_frame = cast(int, ...)
 
 class UnknownCodecError(ValueError): ...
 

av/codec/context.pyi

@@ -1,53 +1,53 @@
 from enum import Flag, IntEnum
 from fractions import Fraction
-from typing import ClassVar, Literal
+from typing import ClassVar, Literal, cast
 
 from av.packet import Packet
 
 from .codec import Codec
 from .hwaccel import HWAccel
 
 class ThreadType(Flag):
-    NONE: ClassVar[ThreadType]
-    FRAME: ClassVar[ThreadType]
-    SLICE: ClassVar[ThreadType]
-    AUTO: ClassVar[ThreadType]
+    NONE = cast(ClassVar[ThreadType], ...)
+    FRAME = cast(ClassVar[ThreadType], ...)
+    SLICE = cast(ClassVar[ThreadType], ...)
+    AUTO = cast(ClassVar[ThreadType], ...)
     def __get__(self, i: object | None, owner: type | None = None) -> ThreadType: ...
     def __set__(self, instance: object, value: int | str | ThreadType) -> None: ...
 
 class Flags(IntEnum):
-    unaligned: int
-    qscale: int
-    four_mv: int
-    output_corrupt: int
-    qpel: int
-    drop_changed: int
-    recon_frame: int
-    copy_opaque: int
-    frame_duration: int
-    pass1: int
-    pass2: int
-    loop_filter: int
-    gray: int
-    psnr: int
-    interlaced_dct: int
-    low_delay: int
-    global_header: int
-    bitexact: int
-    ac_pred: int
-    interlaced_me: int
-    closed_gop: int
+    unaligned = cast(int, ...)
+    qscale = cast(int, ...)
+    four_mv = cast(int, ...)
+    output_corrupt = cast(int, ...)
+    qpel = cast(int, ...)
+    drop_changed = cast(int, ...)
+    recon_frame = cast(int, ...)
+    copy_opaque = cast(int, ...)
+    frame_duration = cast(int, ...)
+    pass1 = cast(int, ...)
+    pass2 = cast(int, ...)
+    loop_filter = cast(int, ...)
+    gray = cast(int, ...)
+    psnr = cast(int, ...)
+    interlaced_dct = cast(int, ...)
+    low_delay = cast(int, ...)
+    global_header = cast(int, ...)
+    bitexact = cast(int, ...)
+    ac_pred = cast(int, ...)
+    interlaced_me = cast(int, ...)
+    closed_gop = cast(int, ...)
 
 class Flags2(IntEnum):
-    fast: int
-    no_output: int
-    local_header: int
-    chunks: int
-    ignore_crop: int
-    show_all: int
-    export_mvs: int
-    skip_manual: int
-    ro_flush_noop: int
+    fast = cast(int, ...)
+    no_output = cast(int, ...)
+    local_header = cast(int, ...)
+    chunks = cast(int, ...)
+    ignore_crop = cast(int, ...)
+    show_all = cast(int, ...)
+    export_mvs = cast(int, ...)
+    skip_manual = cast(int, ...)
+    ro_flush_noop = cast(int, ...)
 
 class CodecContext:
     name: str

av/codec/hwaccel.pyi

@@ -1,29 +1,30 @@
 from enum import IntEnum
+from typing import cast
 
 from av.codec.codec import Codec
 from av.video.format import VideoFormat
 
 class HWDeviceType(IntEnum):
-    none: int
-    vdpau: int
-    cuda: int
-    vaapi: int
-    dxva2: int
-    qsv: int
-    videotoolbox: int
-    d3d11va: int
-    drm: int
-    opencl: int
-    mediacodec: int
-    vulkan: int
-    d3d12va: int
+    none = cast(int, ...)
+    vdpau = cast(int, ...)
+    cuda = cast(int, ...)
+    vaapi = cast(int, ...)
+    dxva2 = cast(int, ...)
+    qsv = cast(int, ...)
+    videotoolbox = cast(int, ...)
+    d3d11va = cast(int, ...)
+    drm = cast(int, ...)
+    opencl = cast(int, ...)
+    mediacodec = cast(int, ...)
+    vulkan = cast(int, ...)
+    d3d12va = cast(int, ...)
 
 class HWConfigMethod(IntEnum):
-    none: int
-    hw_device_ctx: int
-    hw_frame_ctx: int
-    internal: int
-    ad_hoc: int
+    none = cast(int, ...)
+    hw_device_ctx = cast(int, ...)
+    hw_frame_ctx = cast(int, ...)
+    internal = cast(int, ...)
+    ad_hoc = cast(int, ...)
 
 class HWConfig:
     @property

av/container/core.pyi

@@ -2,7 +2,7 @@ from enum import Flag, IntEnum
 from fractions import Fraction
 from pathlib import Path
 from types import TracebackType
-from typing import Any, Callable, ClassVar, Literal, Type, overload
+from typing import Any, Callable, ClassVar, Literal, Type, cast, overload
 
 from av.codec.hwaccel import HWAccel
 from av.format import ContainerFormat
@@ -14,58 +14,58 @@ from .streams import StreamContainer
 Real = int | float | Fraction
 
 class Flags(Flag):
-    gen_pts: ClassVar[Flags]
-    ign_idx: ClassVar[Flags]
-    non_block: ClassVar[Flags]
-    ign_dts: ClassVar[Flags]
-    no_fillin: ClassVar[Flags]
-    no_parse: ClassVar[Flags]
-    no_buffer: ClassVar[Flags]
-    custom_io: ClassVar[Flags]
-    discard_corrupt: ClassVar[Flags]
-    flush_packets: ClassVar[Flags]
-    bitexact: ClassVar[Flags]
-    sort_dts: ClassVar[Flags]
-    fast_seek: ClassVar[Flags]
-    shortest: ClassVar[Flags]
-    auto_bsf: ClassVar[Flags]
+    gen_pts = cast(ClassVar[Flags], ...)
+    ign_idx = cast(ClassVar[Flags], ...)
+    non_block = cast(ClassVar[Flags], ...)
+    ign_dts = cast(ClassVar[Flags], ...)
+    no_fillin = cast(ClassVar[Flags], ...)
+    no_parse = cast(ClassVar[Flags], ...)
+    no_buffer = cast(ClassVar[Flags], ...)
+    custom_io = cast(ClassVar[Flags], ...)
+    discard_corrupt = cast(ClassVar[Flags], ...)
+    flush_packets = cast(ClassVar[Flags], ...)
+    bitexact = cast(ClassVar[Flags], ...)
+    sort_dts = cast(ClassVar[Flags], ...)
+    fast_seek = cast(ClassVar[Flags], ...)
+    shortest = cast(ClassVar[Flags], ...)
+    auto_bsf = cast(ClassVar[Flags], ...)
 
 class AudioCodec(IntEnum):
-    none: int
-    pcm_alaw: int
-    pcm_bluray: int
-    pcm_dvd: int
-    pcm_f16le: int
-    pcm_f24le: int
-    pcm_f32be: int
-    pcm_f32le: int
-    pcm_f64be: int
-    pcm_f64le: int
-    pcm_lxf: int
-    pcm_mulaw: int
-    pcm_s16be: int
-    pcm_s16be_planar: int
-    pcm_s16le: int
-    pcm_s16le_planar: int
-    pcm_s24be: int
-    pcm_s24daud: int
-    pcm_s24le: int
-    pcm_s24le_planar: int
-    pcm_s32be: int
-    pcm_s32le: int
-    pcm_s32le_planar: int
-    pcm_s64be: int
-    pcm_s64le: int
-    pcm_s8: int
-    pcm_s8_planar: int
-    pcm_u16be: int
-    pcm_u16le: int
-    pcm_u24be: int
-    pcm_u24le: int
-    pcm_u32be: int
-    pcm_u32le: int
-    pcm_u8: int
-    pcm_vidc: int
+    none = cast(int, ...)
+    pcm_alaw = cast(int, ...)
+    pcm_bluray = cast(int, ...)
+    pcm_dvd = cast(int, ...)
+    pcm_f16le = cast(int, ...)
+    pcm_f24le = cast(int, ...)
+    pcm_f32be = cast(int, ...)
+    pcm_f32le = cast(int, ...)
+    pcm_f64be = cast(int, ...)
+    pcm_f64le = cast(int, ...)
+    pcm_lxf = cast(int, ...)
+    pcm_mulaw = cast(int, ...)
+    pcm_s16be = cast(int, ...)
+    pcm_s16be_planar = cast(int, ...)
+    pcm_s16le = cast(int, ...)
+    pcm_s16le_planar = cast(int, ...)
+    pcm_s24be = cast(int, ...)
+    pcm_s24daud = cast(int, ...)
+    pcm_s24le = cast(int, ...)
+    pcm_s24le_planar = cast(int, ...)
+    pcm_s32be = cast(int, ...)
+    pcm_s32le = cast(int, ...)
+    pcm_s32le_planar = cast(int, ...)
+    pcm_s64be = cast(int, ...)
+    pcm_s64le = cast(int, ...)
+    pcm_s8 = cast(int, ...)
+    pcm_s8_planar = cast(int, ...)
+    pcm_u16be = cast(int, ...)
+    pcm_u16le = cast(int, ...)
+    pcm_u24be = cast(int, ...)
+    pcm_u24le = cast(int, ...)
+    pcm_u32be = cast(int, ...)
+    pcm_u32le = cast(int, ...)
+    pcm_u8 = cast(int, ...)
+    pcm_vidc = cast(int, ...)
 
 class Container:
     writeable: bool

av/format.pyi

@@ -1,26 +1,26 @@
 __all__ = ("Flags", "ContainerFormat", "formats_available")
 
 from enum import Flag
-from typing import ClassVar, Literal
+from typing import ClassVar, Literal, cast
 
 class Flags(Flag):
-    no_file: ClassVar[Flags]
-    need_number: ClassVar[Flags]
-    show_ids: ClassVar[Flags]
-    global_header: ClassVar[Flags]
-    no_timestamps: ClassVar[Flags]
-    generic_index: ClassVar[Flags]
-    ts_discont: ClassVar[Flags]
-    variable_fps: ClassVar[Flags]
-    no_dimensions: ClassVar[Flags]
-    no_streams: ClassVar[Flags]
-    no_bin_search: ClassVar[Flags]
-    no_gen_search: ClassVar[Flags]
-    no_byte_seek: ClassVar[Flags]
-    allow_flush: ClassVar[Flags]
-    ts_nonstrict: ClassVar[Flags]
-    ts_negative: ClassVar[Flags]
-    seek_to_pts: ClassVar[Flags]
+    no_file = cast(ClassVar[Flags], ...)
+    need_number = cast(ClassVar[Flags], ...)
+    show_ids = cast(ClassVar[Flags], ...)
+    global_header = cast(ClassVar[Flags], ...)
+    no_timestamps = cast(ClassVar[Flags], ...)
+    generic_index = cast(ClassVar[Flags], ...)
+    ts_discont = cast(ClassVar[Flags], ...)
+    variable_fps = cast(ClassVar[Flags], ...)
+    no_dimensions = cast(ClassVar[Flags], ...)
+    no_streams = cast(ClassVar[Flags], ...)
+    no_bin_search = cast(ClassVar[Flags], ...)
+    no_gen_search = cast(ClassVar[Flags], ...)
+    no_byte_seek = cast(ClassVar[Flags], ...)
+    allow_flush = cast(ClassVar[Flags], ...)
+    ts_nonstrict = cast(ClassVar[Flags], ...)
+    ts_negative = cast(ClassVar[Flags], ...)
+    seek_to_pts = cast(ClassVar[Flags], ...)
 
 class ContainerFormat:
     def __init__(self, name: str, mode: Literal["r", "w"] | None = None) -> None: ...