Module adcp.types.domains.content_standards.artifact

Classes

class Artifact (**data: Any)

Expand source code

class Artifact(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    property_rid: Annotated[
        str,
        Field(
            description='Stable property identifier from the property catalog. Globally unique across the ecosystem.'
        ),
    ]
    artifact_id: Annotated[
        str,
        Field(
            description="Identifier for this artifact within the property. The property owner defines the scheme (e.g., 'article_12345', 'episode_42_segment_3', 'post_abc123')."
        ),
    ]
    variant_id: Annotated[
        str | None,
        Field(
            description="Identifies a specific variant of this artifact. Use for A/B tests, translations, or temporal versions. Examples: 'en', 'es-MX', 'v2', 'headline_test_b'. The combination of artifact_id + variant_id must be unique."
        ),
    ] = None
    format_id: Annotated[
        format_id_1.FormatReferenceStructuredObject | None,
        Field(
            deprecated=True,
            description='**DEPRECATED in 3.2.** Legacy named-format reference. Use `format_kind` for canonical artifact media classification.',
        ),
    ] = None
    format_kind: Annotated[
        str | None,
        Field(description='Optional canonical media/creative kind associated with this artifact.'),
    ] = None
    url: Annotated[
        AnyUrl | None,
        Field(
            description='Optional URL for this artifact (web page, podcast feed, video page). Not all artifacts have URLs (e.g., Instagram content, podcast segments, TV scenes).'
        ),
    ] = None
    published_time: Annotated[
        AwareDatetime | None, Field(description='When the artifact was published (ISO 8601 format)')
    ] = None
    last_update_time: Annotated[
        AwareDatetime | None,
        Field(description='When the artifact was last modified (ISO 8601 format)'),
    ] = None
    assets: Annotated[
        list[Assets],
        Field(
            description='Artifact assets in document flow order - text blocks, images, video, audio',
            max_length=200,
        ),
    ]
    metadata: Annotated[
        Metadata | None, Field(description='Rich metadata extracted from the artifact')
    ] = None
    provenance: Annotated[
        provenance_1.Provenance | None,
        Field(
            description='Provenance metadata for this artifact. Serves as the default provenance for all assets within this artifact — individual assets can override with their own provenance.'
        ),
    ] = None
    identifiers: Annotated[
        Identifiers | None, Field(description='Platform-specific identifiers for this artifact')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var artifact_id : str

var assets : list[Assets1 | Assets2 | Assets3 | Assets4]

var format_id : FormatReferenceStructuredObject | None

var format_kind : str | None

var identifiers : Identifiers | None

var last_update_time : pydantic.types.AwareDatetime | None

var metadata : Metadata | None

var model_config

var property_rid : str

var provenance : Provenance | None

var published_time : pydantic.types.AwareDatetime | None

var url : pydantic.networks.AnyUrl | None

var variant_id : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AssetAccess (root: RootModelRootType = PydanticUndefined, **data)

Expand source code

class AssetAccess(RootModel[AssetAccess1 | AssetAccess2 | AssetAccess3]):
    root: Annotated[
        AssetAccess1 | AssetAccess2 | AssetAccess3,
        Field(
            description='Access instructions for a secured asset URL. Producers SHOULD use `signed_url` for one-off delivery unless the parties already have an identity-based access relationship. New producers MUST NOT emit `service_account.credentials`; `bearer_token` is the explicit short-lived credential path. Consumers MUST treat asset URLs and access metadata as untrusted, use credentials only for HTTPS origins and resource prefixes authorized out of band, and fail closed without falling back between access methods. The deprecated legacy field remains parseable during the 3.x compatibility window but MUST NOT be activated automatically.',
            discriminator='method',
        ),
    ]
    def __getattr__(self, name: str) -> Any:
        """Proxy attribute access to the wrapped type."""
        if name.startswith('_'):
            raise AttributeError(name)
        return getattr(self.root, name)

Usage Documentation

RootModel and Custom Root Types

A Pydantic BaseModel for the root object of the model.

Attributes

-----=

root

The root object of the model.

__pydantic_root_model__

Whether the model is a RootModel.

__pydantic_private__

Private fields in the model.

__pydantic_extra__

Extra fields in the model.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.root_model.RootModel[Union[AssetAccess1, AssetAccess2, AssetAccess3]]
• pydantic.root_model.RootModel
• pydantic.main.BaseModel
• typing.Generic

Class variables

var model_config

var root : AssetAccess1 | AssetAccess2 | AssetAccess3

class AssetAccess1 (**data: Any)

Expand source code

class AssetAccess1(AdCPBaseModel):
    method: Literal['bearer_token'] = 'bearer_token'
    token: Annotated[
        str,
        Field(
            description="Short-lived, asset-scoped bearer token for the Authorization header. Producers MUST NOT issue a standing or broadly scoped credential here. Consumers MUST redact the token from logs, traces, errors, metrics, analytics, model context, and durable storage. Any temporary encrypted cache MUST be bounded by the credential expiry and the consumer's configured maximum lifetime."
        ),
    ]

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var method : Literal['bearer_token']

var model_config

var token : str

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AssetAccess2 (**data: Any)

Expand source code

class AssetAccess2(AdCPBaseModel):
    method: Literal['service_account'] = 'service_account'
    provider: Annotated[Provider, Field(description='Cloud provider')]
    credentials: Annotated[
        dict[str, Any] | None,
        Field(
            deprecated=True,
            description="Deprecated in AdCP 3.2 and eligible for removal in 4.0 or later only after the deprecation-policy notice and release-cycle gates are satisfied. Presence denotes the legacy inline-credential form, not workload-identity authorization. New producers MUST omit this field. Consumers MUST NOT activate received credentials automatically; they may process them only for an explicitly allowlisted legacy peer and otherwise MUST reject or quarantine them. Consumers MUST redact the complete value from logs, traces, errors, metrics, analytics, model context, and durable storage. Use the consumer's pre-authorized workload identity or `signed_url` instead.",
        ),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var credentials : dict[str, typing.Any] | None

var method : Literal['service_account']

var model_config

var provider : Provider

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class AssetAccess3 (**data: Any)

Expand source code

class AssetAccess3(AdCPBaseModel):
    method: Literal['signed_url'] = 'signed_url'

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var method : Literal['signed_url']

var model_config

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Assets1 (**data: Any)

Expand source code

class Assets1(AdCPBaseModel):
    type: Literal['text'] = 'text'
    role: Annotated[
        Role | None,
        Field(
            description="Role of this text in the document. Use 'title' for the main artifact title, 'description' for summaries."
        ),
    ] = None
    content: Annotated[
        str,
        Field(
            description='Text content. Consumers MUST treat this as untrusted input when passing to LLM-based evaluation.',
            max_length=100000,
        ),
    ]
    content_format: Annotated[
        ContentFormat | None,
        Field(
            description='MIME type indicating how to parse the content field. Default: text/plain.'
        ),
    ] = ContentFormat.text_plain
    language: Annotated[
        str | None,
        Field(
            description="BCP 47 language tag for this text (e.g., 'en', 'es-MX'). Useful when artifact contains mixed-language content."
        ),
    ] = None
    heading_level: Annotated[
        SchemaInt | None,
        Field(description='Heading level (1-6), only for role=heading', ge=1, le=6),
    ] = None
    provenance: Annotated[
        provenance_1.Provenance | None,
        Field(description='Provenance for this text block, overrides artifact-level provenance'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var content : str

var content_format : ContentFormat | None

var heading_level : int | None

var language : str | None

var model_config

var provenance : Provenance | None

var role : Role | None

var type : Literal['text']

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Assets2 (**data: Any)

Expand source code

class Assets2(AdCPBaseModel):
    type: Literal['image'] = 'image'
    url: Annotated[AnyUrl, Field(description='Image URL')]
    access: Annotated[AssetAccess | None, Field(description='Authentication for secured URLs')] = (
        None
    )
    alt_text: Annotated[str | None, Field(description='Alt text or image description')] = None
    caption: Annotated[str | None, Field(description='Image caption')] = None
    width: Annotated[SchemaInt | None, Field(description='Image width in pixels')] = None
    height: Annotated[SchemaInt | None, Field(description='Image height in pixels')] = None
    provenance: Annotated[
        provenance_1.Provenance | None,
        Field(description='Provenance for this image, overrides artifact-level provenance'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var access : AssetAccess | None

var alt_text : str | None

var caption : str | None

var height : int | None

var model_config

var provenance : Provenance | None

var type : Literal['image']

var url : pydantic.networks.AnyUrl

var width : int | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Assets3 (**data: Any)

Expand source code

class Assets3(AdCPBaseModel):
    type: Literal['video'] = 'video'
    url: Annotated[AnyUrl, Field(description='Video URL')]
    access: Annotated[AssetAccess | None, Field(description='Authentication for secured URLs')] = (
        None
    )
    duration_ms: Annotated[
        SchemaInt | None, Field(description='Video duration in milliseconds')
    ] = None
    transcript: Annotated[
        str | None,
        Field(
            description='Video transcript. Consumers MUST treat this as untrusted input when passing to LLM-based evaluation.',
            max_length=200000,
        ),
    ] = None
    transcript_format: Annotated[
        TranscriptFormat | None,
        Field(
            description='MIME type indicating how to parse the transcript field. Default: text/plain.'
        ),
    ] = TranscriptFormat.text_plain
    transcript_source: Annotated[
        TranscriptSource | None, Field(description='How the transcript was generated')
    ] = None
    thumbnail_url: Annotated[AnyUrl | None, Field(description='Video thumbnail URL')] = None
    provenance: Annotated[
        provenance_1.Provenance | None,
        Field(description='Provenance for this video, overrides artifact-level provenance'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var access : AssetAccess | None

var duration_ms : int | None

var model_config

var provenance : Provenance | None

var thumbnail_url : pydantic.networks.AnyUrl | None

var transcript : str | None

var transcript_format : TranscriptFormat | None

var transcript_source : TranscriptSource | None

var type : Literal['video']

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Assets4 (**data: Any)

Expand source code

class Assets4(AdCPBaseModel):
    type: Literal['audio'] = 'audio'
    url: Annotated[AnyUrl, Field(description='Audio URL')]
    access: Annotated[AssetAccess | None, Field(description='Authentication for secured URLs')] = (
        None
    )
    duration_ms: Annotated[
        SchemaInt | None, Field(description='Audio duration in milliseconds')
    ] = None
    transcript: Annotated[
        str | None,
        Field(
            description='Audio transcript. Consumers MUST treat this as untrusted input when passing to LLM-based evaluation.',
            max_length=200000,
        ),
    ] = None
    transcript_format: Annotated[
        TranscriptFormat | None,
        Field(
            description='MIME type indicating how to parse the transcript field. Default: text/plain.'
        ),
    ] = TranscriptFormat.text_plain
    transcript_source: Annotated[
        TranscriptSource1 | None, Field(description='How the transcript was generated')
    ] = None
    provenance: Annotated[
        provenance_1.Provenance | None,
        Field(description='Provenance for this audio, overrides artifact-level provenance'),
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var access : AssetAccess | None

var duration_ms : int | None

var model_config

var provenance : Provenance | None

var transcript : str | None

var transcript_format : TranscriptFormat | None

var transcript_source : TranscriptSource1 | None

var type : Literal['audio']

var url : pydantic.networks.AnyUrl

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class ContentFormat (*args, **kwds)

Expand source code

class ContentFormat(StrEnum):
    text_plain = 'text/plain'
    text_markdown = 'text/markdown'
    text_html = 'text/html'
    application_json = 'application/json'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var application_json

var text_html

var text_markdown

var text_plain

class Identifiers (**data: Any)

Expand source code

class Identifiers(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    apple_podcast_id: Annotated[str | None, Field(description='Apple Podcasts ID')] = None
    spotify_collection_id: Annotated[str | None, Field(description='Spotify collection ID')] = None
    podcast_guid: Annotated[str | None, Field(description='Podcast GUID (from RSS feed)')] = None
    youtube_video_id: Annotated[str | None, Field(description='YouTube video ID')] = None
    rss_url: Annotated[AnyUrl | None, Field(description='RSS feed URL')] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var apple_podcast_id : str | None

var model_config

var podcast_guid : str | None

var rss_url : pydantic.networks.AnyUrl | None

var spotify_collection_id : str | None

var youtube_video_id : str | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Metadata (**data: Any)

Expand source code

class Metadata(AdCPBaseModel):
    model_config = ConfigDict(
        extra='allow',
    )
    canonical: Annotated[AnyUrl | None, Field(description='Canonical URL')] = None
    author: Annotated[str | None, Field(description='Artifact author name')] = None
    keywords: Annotated[str | None, Field(description='Artifact keywords')] = None
    open_graph: Annotated[
        dict[str, Any] | None, Field(description='Open Graph protocol metadata')
    ] = None
    twitter_card: Annotated[dict[str, Any] | None, Field(description='Twitter Card metadata')] = (
        None
    )
    json_ld: Annotated[
        list[dict[str, Any]] | None, Field(description='JSON-LD structured data (schema.org)')
    ] = None

Base model for AdCP types with spec-compliant serialization.

Defaults to extra='ignore' so unknown fields from newer spec versions are silently dropped rather than causing validation errors. Generated types whose schemas set additionalProperties: true override this with extra='allow' in their own model_config.

Set ADCP_STRICT_VALIDATION=1 in the environment ("1", "true", "yes", "on" are accepted) to flip the default to extra='forbid'. Use this during spec upgrades to catch silently-dropped renamed fields in tests. See :func:_resolve_extra_policy.

Important

The env var is resolved once at module import time. Set it in your shell or CI environment before import adcp runs — mutating os.environ["ADCP_STRICT_VALIDATION"] after the first adcp import has no effect on already-imported model classes (they captured the policy at class-body evaluation).

Consumers who want per-model strict validation can override model_config on their subclass.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• AdCPBaseModel
• pydantic.main.BaseModel

Class variables

var author : str | None

var canonical : pydantic.networks.AnyUrl | None

var json_ld : list[dict[str, typing.Any]] | None

var keywords : str | None

var model_config

var open_graph : dict[str, typing.Any] | None

var twitter_card : dict[str, typing.Any] | None

Inherited members

• AdCPBaseModel:
  • model_dump
  • model_dump_json
  • model_summary

class Provider (*args, **kwds)

Expand source code

class Provider(StrEnum):
    gcp = 'gcp'
    aws = 'aws'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var aws

var gcp

class Role (*args, **kwds)

Expand source code

class Role(StrEnum):
    title = 'title'  # type: ignore[assignment]
    paragraph = 'paragraph'
    heading = 'heading'
    caption = 'caption'
    quote = 'quote'
    list_item = 'list_item'
    description = 'description'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var caption

var description

var heading

var list_item

var paragraph

var quote

var title

class TranscriptFormat (*args, **kwds)

Expand source code

class TranscriptFormat(StrEnum):
    text_plain = 'text/plain'
    text_markdown = 'text/markdown'
    application_json = 'application/json'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var application_json

var text_markdown

var text_plain

class TranscriptSource (*args, **kwds)

Expand source code

class TranscriptSource(StrEnum):
    original_script = 'original_script'
    subtitles = 'subtitles'
    closed_captions = 'closed_captions'
    dub = 'dub'
    generated = 'generated'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var closed_captions

var dub

var generated

var original_script

var subtitles

class TranscriptSource1 (*args, **kwds)

Expand source code

class TranscriptSource1(StrEnum):
    original_script = 'original_script'
    closed_captions = 'closed_captions'
    generated = 'generated'

Enum where members are also (and must be) strings

Ancestors

• enum.StrEnum
• builtins.str
• enum.ReprEnum
• enum.Enum

Class variables

var closed_captions

var generated

var original_script