vcon.extensions package

vcon.extensions module

vCon Extensions Module

This module provides the framework for implementing vCon extensions, including the Lawful Basis and WTF (World Transcription Format) extensions.

class vcon.extensions.ExtensionProcessor[source]

Bases: ABC

Base class for extension processors.

abstract can_process(extension_name: str) → bool[source]

Check if this processor can handle the given extension.

abstract process(vcon_dict: Dict[str, Any]) → ProcessingResult[source]

Process extension data in a vCon.

class vcon.extensions.ExtensionRegistry[source]

Bases: object

Central registry for managing vCon extensions.

check_compatibility(vcon_dict: Dict[str, Any]) → ValidationResult[source]

Check if all required extensions are supported.

get_extension(name: str) → ExtensionInfo | None[source]

Get extension information by name.

get_required_extensions(vcon_dict: Dict[str, Any]) → List[str][source]

Get list of extensions that must be supported.

initialize_default_extensions()[source]

Initialize default extensions.

is_extension_registered(name: str) → bool[source]

Check if an extension is registered.

list_extensions() → List[str][source]

List all registered extension names.

process_extensions(vcon_dict: Dict[str, Any]) → Dict[str, ProcessingResult][source]

Process all extensions in a vCon.

register_extension(extension_info: ExtensionInfo) → None[source]

Register a new extension.

validate_attachment(attachment: Dict[str, Any]) → ValidationResult[source]

Validate an extension attachment.

validate_extension(name: str, vcon_dict: Dict[str, Any]) → ValidationResult[source]

Validate an extension in a vCon.

class vcon.extensions.ExtensionType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

Types of vCon extensions.

COMPATIBLE = 'compatible'
EXPERIMENTAL = 'experimental'
INCOMPATIBLE = 'incompatible'
class vcon.extensions.ExtensionValidator[source]

Bases: ABC

Base class for extension validators.

abstract validate_attachment(attachment: Dict[str, Any]) → ValidationResult[source]

Validate an extension attachment.

abstract validate_extension_usage(vcon_dict: Dict[str, Any]) → ValidationResult[source]

Validate extension usage in a vCon.

class vcon.extensions.LawfulBasisExtension[source]

Bases: object

Main class for the lawful basis extension.

check_permission(vcon_dict: Dict[str, Any], purpose: str, party_index: int = None) → bool[source]

Check if permission is granted for a specific purpose.

create_lawful_basis_attachment(lawful_basis: str, expiration: str, purpose_grants: list, **kwargs) → Dict[str, Any][source]

Create a lawful basis attachment dictionary.

get_extension_info() → ExtensionInfo[source]

Get extension information.

validate_lawful_basis_attachment(attachment: Dict[str, Any]) → bool[source]

Validate a lawful basis attachment.

class vcon.extensions.WTFExtension[source]

Bases: object

Main class for the WTF extension.

analyze_transcription(attachment: Dict[str, Any]) → Dict[str, Any][source]

Perform analysis on a WTF transcription.

compare_transcriptions(attachments: List[Dict[str, Any]]) → Dict[str, Any][source]

Compare multiple transcriptions.

convert_from_provider(provider_data: Dict[str, Any], provider: str) → Dict[str, Any][source]

Convert provider-specific data to WTF attachment.

create_wtf_attachment(transcript: Dict[str, Any], segments: List[Dict[str, Any]], metadata: Dict[str, Any], **kwargs) → Dict[str, Any][source]

Create a WTF transcription attachment dictionary.

export_transcription(attachment: Dict[str, Any], format: str = 'srt') → str[source]

Export transcription in specified format.

get_extension_info() → ExtensionInfo[source]

Get extension information.

validate_wtf_attachment(attachment: Dict[str, Any]) → bool[source]

Validate a WTF transcription attachment.

vcon.extensions.get_extension_registry() → ExtensionRegistry[source]

Get the global extension registry.

vcon.extensions.base module

Base classes for vCon extensions.

This module provides the foundational classes and interfaces for implementing vCon extensions according to the IETF draft specifications.

class vcon.extensions.base.ExtensionAttachment(attachment_purpose: str, body: Dict[str, Any], start: str | datetime | None = None, party: int | None = None, dialog: int | None = None, encoding: str = 'json', meta: Dict[str, Any] | None = None)[source]

