publish_plugins

class CollectUSDAssetLayerContributionsProfileModel(BaseSettingsModel):
    """Define additional contributions to the USD Asset or Shot."""
    _layout = "expanded"
    task_types: list[str] = SettingsField(
        default_factory=list,
        title="Task Types",
        enum_resolver=task_types_enum,
        description=(
            "The current create context task type to filter against. This"
            " allows to filter the profile to only be valid if currently "
            " creating from within that task type."
        ),
    )
    product_names: list[str] = SettingsField(
        default_factory=list,
        title="Product names",
    )
    contributions: list[ContributionSearchLayersModel] = SettingsField(
        default_factory=list,
        title="Contributions",
    )

    @validator("contributions")
    def validate_unique_outputs(cls, value):
        ensure_unique_names(value)
        return value

class CollectUSDLayerContributionsProfileModel(BaseSettingsModel):
    """Profile to define USD contribution attribute defaults."""
    _layout = "expanded"
    product_base_types: list[str] = SettingsField(
        default_factory=list,
        title="Product base types",
        description=(
            "The product base types to match this profile to. When matched,"
            " the settings below would apply to the instance as default"
            " attributes."
        ),
        section="Filter"
    )
    task_types: list[str] = SettingsField(
        default_factory=list,
        title="Task Types",
        enum_resolver=task_types_enum,
        description=(
            "The current create context task type to filter against. This"
            " allows to filter the profile to only be valid if currently "
            " creating from within that task type."
        ),
    )
    task_names: list[str] = SettingsField(
        default_factory=list,
        title="Task names",
    )
    contribution_enabled: bool = SettingsField(
        True,
        title="Contribution Enabled (default)",
        description=(
            "The default state for USD Contribution being marked enabled or"
            " disabled for this profile."
        ),
        section="Instance attribute defaults",
    )
    contribution_layer: str = SettingsField(
        "",
        title="Contribution Department Layer",
        description=(
            "The default contribution layer to apply the contribution to when"
            " matching this profile. The layer name should be in the"
            " 'Department Layer Orders' list to get a sensible order."
        ),
    )
    contribution_target_product: str = SettingsField(
        "usdAsset",
        title="Target Product",
        description=(
            "The default destination product name to apply the contribution to"
            " when matching this profile."
            " Usually e.g. 'usdAsset' or 'usdShot'."
        ),
    )
    contribution_apply_as_variant: bool = SettingsField(
        True,
        title="Apply as variant",
        description=(
            "The default 'Apply as variant' state for instances matching this"
            " profile. Usually enabled for asset contributions and disabled"
            " for shot contributions."
        ),
    )
    contribution_variant_set_name: str = SettingsField(
        "{layer}",
        title="Variant Set name",
        description=(
            "The default variant set name for instances matching this profile."
        ),
    )
    contribution_variant: str = SettingsField(
        "{variant}",
        title="Variant Name",
        description=(
            "The default variant name for instances matching this profile."
        ),
    )
    contribution_variant_default_policy: str = SettingsField(
        "if_not_set",
        title="Set as default variant selection",
        enum_resolver=contribution_variant_default_policy_enum,
        description=(
            "Controls whether this contribution's variant name is authored "
            "as the selected default for the variant set. Use "
            f"'{CONTRIBUTION_VARIANT_DEFAULT_POLICY['never']}' to leave the "
            "variant selection unchanged, "
            f"'{CONTRIBUTION_VARIANT_DEFAULT_POLICY['if_not_set']}' to set "
            "it only when no selection exists, or "
            f"'{CONTRIBUTION_VARIANT_DEFAULT_POLICY['always']}' to always "
            "override the current selection."
        ),
    )

class ContributionSearchLayersModel(BaseSettingsModel):
    """Additional contribution to add into the USD Asset or Shot."""
    _layout = "expanded"
    name: str = SettingsField(
        "",
        title="Layer Identifier",
        description=(
            "Specific layer identifier to search for in the Sdf layer. If it"
            " is already found the original layer identifier will be swapped"
            " with this newer, so you can contribute updates to the same"
            " product."
        ),
    )
    order: int = SettingsField(
        0,
        title="Order",
        description=(
            "Strength of the contribution among other contributions. "
            "Higher order means a higher strength and stacks the layer on top."
        ),
    )
    type: str = SettingsField(
        "sublayer",
        title="Load",
        enum_resolver=usd_contribution_layering_types_enum_resolver,
        conditional_enum=True,
        description=(
            "How to add the contribution: as a sublayer, as a reference on a"
            " prim or as a reference inside a variant on a prim."
        ),
    )

    # Load type specific-settings
    reference: ReferenceContributionModel = SettingsField(
        default_factory=ReferenceContributionModel,
        title="Reference Contribution"
    )
    variant: VariantContributionModel = SettingsField(
        default_factory=VariantContributionModel,
        title="Variant Contribution",
    )

    only_if_existing: bool = SettingsField(
        default=True,
        title="Add only if version exists",
        description=(
            "Add the layer only if the given representation filepath exists."
        )
    )

    # Now we need to define what file or path the user should be loading.
    # These can be AYON Entity URIs or a 'searched product' at a specific
    # folder path or parent folder path
    load_from: str = SettingsField(
        "source_path",
        title="Layer method",
        enum_resolver=usd_contribution_load_from_enum_resolver,
        conditional_enum=True,
        description=(
            "How to define the layer to contribute: an explicit source path"
            " or a product found in a parent folder of a given folder type."
        ),
    )

    source_path: str = SettingsField(
        "",
        title="Source Path",
        description=(
            "Layer path. This can be an AYON entity URI or a relative file"
            " path. It will be taken 1:1 into the result so use with caution."
        ),
    )
    search_product: SearchParentProductModel = SettingsField(
        default_factory=SearchParentProductModel,
        title="Find product in first parent folder of a given folder type",
    )

