Format options

CineonFormatOptions ¶

Bases: FormatOptionsBase

Cineon/DPX format-specific render options.

These settings correspond to the Cineon Settings dialog in After Effects, accessible when the output format is set to Cineon Sequence or DPX Sequence.

Example

from py_aep import CineonFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, CineonFormatOptions):
    print(om.format_options.file_format)

Attributes¶

bit_depth ¶

bit_depth = ChunkField[int](
    "_body",
    "bit_depth",
    validate=validate_one_of([8, 10, 12, 16]),
)

The bit depth per channel (8, 10, 12, or 16). Read / Write.

Only meaningful when file_format is CineonFileFormat.DPX. For FIDO/Cineon 4.5 the output is always 10-bit and AE hides the Bit Depth dropdown; the stored byte is inert and keeps whatever the last DPX selection was (AE-observed), so reads may return a stale value.

converted_black_point ¶

converted_black_point = ChunkField[float](
    "_body",
    "converted_black_point",
    validate=_validate_number(),
)

The converted black point value, normalized to the 0.0-1.0 range. This is the linear-light equivalent of the 10-bit black point. Read / Write.

converted_white_point ¶

converted_white_point = ChunkField[float](
    "_body",
    "converted_white_point",
    validate=_validate_number(),
)

The converted white point value, normalized to the 0.0-1.0 range. This is the linear-light equivalent of the 10-bit white point. Read / Write.

current_gamma ¶

current_gamma = ChunkField[float](
    "_body", "current_gamma", validate=_validate_number()
)

The gamma value applied during the Cineon/DPX conversion. Read / Write.

file_format ¶

file_format = enum(
    CineonFileFormat,
    "_body",
    "file_format",
    allow_out_of_enum_values=True,
)

The file format for the Cineon output. See CineonFileFormat for possible values. An out-of-enum stored value reads back as a raw int (the binary is trusted). Read / Write.

highlight_expansion ¶

highlight_expansion = ChunkField[int](
    "_body", "highlight_expansion", validate=validate_u2
)

The highlight expansion value. Read / Write.

logarithmic_conversion ¶

logarithmic_conversion = bool(
    "_body", "logarithmic_conversion"
)

Whether logarithmic conversion is enabled. Read / Write.

ten_bit_black_point ¶

ten_bit_black_point = ChunkField[int](
    "_body",
    "ten_bit_black_point",
    validate=_validate_number(
        min=0, max=1023, integer=True
    ),
)

The 10-bit black point value (0-1023). Defines the code value that maps to the black point on a logarithmic scale. Read / Write.

ten_bit_white_point ¶

ten_bit_white_point = ChunkField[int](
    "_body",
    "ten_bit_white_point",
    validate=_validate_number(
        min=0, max=1023, integer=True
    ),
)

The 10-bit white point value (0-1023). Defines the code value that maps to the white point on a logarithmic scale. Read / Write.

JpegFormatOptions ¶

Bases: FormatOptionsBase

JPEG format-specific render options.

These settings correspond to the JPEG Options dialog in After Effects, accessible when the output format is set to JPEG Sequence.

Example

from py_aep import JpegFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, JpegFormatOptions):
    print(om.format_options.quality)

Attributes¶

format_type ¶

format_type = enum(
    JpegFormatType,
    "_body",
    "format_type",
    allow_out_of_enum_values=True,
)

JPEG format option type: Baseline (Standard), Baseline Optimized, or Progressive. An out-of-enum stored value reads back as a raw int (the binary is trusted). Read / Write.

quality ¶

quality = ChunkField[int](
    "_body",
    "quality",
    validate=_validate_number(min=0, max=10, integer=True),
)

JPEG quality level, from 0 (Smaller File) to 10 (Bigger File). Read / Write.

scans ¶

scans = ChunkField[int](
    "_body",
    "scans",
    transform=lambda x: x + 2,
    reverse=lambda x: x - 2,
    validate=validate_one_of([3, 4, 5]),
)

Number of progressive scans (3, 4, or 5). Only relevant when format_type is JpegFormatType.PROGRESSIVE. Read / Write.

OpenExrFormatOptions ¶

Bases: FormatOptionsBase

