CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/pypi-azure-ai-documentintelligence

Azure AI Document Intelligence client library for Python - a cloud service that uses machine learning to analyze text and structured data from documents

76

1.18x
Overview
Eval results
Files

model-management.mddocs/

Model Management Operations

Custom document model lifecycle management including building, composing, copying, and managing document models. Supports both template and neural training modes with comprehensive model metadata, operation tracking, and cross-resource model copying capabilities.

Capabilities

Model Building

Creates custom document models from training data using template or neural training modes. Template mode works well for consistent document layouts, while neural mode handles diverse document structures.

def begin_build_document_model(
    body: Union[BuildDocumentModelRequest, JSON, IO[bytes]],
    **kwargs: Any
) -> LROPoller[DocumentModelDetails]:
    """
    Builds a custom document model.

    Parameters:
    - body: Build request with model configuration and training data

    Returns:
    LROPoller[DocumentModelDetails]: Model building operation poller
    """

Usage example:

from azure.ai.documentintelligence.models import (
    BuildDocumentModelRequest,
    AzureBlobContentSource,
    DocumentBuildMode
)

# Build neural model for diverse layouts
build_request = BuildDocumentModelRequest(
    model_id="my-neural-model",
    description="Invoice processing model",
    build_mode=DocumentBuildMode.NEURAL,
    training_data_source=AzureBlobContentSource(
        container_url="https://account.blob.core.windows.net/training-data"
    ),
    tags={"department": "finance", "version": "1.0"}
)

poller = admin_client.begin_build_document_model(build_request)
model = poller.result()
print(f"Model {model.model_id} built successfully")

Model Composition

Combines multiple trained models into a single composed model that can intelligently route documents to the appropriate sub-model based on document characteristics.

def begin_compose_model(
    body: Union[ComposeDocumentModelRequest, JSON, IO[bytes]],
    **kwargs: Any
) -> LROPoller[DocumentModelDetails]:
    """
    Composes multiple models into a single model.

    Parameters:
    - body: Compose request with component model IDs and configuration

    Returns:  
    LROPoller[DocumentModelDetails]: Model composition operation poller
    """

Usage example:

from azure.ai.documentintelligence.models import (
    ComposeDocumentModelRequest,
    ComponentDocumentModelDetails
)

compose_request = ComposeDocumentModelRequest(
    model_id="composed-invoice-model",
    description="Multi-format invoice model",
    component_models=[
        ComponentDocumentModelDetails(model_id="invoice-template-1"),
        ComponentDocumentModelDetails(model_id="invoice-template-2"),
        ComponentDocumentModelDetails(model_id="receipt-model")
    ],
    tags={"type": "composed", "domain": "invoicing"}
)

poller = admin_client.begin_compose_model(compose_request)
composed_model = poller.result()

Model Information Retrieval

Retrieves detailed information about trained models including training statistics, field schemas, and model capabilities.

def get_model(
    model_id: str,
    **kwargs: Any
) -> DocumentModelDetails:
    """
    Gets detailed model information.

    Parameters:
    - model_id (str): Unique model identifier

    Returns:
    DocumentModelDetails: Complete model metadata and configuration
    """

def list_models(
    **kwargs: Any
) -> Iterable[DocumentModelDetails]:
    """
    Lists all custom models.

    Returns:
    Iterable[DocumentModelDetails]: Paginated model collection
    """

Model Deletion

Removes custom models from the service to free up model quotas and clean up unused models.

def delete_model(
    model_id: str,
    **kwargs: Any
) -> None:
    """
    Deletes a custom model.

    Parameters:
    - model_id (str): Model identifier to delete
    """

Model Copy Authorization

Generates authorization tokens for copying models between different Document Intelligence resources, enabling model sharing and deployment across environments.

def authorize_model_copy(
    body: Union[AuthorizeCopyRequest, JSON, IO[bytes]],
    **kwargs: Any
) -> ModelCopyAuthorization:
    """
    Generates authorization for model copy operation.

    Parameters:
    - body: Copy authorization request with target resource details

    Returns:
    ModelCopyAuthorization: Authorization token and metadata for copy operation
    """

Model Copying

Copies models between Document Intelligence resources using authorization tokens, enabling model deployment and sharing across different environments.

def begin_copy_model_to(
    model_id: str,
    body: Union[ModelCopyAuthorization, JSON, IO[bytes]],
    **kwargs: Any
) -> LROPoller[DocumentModelDetails]:
    """
    Copies model to target resource.

    Parameters:
    - model_id (str): Source model identifier
    - body: Copy authorization from target resource

    Returns:
    LROPoller[DocumentModelDetails]: Model copy operation poller
    """

Usage example:

# Step 1: Generate copy authorization on target resource
target_admin_client = DocumentIntelligenceAdministrationClient(
    endpoint="https://target-resource.cognitiveservices.azure.com/",
    credential=AzureKeyCredential("target-api-key")
)