class EntityListFolderModel(BaseSettingsModel):
    """Folder must have label and can be scoped to views.

    Scope of the folder can be defined for all views or use just the view
        matching list type of created list. In case the list folder already
        exists the settings are not used and we just make sure the list can
        be seen under the folder.

    """
    _layout = "expanded"
    label: str = SettingsField(
        "",
        title="Folder label",
        description=(
            "The label of the folder to create. "
            "Anatomy formattable template for the name."
        ),
    )
    # Don't use explicit scope enum, rather ask if the folder should be seen
    #   everywhere or just in the list type matching created list.
    scope_def: str = SettingsField(
        "all",
        enum_resolver=list_folder_scope_def,
        title="Scope",
    )

class ExtractBurninDef(BaseSettingsModel):
    _isGroup = True
    _layout = "expanded"
    name: str = SettingsField(
        "",
        title="Name",
        description=(
            "Unique name of the burnin. Review outputs in *Extract Review*"
            " can link to it by this name."
        ),
    )
    TOP_LEFT: str = SettingsField(
        "",
        title="Top Left",
        description=(
            "Text to burn in at this position. Supports template keys, e.g."
            " `{folder[name]}`, `{task[name]}`, `{anatomy[version]}`,"
            " `{username}`, `{comment}`, `{yy}-{mm}-{dd}`, `{frame_start}`,"
            " `{frame_end}`, `{current_frame}` and `{timecode}`."
        ),
    )
    TOP_CENTERED: str = SettingsField("", title="Top Centered")
    TOP_RIGHT: str = SettingsField("", title="Top Right")
    BOTTOM_LEFT: str = SettingsField("", title="Bottom Left")
    BOTTOM_CENTERED: str = SettingsField("", title="Bottom Centered")
    BOTTOM_RIGHT: str = SettingsField("", title="Bottom Right")
    filter: ExtractBurninDefFilter = SettingsField(
        default_factory=ExtractBurninDefFilter,
        title="Additional filtering"
    )

    @validator("name")
    def validate_name(cls, value):
        """Ensure name does not contain weird characters"""
        return normalize_name(value)

class ExtractOIIOPostProcessModel(BaseSettingsModel):
    """Process representation images with `oiiotool` on publish.

    This could be used to convert images to different formats, convert to
    scanline images or flatten deep images.
    """
    enabled: bool = SettingsField(True)
    profiles: list[ExtractOIIOPostProcessProfileModel] = SettingsField(
        default_factory=list, title="Profiles"
    )

class ExtractOIIOTranscodeModel(BaseSettingsModel):
    """Transcode images to another colorspace using OIIO.

    Mostly aimed at transcoding for reviewables (it'll process and output
    only RGBA channels).
    """
    enabled: bool = SettingsField(True)
    profiles: list[ExtractOIIOTranscodeProfileModel] = SettingsField(
        default_factory=list, title="Profiles"
    )

class ExtractOTIOReviewModel(BaseSettingsModel):
    """Extract review representation from OTIO based input products.
    """
    representation_name: str = SettingsField(
        "",
        title="Representation name",
        description=(
            "The name of the representation generated by the OTIO extractor. "
            "(Defaults to the Output Extension.)"
        )
    )
    output_ext: str = SettingsField(
        "png",
        title="Output extension",
        # TODO: need to work-out the plugin logic
        # before we allow more than 'png' extension.
        disabled=True,
    )
    default_width: int = SettingsField(
        1280,
        ge=0,
        le=100000,
        title="Default width"
    )
    default_height: int = SettingsField(
        720,
        ge=0,
        le=100000,
        title="Default height"
    )