OpenEXR format-specific render options.

These settings correspond to the OpenEXR Options dialog in After Effects, accessible when the output format is set to OpenEXR or OpenEXR Sequence.

Example

from py_aep import OpenExrFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, OpenExrFormatOptions):
    print(om.format_options.compression)

Attributes¶

compression ¶

compression = enum(
    OpenExrCompression,
    "_body",
    "compression",
    allow_out_of_enum_values=True,
)

The compression method. Corresponds to the Compression dropdown in the OpenEXR Options dialog. An out-of-enum stored value reads back as a raw int (the binary is trusted). Read / Write.

dwa_compression_level ¶

dwa_compression_level: float | None

The DWA compression level. Only meaningful when compression is OpenExrCompression.DWAA or OpenExrCompression.DWAB. Stored as a little-endian f4 in the Ropt body. Defaults to 45.0. Read / Write.

luminance_chroma ¶

luminance_chroma = bool('_body', 'luminance_chroma')

Whether Luminance/Chroma encoding is enabled. Corresponds to the Luminance/Chroma checkbox in the OpenEXR Options dialog. Not applicable when compression is DWAA or DWAB. Read / Write.

thirty_two_bit_float ¶

thirty_two_bit_float = bool("_body", "thirty_two_bit_float")

Whether 32-bit float output is used instead of the default 16-bit half float. Corresponds to the 32-bit float (not recommended) checkbox in the OpenEXR Options dialog. Read / Write.

PngFormatOptions ¶

Bases: FormatOptionsBase

PNG format-specific render options.

These settings correspond to the PNG Options dialog in After Effects, accessible when the output format is set to PNG Sequence.

The Ropt body for PNG contains a fixed-size binary block (typically 318 bytes) with width, height, and bit depth at known offsets. HDR10 metadata is stored separately in a JSON Utf8 chunk alongside the Ropt chunk.

Example

from py_aep import PngFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, PngFormatOptions):
    print(om.format_options.compression)

Attributes¶

bit_depth ¶

bit_depth = ChunkField[int](
    "_body",
    "bit_depth",
    validate=validate_one_of([8, 16, 32]),
)

The output bit depth per channel. Common values are 8 and 16. Read / Write.

color_primaries ¶

color_primaries: Hdr10ColorPrimaries | int

The color primaries used for HDR10 metadata. Corresponds to the Color Primaries dropdown in the PNG Options dialog. Only meaningful when include_hdr10_metadata is True. An out-of-enum stored value reads back as a raw int (the binary is trusted). Read / Write.

compression ¶

compression = enum(
    PngCompression,
    "_body",
    "compression",
    allow_out_of_enum_values=True,
)

The PNG compression / interlace mode. Corresponds to the Compression dropdown in the PNG Options dialog. An out-of-enum stored value reads back as a raw int (the binary is trusted). Read / Write.

content_light_average ¶

content_light_average: float | None

The maximum frame average light level in nits for HDR10 metadata, or None if not explicitly set. Corresponds to the Content Light Average field in the PNG Options dialog. Read / Write.

content_light_max ¶

content_light_max: float | None

The maximum content light level in nits for HDR10 metadata, or None if not explicitly set. Corresponds to the Content Light Maximum field in the PNG Options dialog. Read / Write.

height ¶

height = ChunkField[int]('_body', 'height', read_only=True)

The output height in pixels. Read-only.

include_hdr10_metadata ¶

include_hdr10_metadata: bool

Whether HDR10 metadata is embedded in the PNG output. Corresponds to the Include HDR10 Metadata checkbox in the PNG Options dialog. Only available for 16-bit output. Read / Write.

luminance_max ¶

luminance_max: float | None

The maximum display luminance in nits for HDR10 metadata, or None if not explicitly set. Corresponds to the Luminance Maximum field in the PNG Options dialog. Read / Write.

luminance_min ¶

luminance_min: float | None

The minimum display luminance in nits for HDR10 metadata, or None if not explicitly set. Corresponds to the Luminance Minimum field in the PNG Options dialog. Read / Write.

width ¶

width = ChunkField[int]('_body', 'width', read_only=True)

The output width in pixels. Read-only.

TargaFormatOptions ¶