auth_request = AuthorizeCopyRequest(
    model_id="copied-model-id",
    description="Copied invoice model"
)
copy_auth = target_admin_client.authorize_model_copy(auth_request)

# Step 2: Copy model from source resource
source_admin_client = DocumentIntelligenceAdministrationClient(
    endpoint="https://source-resource.cognitiveservices.azure.com/",
    credential=AzureKeyCredential("source-api-key")
)

poller = source_admin_client.begin_copy_model_to("source-model-id", copy_auth)
copied_model = poller.result()

Request Types

class BuildDocumentModelRequest:
    """Request to build a custom document model."""
    model_id: str
    description: Optional[str]
    build_mode: DocumentBuildMode
    training_data_source: Union[AzureBlobContentSource, AzureBlobFileListContentSource]
    test_data_source: Optional[Union[AzureBlobContentSource, AzureBlobFileListContentSource]]
    tags: Optional[Dict[str, str]]

class ComposeDocumentModelRequest:
    """Request to compose multiple models."""
    model_id: str
    description: Optional[str]
    component_models: List[ComponentDocumentModelDetails]
    tags: Optional[Dict[str, str]]

class AuthorizeCopyRequest:
    """Request to authorize model copying."""
    model_id: str
    description: Optional[str]
    tags: Optional[Dict[str, str]]

class ComponentDocumentModelDetails:
    """Component model for composition."""
    model_id: str

Response Types

class DocumentModelDetails:
    """Comprehensive model information and metadata."""
    model_id: str
    description: Optional[str]
    created_date_time: datetime
    expiration_date_time: Optional[datetime]
    api_version: str
    tags: Optional[Dict[str, str]]
    build_mode: Optional[DocumentBuildMode]
    azure_blob_source: Optional[AzureBlobContentSource]
    azure_blob_file_list_source: Optional[AzureBlobFileListContentSource]
    doc_types: Optional[Dict[str, DocumentTypeDetails]]
    warnings: Optional[List[DocumentIntelligenceWarning]]
    training_hours: Optional[int]
    base_model_id: Optional[str]

class ModelCopyAuthorization:
    """Authorization for cross-resource model copying."""
    target_resource_id: str
    target_resource_region: str
    target_model_id: str
    target_model_location: str
    access_token: str
    expiration_date_time: datetime

class DocumentTypeDetails:
    """Document type configuration within a model."""
    description: Optional[str]
    build_mode: Optional[DocumentBuildMode]
    field_schema: Optional[Dict[str, DocumentFieldSchema]]
    field_confidence: Optional[Dict[str, float]]

Content Source Types

class AzureBlobContentSource:
    """Azure Blob Storage content source."""
    container_url: str
    prefix: Optional[str]

class AzureBlobFileListContentSource:
    """Azure Blob Storage file list source."""
    container_url: str
    file_list: str

class DocumentFieldSchema:
    """Schema definition for document fields."""
    type: DocumentFieldType
    description: Optional[str]
    example: Optional[str]
    items: Optional["DocumentFieldSchema"]
    properties: Optional[Dict[str, "DocumentFieldSchema"]]

class CustomDocumentModelsDetails:
    """Custom model quota and usage information."""
    count: int
    limit: int

Service Operations

def get_resource_details(
    **kwargs: Any
) -> DocumentIntelligenceResourceDetails:
    """
    Gets Document Intelligence resource information.

    Returns:
    DocumentIntelligenceResourceDetails: Service resource details and limits
    """

def get_operation(
    operation_id: str,
    **kwargs: Any
) -> DocumentIntelligenceOperationDetails:
    """
    Gets operation details by ID.

    Parameters:
    - operation_id (str): Long-running operation identifier

    Returns: 
    DocumentIntelligenceOperationDetails: Operation status and metadata
    """

def list_operations(
    **kwargs: Any
) -> Iterable[DocumentIntelligenceOperationDetails]:
    """
    Lists all operations.

    Returns:
    Iterable[DocumentIntelligenceOperationDetails]: Paginated operations collection
    """

class DocumentIntelligenceResourceDetails:
    """Service resource information."""
    custom_document_models: CustomDocumentModelsDetails
    custom_neural_document_model_builds: CustomDocumentModelsDetails

class DocumentIntelligenceOperationDetails:
    """Base operation details with status and timing."""
    operation_id: str
    status: DocumentIntelligenceOperationStatus
    percent_completed: Optional[int]
    created_date_time: datetime
    last_updated_date_time: datetime
    kind: OperationKind
    resource_location: str
    api_version: Optional[str]
    tags: Optional[Dict[str, str]]
    error: Optional[DocumentIntelligenceError]

Install with Tessl CLI

npx tessl i tessl/pypi-azure-ai-documentintelligence

docs

async-clients.md

classifier-management.md

document-analysis.md

index.md

model-management.md

models-and-types.md

tile.json