Bases: object

Base class for extension attachments.

classmethod from_dict(data: Dict[str, Any]) → ExtensionAttachment[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.base.ExtensionInfo(name: str, extension_type: ExtensionType, version: str, description: str, attachment_types: List[str] = None, validator: ExtensionValidator | None = None, processor: ExtensionProcessor | None = None)[source]

Bases: object

Information about a vCon extension.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.base.ExtensionProcessor[source]

Bases: ABC

Base class for extension processors.

abstract can_process(extension_name: str) → bool[source]

Check if this processor can handle the given extension.

abstract process(vcon_dict: Dict[str, Any]) → ProcessingResult[source]

Process extension data in a vCon.

class vcon.extensions.base.ExtensionType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

Types of vCon extensions.

COMPATIBLE = 'compatible'
EXPERIMENTAL = 'experimental'
INCOMPATIBLE = 'incompatible'
class vcon.extensions.base.ExtensionValidator[source]

Bases: ABC

Base class for extension validators.

abstract validate_attachment(attachment: Dict[str, Any]) → ValidationResult[source]

Validate an extension attachment.

abstract validate_extension_usage(vcon_dict: Dict[str, Any]) → ValidationResult[source]

Validate extension usage in a vCon.

class vcon.extensions.base.ProcessingResult(success: bool, data: Dict[str, Any] = None, errors: List[str] = None)[source]

Bases: object

Result of extension processing.

add_error(error: str)[source]

Add a processing error.

class vcon.extensions.base.ValidationResult(is_valid: bool, errors: List[str] = None, warnings: List[str] = None)[source]

Bases: object

Result of extension validation.

add_error(error: str)[source]

Add a validation error.

add_warning(warning: str)[source]

Add a validation warning.

vcon.extensions.registry module

Extension registry for managing vCon extensions.

This module provides a centralized registry for managing vCon extensions, including registration, validation, and processing capabilities.

class vcon.extensions.registry.ExtensionRegistry[source]

Bases: object

Central registry for managing vCon extensions.

check_compatibility(vcon_dict: Dict[str, Any]) → ValidationResult[source]

Check if all required extensions are supported.

get_extension(name: str) → ExtensionInfo | None[source]

Get extension information by name.

get_required_extensions(vcon_dict: Dict[str, Any]) → List[str][source]

Get list of extensions that must be supported.

initialize_default_extensions()[source]

Initialize default extensions.

is_extension_registered(name: str) → bool[source]

Check if an extension is registered.

list_extensions() → List[str][source]

List all registered extension names.

process_extensions(vcon_dict: Dict[str, Any]) → Dict[str, ProcessingResult][source]

Process all extensions in a vCon.

register_extension(extension_info: ExtensionInfo) → None[source]

Register a new extension.

validate_attachment(attachment: Dict[str, Any]) → ValidationResult[source]

Validate an extension attachment.

validate_extension(name: str, vcon_dict: Dict[str, Any]) → ValidationResult[source]

Validate an extension in a vCon.

vcon.extensions.registry.get_extension_registry() → ExtensionRegistry[source]

Get the global extension registry.

vcon.extensions.registry.register_extension(extension_info: ExtensionInfo) → None[source]

Register an extension with the global registry.

vcon.extensions.registry.validate_attachment(attachment: Dict[str, Any]) → ValidationResult[source]

Validate an attachment using the global registry.

vcon.extensions.registry.validate_extension(name: str, vcon_dict: Dict[str, Any]) → ValidationResult[source]

Validate an extension using the global registry.

vcon.extensions.lawful_basis.attachment module

Lawful Basis Attachment Classes

This module implements the core data structures for lawful basis attachments as defined in the draft specification.

class vcon.extensions.lawful_basis.attachment.CanonicalizationMethod(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

Supported canonicalization methods.

JCS = 'jcs'
class vcon.extensions.lawful_basis.attachment.ContentHash(algorithm: HashAlgorithm | str, canonicalization: CanonicalizationMethod | str, value: str)[source]

Bases: object

Represents content integrity information.

classmethod from_dict(data: Dict[str, Any]) → ContentHash[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

validate(content: Dict[str, Any]) → bool[source]

Validate content against the hash.

class vcon.extensions.lawful_basis.attachment.HashAlgorithm(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

Supported hash algorithms for content integrity.

BLAKE2B_256 = 'blake2b-256'
SHA_256 = 'sha-256'
SHA_3_256 = 'sha-3-256'
class vcon.extensions.lawful_basis.attachment.LawfulBasisAttachment(lawful_basis: LawfulBasisType, expiration: str | datetime | None, purpose_grants: List[PurposeGrant], terms_of_service: str | None = None, status_interval: str | None = None, content_hash: ContentHash | None = None, registry: RegistryInfo | None = None, proof_mechanisms: List[ProofMechanism] | None = None, metadata: Dict[str, Any] | None = None)[source]

Bases: object

Represents a lawful basis attachment for vCon processing.

This class handles the creation, validation, and processing of lawful basis attachments according to the draft specification.

classmethod from_dict(data: Dict[str, Any]) → LawfulBasisAttachment[source]

Create from dictionary representation.

get_conditions(purpose: str) → List[str][source]

Get conditions for a specific purpose grant.

has_permission(purpose: str) → bool[source]

Check if permission is granted for a specific purpose.

is_valid() → bool[source]

Check if the lawful basis is currently valid.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

validate_content_hash() → bool[source]

Validate the content hash if present.

class vcon.extensions.lawful_basis.attachment.LawfulBasisType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

Types of lawful bases for processing personal data.

CONSENT = 'consent'
CONTRACT = 'contract'
LEGAL_OBLIGATION = 'legal_obligation'
LEGITIMATE_INTERESTS = 'legitimate_interests'
PUBLIC_TASK = 'public_task'
VITAL_INTERESTS = 'vital_interests'
class vcon.extensions.lawful_basis.attachment.ProofMechanism(proof_type: ProofType, timestamp: str | datetime, proof_data: Dict[str, Any])[source]

Bases: object

Represents a proof mechanism for lawful basis.

classmethod from_dict(data: Dict[str, Any]) → ProofMechanism[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.lawful_basis.attachment.ProofType(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

Types of proof mechanisms for lawful basis.

CRYPTOGRAPHIC_SIGNATURE = 'cryptographic_signature'
EXTERNAL_SYSTEM = 'external_system'
SIGNED_DOCUMENT = 'signed_document'
VERBAL_CONFIRMATION = 'verbal_confirmation'
class vcon.extensions.lawful_basis.attachment.PurposeGrant(purpose: str, granted: bool, granted_at: str | datetime, conditions: List[str] | None = None)[source]

Bases: object

Represents a purpose-specific permission grant.

classmethod from_dict(data: Dict[str, Any]) → PurposeGrant[source]

Create from dictionary representation.

is_expired(status_interval: str | None = None) → bool[source]

Check if the grant has expired based on status interval.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.lawful_basis.attachment.RegistryInfo(registry_type: str, url: str)[source]

Bases: object

Represents external attestation registry information.

classmethod from_dict(data: Dict[str, Any]) → RegistryInfo[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

vcon.extensions.lawful_basis.extension module

Lawful Basis Extension Implementation

This module provides the main extension class that integrates all lawful basis functionality with the vCon extension framework.

class vcon.extensions.lawful_basis.extension.LawfulBasisExtension[source]

Bases: object

Main class for the lawful basis extension.

check_permission(vcon_dict: Dict[str, Any], purpose: str, party_index: int = None) → bool[source]

Check if permission is granted for a specific purpose.

create_lawful_basis_attachment(lawful_basis: str, expiration: str, purpose_grants: list, **kwargs) → Dict[str, Any][source]

Create a lawful basis attachment dictionary.

get_extension_info() → ExtensionInfo[source]

Get extension information.

validate_lawful_basis_attachment(attachment: Dict[str, Any]) → bool[source]

Validate a lawful basis attachment.

vcon.extensions.lawful_basis.processing module

Processing for Lawful Basis Extension

This module implements processing logic for lawful basis attachments, including proof mechanism verification and permission evaluation.

class vcon.extensions.lawful_basis.processing.LawfulBasisProcessor[source]

Bases: ExtensionProcessor

Processor for lawful basis extension.

can_process(extension_name: str) → bool[source]

Check if this processor can handle the given extension.

check_permission(vcon_dict: Dict[str, Any], purpose: str, party_index: int | None = None) → ProcessingResult[source]

Check permission for a specific purpose.

process(vcon_dict: Dict[str, Any]) → ProcessingResult[source]

Process lawful basis extension in a vCon.

class vcon.extensions.lawful_basis.processing.PermissionEvaluator[source]

Bases: object

Evaluates permissions based on lawful basis attachments.

evaluate_permission(vcon_dict: Dict[str, Any], purpose: str, party_index: int | None = None) → ProcessingResult[source]

Evaluate permission for a specific purpose.

class vcon.extensions.lawful_basis.processing.ProofProcessor[source]

Bases: object

Processes different types of proof mechanisms.

process_proof(proof: ProofMechanism, vcon_dict: Dict[str, Any]) → bool[source]

Process a proof mechanism and return validation result.

vcon.extensions.lawful_basis.registry module

Registry Integration for Lawful Basis Extension

This module implements integration with external attestation registries, particularly SCITT (Supply Chain Integrity, Transparency, and Trust) services.

class vcon.extensions.lawful_basis.registry.RegistryClient(registry_url: str, auth_token: str | None = None)[source]

Bases: object

Base class for registry clients.

query_status(attestation_id: str) → Dict[str, Any][source]

Query the status of an attestation.

submit_attestation(lawful_basis: LawfulBasisAttachment) → str[source]

Submit a lawful basis attestation to the registry.

verify_receipt(receipt_id: str) → ValidationResult[source]

Verify a registry receipt.

class vcon.extensions.lawful_basis.registry.RegistryManager[source]

Bases: object

Manages multiple registry clients.

query_registry_status(attestation_id: str, registry_type: str) → Dict[str, Any][source]

Query attestation status in a specific registry.

register_client(registry_type: str, client: RegistryClient)[source]

Register a registry client.

submit_to_registry(lawful_basis: LawfulBasisAttachment, registry_type: str) → str[source]

Submit lawful basis to a specific registry.

verify_registry_status(attestation_id: str, registry_type: str) → ValidationResult[source]

Verify attestation status in a specific registry.

class vcon.extensions.lawful_basis.registry.RegistryValidator[source]

Bases: object

Validates registry responses and data.

static validate_attestation_status(status: Dict[str, Any]) → ValidationResult[source]

Validate attestation status data.

static validate_registry_metadata(metadata: Dict[str, Any]) → ValidationResult[source]

Validate registry metadata.

static validate_scitt_receipt(receipt: Dict[str, Any]) → ValidationResult[source]

Validate a SCITT receipt structure.

class vcon.extensions.lawful_basis.registry.SCITTRegistryClient(registry_url: str, auth_token: str | None = None)[source]

Bases: RegistryClient

Client for SCITT (Supply Chain Integrity, Transparency, and Trust) registries.

query_status(attestation_id: str) → Dict[str, Any][source]

Query the status of an attestation in the SCITT registry.

submit_attestation(lawful_basis: LawfulBasisAttachment) → str[source]

Submit a lawful basis attestation to the SCITT registry.

update_attestation(attestation_id: str, updates: Dict[str, Any]) → bool[source]

Update an existing attestation.

verify_receipt(receipt_id: str) → ValidationResult[source]

Verify a SCITT registry receipt.

vcon.extensions.lawful_basis.validation module

Validation for Lawful Basis Extension

This module implements validation logic for lawful basis attachments and extension usage according to the draft specification.

exception vcon.extensions.lawful_basis.validation.ContentHashMismatchError[source]

Bases: LawfulBasisValidationError

Raised when content hash validation fails.

exception vcon.extensions.lawful_basis.validation.LawfulBasisExpiredError[source]

Bases: LawfulBasisValidationError

Raised when lawful basis has expired.

exception vcon.extensions.lawful_basis.validation.LawfulBasisMissingError[source]

Bases: LawfulBasisValidationError

Raised when no valid lawful basis is found.

exception vcon.extensions.lawful_basis.validation.LawfulBasisValidationError[source]

Bases: Exception

Base exception for lawful basis validation errors.

class vcon.extensions.lawful_basis.validation.LawfulBasisValidator[source]

Bases: ExtensionValidator

Validator for lawful basis extension.

validate_attachment(attachment: Dict[str, Any]) → ValidationResult[source]

Validate a lawful basis attachment.

validate_extension_usage(vcon_dict: Dict[str, Any]) → ValidationResult[source]

Validate lawful basis extension usage in a vCon.

validate_lawful_basis_attachment(attachment: LawfulBasisAttachment) → ValidationResult[source]

Validate a LawfulBasisAttachment object.

exception vcon.extensions.lawful_basis.validation.PermissionDeniedError[source]

Bases: LawfulBasisValidationError

Raised when permission is explicitly denied.

exception vcon.extensions.lawful_basis.validation.ProofVerificationError[source]

Bases: LawfulBasisValidationError

Raised when proof mechanisms fail validation.

vcon.extensions.wtf.attachment module

WTF Attachment Classes

This module implements the core data structures for WTF (World Transcription Format) attachments as defined in the draft specification.

class vcon.extensions.wtf.attachment.Metadata(created_at: str, processed_at: str, provider: str, model: str, processing_time: float | None = None, audio: Dict[str, Any] | None = None, options: Dict[str, Any] | None = None)[source]

Bases: object

Represents processing and source metadata.

classmethod from_dict(data: Dict[str, Any]) → Metadata[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.wtf.attachment.Quality(audio_quality: str, background_noise: float, multiple_speakers: bool, overlapping_speech: bool, silence_ratio: float, average_confidence: float, low_confidence_words: int, processing_warnings: List[str])[source]

Bases: object

Represents quality metrics for the transcription.

classmethod from_dict(data: Dict[str, Any]) → Quality[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.wtf.attachment.Segment(id: int, start: float, end: float, text: str, confidence: float, speaker: int | str | None = None, words: List[int] | None = None)[source]

Bases: object

Represents a logical chunk of transcribed content.

classmethod from_dict(data: Dict[str, Any]) → Segment[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.wtf.attachment.Speaker(id: int | str, label: str, segments: List[int], total_time: float, confidence: float)[source]

Bases: object

Represents speaker information for diarization.

classmethod from_dict(data: Dict[str, Any]) → Speaker[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.wtf.attachment.Transcript(text: str, language: str, duration: float, confidence: float)[source]

Bases: object

Represents the high-level transcript information.

classmethod from_dict(data: Dict[str, Any]) → Transcript[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.wtf.attachment.WTFAttachment(transcript: Transcript, segments: List[Segment], metadata: Metadata, words: List[Word] | None = None, speakers: Dict[str, Speaker] | None = None, alternatives: List[Dict[str, Any]] | None = None, enrichments: Dict[str, Any] | None = None, extensions: Dict[str, Any] | None = None, quality: Quality | None = None, streaming: Dict[str, Any] | None = None)[source]

Bases: object

Represents a WTF transcription attachment.

This class handles the creation, validation, and processing of WTF transcription attachments according to the draft specification.

export_to_srt() → str[source]

Export transcription to SRT subtitle format.

export_to_vtt() → str[source]

Export transcription to WebVTT format.

extract_keywords(min_confidence: float = 0.8) → List[str][source]

Extract keywords from high-confidence words.

find_low_confidence_segments(threshold: float = 0.5) → List[Segment][source]

Find segments with confidence below threshold.

classmethod from_dict(data: Dict[str, Any]) → WTFAttachment[source]

Create from dictionary representation.

get_speaking_time() → Dict[str, float][source]

Calculate speaking time for each speaker.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

class vcon.extensions.wtf.attachment.WTFProvider(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]

Bases: Enum

Supported transcription providers.

AMAZON = 'amazon'
ASSEMBLYAI = 'assemblyai'
AZURE = 'azure'
DEEPGRAM = 'deepgram'
GOOGLE = 'google'
PARAKEET = 'parakeet'
REV_AI = 'rev.ai'
SPEECHMATICS = 'speechmatics'
WAV2VEC2 = 'wav2vec2'
WHISPER = 'whisper'
class vcon.extensions.wtf.attachment.Word(id: int, start: float, end: float, text: str, confidence: float, speaker: int | str | None = None, is_punctuation: bool | None = None)[source]

Bases: object

Represents a single word in the transcription.

classmethod from_dict(data: Dict[str, Any]) → Word[source]

Create from dictionary representation.

to_dict() → Dict[str, Any][source]

Convert to dictionary representation.

vcon.extensions.wtf.extension module

WTF Extension Implementation

This module provides the main extension class that integrates all WTF functionality with the vCon extension framework.

class vcon.extensions.wtf.extension.WTFExtension[source]

Bases: object

Main class for the WTF extension.

analyze_transcription(attachment: Dict[str, Any]) → Dict[str, Any][source]

Perform analysis on a WTF transcription.

compare_transcriptions(attachments: List[Dict[str, Any]]) → Dict[str, Any][source]

Compare multiple transcriptions.

convert_from_provider(provider_data: Dict[str, Any], provider: str) → Dict[str, Any][source]

Convert provider-specific data to WTF attachment.

create_wtf_attachment(transcript: Dict[str, Any], segments: List[Dict[str, Any]], metadata: Dict[str, Any], **kwargs) → Dict[str, Any][source]

Create a WTF transcription attachment dictionary.

export_transcription(attachment: Dict[str, Any], format: str = 'srt') → str[source]

Export transcription in specified format.

get_extension_info() → ExtensionInfo[source]

Get extension information.

validate_wtf_attachment(attachment: Dict[str, Any]) → bool[source]

Validate a WTF transcription attachment.

vcon.extensions.wtf.processing module

Processing for WTF Extension

This module implements processing logic for WTF transcription attachments, including provider integration and analysis capabilities.

class vcon.extensions.wtf.processing.WTFProcessor[source]

Bases: ExtensionProcessor

Processor for WTF extension.

analyze_transcription(wtf_attachment: WTFAttachment) → Dict[str, Any][source]

Perform analysis on a WTF transcription.

can_process(extension_name: str) → bool[source]

Check if this processor can handle the given extension.

compare_transcriptions(wtf_attachments: List[WTFAttachment]) → Dict[str, Any][source]

Compare multiple transcriptions.

convert_from_provider(provider_data: Dict[str, Any], provider: str) → WTFAttachment[source]

Convert provider-specific data to WTF format.

export_transcription(wtf_attachment: WTFAttachment, format: str = 'srt') → str[source]

Export transcription in specified format.

process(vcon_dict: Dict[str, Any]) → ProcessingResult[source]

Process WTF extension in a vCon.

vcon.extensions.wtf.providers module

Provider Adapters for WTF Extension

This module implements adapters for converting provider-specific transcription data to the standardized WTF format.

class vcon.extensions.wtf.providers.AssemblyAIAdapter[source]

Bases: ProviderAdapter

Adapter for AssemblyAI transcription data.

convert(assemblyai_data: Dict[str, Any]) → WTFAttachment[source]

Convert AssemblyAI data to WTF format.

class vcon.extensions.wtf.providers.DeepgramAdapter[source]

Bases: ProviderAdapter

Adapter for Deepgram transcription data.

convert(deepgram_data: Dict[str, Any]) → WTFAttachment[source]

Convert Deepgram data to WTF format.

class vcon.extensions.wtf.providers.ProviderAdapter[source]

Bases: ABC

Base class for provider adapters.

abstract convert(provider_data: Dict[str, Any]) → WTFAttachment[source]

Convert provider-specific data to WTF format.

class vcon.extensions.wtf.providers.WhisperAdapter[source]

Bases: ProviderAdapter

Adapter for OpenAI Whisper transcription data.

convert(whisper_data: Dict[str, Any]) → WTFAttachment[source]

Convert Whisper data to WTF format.

vcon.extensions.wtf.validation module

Validation for WTF Extension

This module implements validation logic for WTF transcription attachments according to the draft specification.

class vcon.extensions.wtf.validation.WTFValidator[source]

Bases: ExtensionValidator

Validator for WTF extension.

validate_attachment(attachment: Dict[str, Any]) → ValidationResult[source]

Validate a WTF transcription attachment.

validate_extension_usage(vcon_dict: Dict[str, Any]) → ValidationResult[source]

Validate WTF extension usage in a vCon.

validate_wtf_attachment(attachment: WTFAttachment) → ValidationResult[source]

Validate a WTFAttachment object.