Bases: FormatOptionsBase

Targa (TGA) format-specific render options.

These settings correspond to the Targa Options dialog in After Effects, accessible when the output format is set to Targa Sequence.

Example

from py_aep import TargaFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, TargaFormatOptions):
    print(om.format_options.bits_per_pixel)

Attributes¶

bits_per_pixel ¶

bits_per_pixel = ChunkField[int](
    "_body",
    "bits_per_pixel",
    validate=validate_one_of([24, 32]),
)

Color depth in bits per pixel (24 or 32). Read / Write.

Not coupled to the module's Channels setting in the binary: AE only rewrites this byte when the Targa Options dialog is visited, so AE-saved files hold RGB with 32 bpp and RGB+Alpha with 24 bpp (stale, like Cineon's FIDO bit_depth). The output module's Depth setting is the authoritative alpha/depth choice.

rle_compression ¶

rle_compression = bool('_body', 'rle_compression')

Whether RLE compression is enabled. Read / Write.

TiffFormatOptions ¶

Bases: FormatOptionsBase

TIFF format-specific render options.

These settings correspond to the TIFF Options dialog in After Effects, accessible when the output format is set to TIFF Sequence.

Example

from py_aep import TiffFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, TiffFormatOptions):
    print(om.format_options.lzw_compression)

Attributes¶

ibm_pc_byte_order ¶

ibm_pc_byte_order = bool('_body', 'ibm_pc_byte_order')

Whether IBM PC byte order (little-endian) is used. Read / Write.

lzw_compression ¶

lzw_compression = bool('_body', 'lzw_compression')

Whether LZW compression is enabled. Read / Write.

XmlFormatOptions ¶

Bases: FormatOptionsBase

XML-based format-specific render options.

Shared by output formats that store their settings as a binary header followed by a PremiereData XML block containing ExporterParam elements. Applicable formats include AVI (.AVI), H.264 (H264), MP3 (Mp3), QuickTime (MooV), and WAV (wao_).

Individual parameters are stored in the params dictionary, keyed by their Adobe parameter identifier (e.g. "ADBEVideoCodec").

Example

from py_aep import XmlFormatOptions, parse

app = parse("project.aep")
om = app.project.render_queue.items[0].output_modules[0]
if isinstance(om.format_options, XmlFormatOptions):
    print(om.format_options.video_codec)

Attributes¶

audio_bitrate ¶

audio_bitrate = _ScalarParam('ADBEAudioBitrate')

The H.264 audio bitrate in kbps, from the ADBEAudioBitrate parameter, or None when absent. Read / Write.

audio_codec ¶

audio_codec = _EnumParam('ADBEAudioCodec', AudioCodec)

The audio codec as an AudioCodec integer value extracted from the ADBEAudioCodec parameter, or None when the parameter is absent. Falls back to a plain int when the codec is not in the AudioCodec enum. Read / Write.

audio_interleave ¶

audio_interleave = _EnumParam(
    "ADBEAudioInterleave", AudioInterleave
)

The AVI audio interleave interval as an AudioInterleave value extracted from the ADBEAudioInterleave parameter. The dialog's None choice stores no parameter, so reads return None for it. Read / Write.

bitrate ¶

bitrate = _ScalarParam('BitRate')

The MP3 audio bitrate in kbps, from the BitRate parameter (note: not ADBE-prefixed), or None when absent. Read / Write.

dnx_alpha_type ¶

dnx_alpha_type = _ScalarParam('ADBEDNxHDAlphaType')

The DNxHR/DNxHD Alpha choice from the ADBEDNxHDAlphaType parameter: 1 = Compressed, None (param absent) = None. Only meaningful when video_codec is VideoCodec.DNXHR_DNXHD. (ADBEVideoAlphaType is unrelated - it reads true on every sampled module.) Read / Write.

format_code ¶

format_code = ChunkField[str](
    "_body", "format_code", read_only=True
)

The 4-character format identifier from the Ropt chunk header (e.g. ".AVI", "H264", "Mp3 ", "MooV", "wao_"). Read-only.

frame_rate ¶

frame_rate: float | None