class ExtractReviewOutputDefModel(BaseSettingsModel):
    _layout = "expanded"
    name: str = SettingsField(
        "",
        title="Name",
        description=(
            "Unique name of the output, used in the representation name,"
            " e.g. `h264`."
        ),
    )
    ext: str = SettingsField(
        "",
        title="Output extension",
        description="File extension of the output, e.g. `mp4` or `png`.",
    )
    # TODO use some different source of tags
    tags: list[str] = SettingsField(
        default_factory=list,
        title="Tags",
        description=(
            "Tags added to the output representation. Common tags:\n"
            "- `webreview`: upload as reviewable to AYON\n"
            "- `burnin`: add burnins using *Extract Burnin*\n"
            "- `delete`: do not keep the file after publishing\n"
            "- `no-handles`: exclude handles from the output\n"
            "- `ftrackreview` / `kitsureview`: send to the tracker"
        ),
    )
    burnins: list[str] = SettingsField(
        default_factory=list,
        title="Link to a burnin by name",
        description=(
            "Names of burnin definitions from *Extract Burnin* to use for"
            " this output. Empty means all matching burnins are used."
        ),
    )
    ffmpeg_args: ExtractReviewFFmpegModel = SettingsField(
        default_factory=ExtractReviewFFmpegModel,
        title="FFmpeg arguments"
    )
    filter: ExtractReviewFilterModel = SettingsField(
        default_factory=ExtractReviewFilterModel,
        title="Additional output filtering"
    )
    overscan_crop: str = SettingsField(
        "",
        title="Overscan crop",
        description=(
            "Crop input overscan. See the documentation for more information."
        )
    )
    overscan_color: ColorRGBA_uint8 = SettingsField(
        (0, 0, 0, 0.0),
        title="Overscan color",
        description=(
            "Overscan color is used when input aspect ratio is not"
            " same as output aspect ratio."
        )
    )
    # overscan_color: ColorRGB_uint8 = SettingsField(
    #     (0, 0, 0),
    #     title="Overscan color",
    #     description=(
    #         "Overscan color is used when input aspect ratio is not"
    #         " same as output aspect ratio."
    #     )
    # )
    width: int = SettingsField(
        0,
        ge=0,
        le=100000,
        title="Output width",
        description=(
            "Width and Height must be both set to higher"
            " value than 0 else source resolution is used."
        )
    )
    height: int = SettingsField(
        0,
        title="Output height",
        ge=0,
        le=100000,
    )
    scale_pixel_aspect: bool = SettingsField(
        True,
        title="Scale pixel aspect",
        description=(
            "Rescale input when it's pixel aspect ratio is not 1."
            " Useful for anamorphic reviews."
        )
    )
    bg_color: ColorRGBA_uint8 = SettingsField(
        (0, 0, 0, 0.0),
        description=(
            "Background color is used only when input have transparency"
            " and Alpha is higher than 0."
        ),
        title="Background color",
    )
    letter_box: ExtractReviewLetterBox = SettingsField(
        default_factory=ExtractReviewLetterBox,
        title="Letter Box"
    )
    fill_missing_frames: str = SettingsField(
        title="Handle missing frames",
        default="closest_existing",
        description="How to handle gaps in sequence frame ranges.",
        enum_resolver=_handle_missing_frames_enum
    )

    @validator("name")
    def validate_name(cls, value):
        """Ensure name does not contain weird characters"""
        return normalize_name(value)

class ExtractThumbnailFromSourceModel(BaseSettingsModel):
    """Thumbnail extraction from source files using ffmpeg and oiiotool."""
    enabled: bool = SettingsField(True)

    target_size: ResizeModel = SettingsField(
        default_factory=ResizeModel, title="Target size"
    )
    background_color: ColorRGBA_uint8 = SettingsField(
        (0, 0, 0, 0.0), title="Background color"
    )

class IntegrateProductGroupModel(BaseSettingsModel):
    """Group published products by filtering logic.

    Set all published instances as a part of specific group named according
     to 'Template'.

    Implemented all variants of placeholders '{task}', '{product[type]}',
    '{host}', '{product[name]}', '{renderlayer}'.
    """

    _isGroup = True
    product_grouping_profiles: list[IntegrateProductGroupProfile] = (
        SettingsField(
            default_factory=list,
            title="Product group profiles"
        )
    )

class PreIntegrateThumbnailsModel(BaseSettingsModel):
    """Explicitly set if Thumbnail representation should be integrated.

    If no matching profile set, existing state from Host implementation
    is kept.
    """

    _isGroup = True
    enabled: bool = SettingsField(True)
    integrate_profiles: list[PreIntegrateThumbnailsProfile] = SettingsField(
        default_factory=list,
        title="Integrate profiles"
    )

class ValidateIntentModel(BaseSettingsModel):
    """Validate if Publishing intent was selected.

    It is possible to disable validation for specific publishing context
    with profiles.
    """

    _isGroup = True
    enabled: bool = SettingsField(False)
    profiles: list[ValidateIntentProfile] = SettingsField(default_factory=list)