The output frame rate in frames per second, derived from the ADBEVideoFPS parameter. Adobe stores this as ticks per frame using a time base of 254,016,000,000 ticks/second, so frame_rate = 254016000000 / ADBEVideoFPS. None for audio-only formats (MP3, WAV). Read / Write.

level ¶

level = _ScalarParam('ADBEVideoMPEGProfileLevel')

The H.264 encoding level as the raw integer from the ADBEVideoMPEGProfileLevel parameter (level x 10, e.g. 41 for 4.1; 100 is Unrestricted), or None when absent. Read / Write.

mpeg_audio_format ¶

mpeg_audio_format = _EnumParam(
    "ADBEMPEGAudioFormat", MPEGAudioFormat
)

The dialog's top-level Audio Format (AAC / MPEG / PCM) as an MPEGAudioFormat FourCC integer value extracted from the ADBEMPEGAudioFormat parameter, or None when the parameter is absent. Despite the parameter's MPEG prefix it selects among all three families. Falls back to a plain int when the value is not in the MPEGAudioFormat enum. Read / Write.

mpeg_audio_layer ¶

mpeg_audio_layer = _EnumParam(
    "ADBEMPEGAudioLayer", MPEGAudioLayer
)

The MPEG-1 audio layer as an MPEGAudioLayer value extracted from the ADBEMPEGAudioLayer parameter, or None when the parameter is absent. Only meaningful when mpeg_audio_format is MPEGAudioFormat.MPEG. Read / Write.

mpeg_multiplexer ¶

mpeg_multiplexer = _EnumParam(
    "ADBEMPEGMultiplexer", MPEGMultiplexer
)

The MPEG multiplexer as an MPEGMultiplexer FourCC integer value extracted from the ADBEMPEGMultiplexer parameter, or None when the parameter is absent. Falls back to a plain int when the value is not in the MPEGMultiplexer enum. Read / Write.

mpeg_mux_stream_compatibility ¶

mpeg_mux_stream_compatibility = _EnumParam(
    "ADBEMPEGMuxStreamCompatibility",
    MPEGMuxStreamCompatibility,
)

The MPEG mux stream compatibility as an MPEGMuxStreamCompatibility FourCC integer value extracted from the ADBEMPEGMuxStreamCompatibility parameter, or None when the parameter is absent. Falls back to a plain int when the value is not in the MPEGMuxStreamCompatibility enum. Read / Write.

params ¶

params: ParamsDict = ParamsDict()

All ExporterParam key-value pairs extracted from the embedded XML PremiereData block. Keys are Adobe parameter identifiers such as "ADBEVideoCodec", "ADBEVideoQuality", "ADBEAudioInterleave", etc. Values are the raw string representations from the XML. Read / Write.

Writes through this dict are the documented low-level escape hatch: they bypass the typed accessors' format-rule validation and clamps. Item assignment (params[key] = value), update and setdefault all sync back to the XML. Removal (pop/del) only mutates the dict: the ExporterParam element stays in the file.

profile ¶

profile: MPEGProfile | int

The H.264 encoding profile as an MPEGProfile value from the ADBEVideoMPEGProfile parameter. Read / Write.

After Effects stores NO parameter for Baseline, so an absent parameter reads back as MPEGProfile.BASELINE and assigning BASELINE removes the parameter (AE-validated: the result matches an AE-saved Baseline module's parameters exactly). The dropdown's Auto is resolved at save time and reads back as MAIN. Falls back to a plain int when the stored value is not in the MPEGProfile enum.

resolution ¶

resolution = _EnumParam(
    "ADBEVideoResolution", DnxResolution
)

The DNxHR/DNxHD resolution preset as a DnxResolution value extracted from the ADBEVideoResolution parameter, or None when the parameter is absent. Only meaningful when video_codec is VideoCodec.DNXHR_DNXHD; the param survives codec changes (stale under other codecs). Falls back to a plain int when the value is not in the DnxResolution enum. Read / Write.

video_codec ¶

video_codec = _EnumParam('ADBEVideoCodec', VideoCodec)

The video codec as a VideoCodec FourCC integer value extracted from the ADBEVideoCodec parameter, or None for audio-only formats (MP3, WAV). Falls back to a plain int when the codec is not in the VideoCodec enum. Read / Write.