nv-ingest-api 2025.4.15.dev20250415__py3-none-any.whl → 2025.4.17.dev20250417__py3-none-any.whl

nv_ingest_api/internal/schemas/extract/extract_table_schema.py

@@ -0,0 +1,129 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+import logging
+from typing import Optional
+from typing import Tuple
+
+from pydantic import field_validator, model_validator, ConfigDict, BaseModel
+
+
+logger = logging.getLogger(__name__)
+
+
+class TableExtractorConfigSchema(BaseModel):
+    """
+    Configuration schema for the table extraction stage settings.
+
+    Parameters
+    ----------
+    auth_token : Optional[str], default=None
+        Authentication token required for secure services.
+
+    paddle_endpoints : Tuple[Optional[str], Optional[str]], default=(None, None)
+        A tuple containing the gRPC and HTTP services for the paddle endpoint.
+        Either the gRPC or HTTP service can be empty, but not both.
+
+    Methods
+    -------
+    validate_endpoints(values)
+        Validates that at least one of the gRPC or HTTP services is provided for the yolox endpoint.
+
+    Raises
+    ------
+    ValueError
+        If both gRPC and HTTP services are empty for the yolox endpoint.
+
+    Config
+    ------
+    extra : str
+        Pydantic config option to forbid extra fields.
+    """
+
+    auth_token: Optional[str] = None
+
+    yolox_endpoints: Tuple[Optional[str], Optional[str]] = (None, None)
+    yolox_infer_protocol: str = ""
+
+    paddle_endpoints: Tuple[Optional[str], Optional[str]] = (None, None)
+    paddle_infer_protocol: str = ""
+
+    nim_batch_size: int = 2
+    workers_per_progress_engine: int = 5
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_endpoints(cls, values):
+        """
+        Validates the gRPC and HTTP services for the yolox endpoint.
+
+        Parameters
+        ----------
+        values : dict
+            Dictionary containing the values of the attributes for the class.
+
+        Returns
+        -------
+        dict
+            The validated dictionary of values.
+
+        Raises
+        ------
+        ValueError
+            If both gRPC and HTTP services are empty for the yolox endpoint.
+        """
+
+        def clean_service(service):
+            """Set service to None if it's an empty string or contains only spaces or quotes."""
+            if service is None or not service.strip() or service.strip(" \"'") == "":
+                return None
+            return service
+
+        for endpoint_name in ["yolox_endpoints", "paddle_endpoints"]:
+            grpc_service, http_service = values.get(endpoint_name, (None, None))
+            grpc_service = clean_service(grpc_service)
+            http_service = clean_service(http_service)
+
+            if not grpc_service and not http_service:
+                raise ValueError(f"Both gRPC and HTTP services cannot be empty for {endpoint_name}.")
+
+            values[endpoint_name] = (grpc_service, http_service)
+
+        return values
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class TableExtractorSchema(BaseModel):
+    """
+    Configuration schema for the table extraction processing settings.
+
+    Parameters
+    ----------
+    max_queue_size : int, default=1
+        The maximum number of items allowed in the processing queue.
+
+    n_workers : int, default=2
+        The number of worker threads to use for processing.
+
+    raise_on_failure : bool, default=False
+        A flag indicating whether to raise an exception if a failure occurs during table extraction.
+
+    stage_config : Optional[TableExtractorConfigSchema], default=None
+        Configuration for the table extraction stage, including yolox service endpoints.
+    """
+
+    max_queue_size: int = 1
+    n_workers: int = 2
+    raise_on_failure: bool = False
+
+    @field_validator("max_queue_size", "n_workers")
+    def check_positive(cls, v, field):
+        if v <= 0:
+            raise ValueError(f"{field.field_name} must be greater than 10.")
+        return v
+
+    endpoint_config: Optional[TableExtractorConfigSchema] = None
+    model_config = ConfigDict(extra="forbid")

nv_ingest_api/internal/schemas/message_brokers/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0

nv_ingest_api/internal/schemas/message_brokers/message_broker_client_schema.py

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+from typing import Optional, Literal
+
+from pydantic import Field, BaseModel
+from typing_extensions import Annotated
+
+
+class MessageBrokerClientSchema(BaseModel):
+    host: str = "redis"
+    port: Annotated[int, Field(gt=0, lt=65536)] = 6379
+
+    # Update this for new broker types
+    client_type: Literal["redis", "simple"] = "redis"  # Restrict to 'redis' or 'simple'
+
+    broker_params: Optional[dict] = Field(default_factory=dict)
+
+    connection_timeout: Optional[Annotated[int, Field(ge=0)]] = 300
+    max_backoff: Optional[Annotated[int, Field(ge=0)]] = 300
+    max_retries: Optional[Annotated[int, Field(ge=0)]] = 0

nv_ingest_api/internal/schemas/message_brokers/request_schema.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+import logging
+from typing import Optional
+
+from pydantic import ConfigDict, BaseModel
+from pydantic import Field
+
+logger = logging.getLogger(__name__)
+
+
+# Define schemas for request validation
+class PushRequestSchema(BaseModel):
+    command: str
+    queue_name: str = Field(..., min_length=1)
+    message: str = Field(..., min_length=1)
+    timeout: Optional[float] = 100  # Optional timeout for blocking push
+    model_config = ConfigDict(extra="forbid")
+
+
+class PopRequestSchema(BaseModel):
+    command: str
+    queue_name: str = Field(..., min_length=1)
+    timeout: Optional[float] = 100  # Optional timeout for blocking pop
+    model_config = ConfigDict(extra="forbid")
+
+
+class SizeRequestSchema(BaseModel):
+    command: str
+    queue_name: str = Field(..., min_length=1)
+    model_config = ConfigDict(extra="forbid")

nv_ingest_api/internal/schemas/message_brokers/response_schema.py

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+# NOTE: This code is duplicated from the ingest service:
+# src/nv_ingest_client/schemas/response_schema.py
+# Eventually we should move all client wrappers for the message broker into a shared library that both the ingest
+# service and the client can use.
+
+from typing import Optional, Union
+from pydantic import BaseModel
+
+
+class ResponseSchema(BaseModel):
+    response_code: int
+    response_reason: Optional[str] = "OK"
+    response: Union[str, dict, None] = None
+    trace_id: Optional[str] = None  # Unique trace ID
+    transaction_id: Optional[str] = None  # Unique transaction ID

nv_ingest_api/internal/schemas/meta/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0

nv_ingest_api/internal/schemas/meta/base_model_noext.py

@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+from pydantic import ConfigDict, BaseModel
+
+
+# Define a base class with extra fields forbidden
+class BaseModelNoExt(BaseModel):
+    model_config = ConfigDict(extra="forbid")

nv_ingest_api/internal/schemas/meta/ingest_job_schema.py

@@ -0,0 +1,237 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from typing import Any, Dict, List, Optional, Union, Annotated
+
+from pydantic import Field, field_validator, model_validator
+
+from nv_ingest_api.internal.schemas.meta.base_model_noext import BaseModelNoExt
+from nv_ingest_api.internal.enums.common import ContentTypeEnum, TaskTypeEnum, DocumentTypeEnum
+
+# ------------------------------------------------------------------------------
+# Logging Configuration
+# ------------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# ------------------------------------------------------------------------------
+# Schemas: Common and Task-Specific
+# ------------------------------------------------------------------------------
+
+
+# Tracing Options Schema
+class TracingOptionsSchema(BaseModelNoExt):
+    trace: bool = False
+    ts_send: int
+    trace_id: Optional[str] = None
+
+
+# Ingest Task Schemas
+
+
+class IngestTaskSplitSchema(BaseModelNoExt):
+    tokenizer: Optional[str] = None
+    chunk_size: Annotated[int, Field(gt=0)] = 1024
+    chunk_overlap: Annotated[int, Field(ge=0)] = 150
+    params: dict
+
+    @field_validator("chunk_overlap")
+    def check_chunk_overlap(cls, v, values, **kwargs):
+        if v is not None and "chunk_size" in values.data and v >= values.data["chunk_size"]:
+            raise ValueError("chunk_overlap must be less than chunk_size")
+        return v
+
+
+class IngestTaskExtractSchema(BaseModelNoExt):
+    document_type: DocumentTypeEnum
+    method: str
+    params: dict
+
+    @field_validator("document_type", mode="before")
+    @classmethod
+    def case_insensitive_document_type(cls, v):
+        if isinstance(v, str):
+            v = v.lower()
+        try:
+            return DocumentTypeEnum(v)
+        except ValueError:
+            raise ValueError(f"{v} is not a valid DocumentTypeEnum value")
+
+
+class IngestTaskStoreEmbedSchema(BaseModelNoExt):
+    params: dict
+
+
+class IngestTaskStoreSchema(BaseModelNoExt):
+    structured: bool = True
+    images: bool = False
+    method: str
+    params: dict
+
+
+# Captioning: All fields are optional and override default parameters.
+class IngestTaskCaptionSchema(BaseModelNoExt):
+    api_key: Optional[str] = None
+    endpoint_url: Optional[str] = None
+    prompt: Optional[str] = None
+    model_name: Optional[str] = None
+
+
+class IngestTaskFilterParamsSchema(BaseModelNoExt):
+    min_size: int = 128
+    max_aspect_ratio: Union[float, int] = 5.0
+    min_aspect_ratio: Union[float, int] = 0.2
+    filter: bool = False
+
+
+class IngestTaskFilterSchema(BaseModelNoExt):
+    # TODO: Ensure ContentTypeEnum is imported/defined as needed.
+    content_type: ContentTypeEnum = ContentTypeEnum.IMAGE
+    params: IngestTaskFilterParamsSchema = IngestTaskFilterParamsSchema()
+
+
+class IngestTaskDedupParams(BaseModelNoExt):
+    filter: bool = False
+
+
+class IngestTaskDedupSchema(BaseModelNoExt):
+    # TODO: Ensure ContentTypeEnum is imported/defined as needed.
+    content_type: ContentTypeEnum = ContentTypeEnum.IMAGE
+    params: IngestTaskDedupParams = IngestTaskDedupParams()
+
+
+class IngestTaskEmbedSchema(BaseModelNoExt):
+    endpoint_url: Optional[str] = None
+    model_name: Optional[str] = None
+    api_key: Optional[str] = None
+    filter_errors: bool = False
+
+
+class IngestTaskVdbUploadSchema(BaseModelNoExt):
+    bulk_ingest: bool = False
+    bulk_ingest_path: Optional[str] = None
+    params: Optional[dict] = None
+    filter_errors: bool = True
+
+
+class IngestTaskAudioExtraction(BaseModelNoExt):
+    auth_token: Optional[str] = None
+    grpc_endpoint: Optional[str] = None
+    http_endpoint: Optional[str] = None
+    infer_protocol: Optional[str] = None
+    function_id: Optional[str] = None
+    use_ssl: Optional[bool] = None
+    ssl_cert: Optional[str] = None
+
+
+class IngestTaskTableExtraction(BaseModelNoExt):
+    params: dict = Field(default_factory=dict)
+
+
+class IngestTaskChartExtraction(BaseModelNoExt):
+    params: dict = Field(default_factory=dict)
+
+
+class IngestTaskInfographicExtraction(BaseModelNoExt):
+    params: dict = Field(default_factory=dict)
+
+
+class IngestTaskSchema(BaseModelNoExt):
+    type: TaskTypeEnum
+    task_properties: Union[
+        IngestTaskSplitSchema,
+        IngestTaskExtractSchema,
+        IngestTaskStoreEmbedSchema,
+        IngestTaskStoreSchema,
+        IngestTaskEmbedSchema,
+        IngestTaskCaptionSchema,
+        IngestTaskDedupSchema,
+        IngestTaskFilterSchema,
+        IngestTaskVdbUploadSchema,
+        IngestTaskAudioExtraction,
+        IngestTaskTableExtraction,
+        IngestTaskChartExtraction,
+        IngestTaskInfographicExtraction,
+    ]
+    raise_on_failure: bool = False
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_task_properties_type(cls, values):
+        task_type, task_properties = values.get("type"), values.get("task_properties", {})
+        if task_type and task_properties:
+            expected_type = {
+                TaskTypeEnum.CAPTION: IngestTaskCaptionSchema,
+                TaskTypeEnum.DEDUP: IngestTaskDedupSchema,
+                TaskTypeEnum.EMBED: IngestTaskEmbedSchema,
+                TaskTypeEnum.EXTRACT: IngestTaskExtractSchema,
+                TaskTypeEnum.FILTER: IngestTaskFilterSchema,  # Extend mapping as necessary
+                TaskTypeEnum.SPLIT: IngestTaskSplitSchema,
+                TaskTypeEnum.STORE_EMBEDDING: IngestTaskStoreEmbedSchema,
+                TaskTypeEnum.STORE: IngestTaskStoreSchema,
+                TaskTypeEnum.VDB_UPLOAD: IngestTaskVdbUploadSchema,
+                TaskTypeEnum.AUDIO_DATA_EXTRACT: IngestTaskAudioExtraction,
+                TaskTypeEnum.TABLE_DATA_EXTRACT: IngestTaskTableExtraction,
+                TaskTypeEnum.CHART_DATA_EXTRACT: IngestTaskChartExtraction,
+                TaskTypeEnum.INFOGRAPHIC_DATA_EXTRACT: IngestTaskInfographicExtraction,
+            }.get(
+                task_type
+            )  # Removed .upper()
+
+            # Validate task_properties against the expected schema.
+            validated_task_properties = expected_type(**task_properties)
+            values["task_properties"] = validated_task_properties
+        return values
+
+    @field_validator("type", mode="before")
+    @classmethod
+    def case_insensitive_task_type(cls, v):
+        if isinstance(v, str):
+            v = v.lower()
+        try:
+            return TaskTypeEnum(v)
+        except ValueError:
+            raise ValueError(f"{v} is not a valid TaskTypeEnum value")
+
+
+# ------------------------------------------------------------------------------
+# Schemas: Job Schemas
+# ------------------------------------------------------------------------------
+
+
+class JobPayloadSchema(BaseModelNoExt):
+    content: List[Union[str, bytes]]
+    source_name: List[str]
+    source_id: List[Union[str, int]]
+    document_type: List[str]
+
+
+class IngestJobSchema(BaseModelNoExt):
+    job_payload: JobPayloadSchema
+    job_id: Union[str, int]
+    tasks: List[IngestTaskSchema]
+    tracing_options: Optional[TracingOptionsSchema] = None
+
+
+# ------------------------------------------------------------------------------
+# Utility Functions
+# ------------------------------------------------------------------------------
+
+
+def validate_ingest_job(job_data: Dict[str, Any]) -> IngestJobSchema:
+    """
+    Validates a dictionary representing an ingest_job using the IngestJobSchema.
+
+    Parameters:
+    - job_data: Dictionary representing an ingest job.
+
+    Returns:
+    - IngestJobSchema: The validated ingest job.
+
+    Raises:
+    - ValidationError: If the input data does not conform to the IngestJobSchema.
+    """
+
+    return IngestJobSchema(**job_data)

nv_ingest_api/internal/schemas/meta/metadata_schema.py

@@ -0,0 +1,221 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+
+import logging
+from datetime import datetime
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Union
+
+from pydantic import field_validator, model_validator, Field
+
+from nv_ingest_api.internal.enums.common import (
+    AccessLevelEnum,
+    ContentTypeEnum,
+    TextTypeEnum,
+    LanguageEnum,
+    TableFormatEnum,
+    StatusEnum,
+    DocumentTypeEnum,
+    TaskTypeEnum,
+)
+from nv_ingest_api.internal.schemas.meta.base_model_noext import BaseModelNoExt
+from nv_ingest_api.util.converters import datetools
+
+logger = logging.getLogger(__name__)
+
+
+# Sub schemas
+class SourceMetadataSchema(BaseModelNoExt):
+    """
+    Schema for the knowledge base file from which content
+    and metadata is extracted.
+    """
+
+    source_name: str
+    source_id: str
+    source_location: str = ""
+    source_type: Union[DocumentTypeEnum, str]
+    collection_id: str = ""
+    date_created: str = datetime.now().isoformat()
+    last_modified: str = datetime.now().isoformat()
+    summary: str = ""
+    partition_id: int = -1
+    access_level: Union[AccessLevelEnum, int] = AccessLevelEnum.UNKNOWN
+
+    @field_validator("date_created", "last_modified")
+    @classmethod
+    def validate_fields(cls, field_value):
+        datetools.validate_iso8601(field_value)
+        return field_value
+
+
+class NearbyObjectsSubSchema(BaseModelNoExt):
+    """
+    Schema to hold related extracted object.
+    """
+
+    content: List[str] = Field(default_factory=list)
+    bbox: List[tuple] = Field(default_factory=list)
+    type: List[str] = Field(default_factory=list)
+
+
+class NearbyObjectsSchema(BaseModelNoExt):
+    """
+    Schema to hold types of related extracted objects.
+    """
+
+    text: NearbyObjectsSubSchema = NearbyObjectsSubSchema()
+    images: NearbyObjectsSubSchema = NearbyObjectsSubSchema()
+    structured: NearbyObjectsSubSchema = NearbyObjectsSubSchema()
+
+
+class ContentHierarchySchema(BaseModelNoExt):
+    """
+    Schema for the extracted content hierarchy.
+    """
+
+    page_count: int = -1
+    page: int = -1
+    block: int = -1
+    line: int = -1
+    span: int = -1
+    nearby_objects: NearbyObjectsSchema = NearbyObjectsSchema()
+
+
+class ContentMetadataSchema(BaseModelNoExt):
+    """
+    Data extracted from a source; generally Text or Image.
+    """
+
+    type: ContentTypeEnum
+    description: str = ""
+    page_number: int = -1
+    hierarchy: ContentHierarchySchema = ContentHierarchySchema()
+    subtype: Union[ContentTypeEnum, str] = ""
+
+
+class TextMetadataSchema(BaseModelNoExt):
+    text_type: TextTypeEnum
+    summary: str = ""
+    keywords: Union[str, List[str], Dict] = ""
+    language: LanguageEnum = "en"  # default to Unknown? Maybe do some kind of heuristic check
+    text_location: tuple = (0, 0, 0, 0)
+    text_location_max_dimensions: tuple = (0, 0, 0, 0)
+
+
+class ImageMetadataSchema(BaseModelNoExt):
+    image_type: Union[DocumentTypeEnum, str]
+    structured_image_type: ContentTypeEnum = ContentTypeEnum.NONE
+    caption: str = ""
+    text: str = ""
+    image_location: tuple = (0, 0, 0, 0)
+    image_location_max_dimensions: tuple = (0, 0)
+    uploaded_image_url: str = ""
+    width: int = 0
+    height: int = 0
+
+    @field_validator("image_type")
+    def validate_image_type(cls, v):
+        if not isinstance(v, (DocumentTypeEnum, str)):
+            raise ValueError("image_type must be a string or DocumentTypeEnum")
+        return v
+
+    @field_validator("width", "height")
+    def clamp_non_negative(cls, v, field):
+        if v < 0:
+            logger.warning(f"{field.field_name} is negative; clamping to 0. Original value: {v}")
+            return 0
+        return v
+
+
+class TableMetadataSchema(BaseModelNoExt):
+    caption: str = ""
+    table_format: TableFormatEnum
+    table_content: str = ""
+    table_content_format: Union[TableFormatEnum, str] = ""
+    table_location: tuple = (0, 0, 0, 0)
+    table_location_max_dimensions: tuple = (0, 0)
+    uploaded_image_uri: str = ""
+
+
+class ChartMetadataSchema(BaseModelNoExt):
+    caption: str = ""
+    table_format: TableFormatEnum
+    table_content: str = ""
+    table_content_format: Union[TableFormatEnum, str] = ""
+    table_location: tuple = (0, 0, 0, 0)
+    table_location_max_dimensions: tuple = (0, 0)
+    uploaded_image_uri: str = ""
+
+
+class AudioMetadataSchema(BaseModelNoExt):
+    audio_transcript: str = ""
+    audio_type: str = ""
+
+
+# TODO consider deprecating this in favor of info msg...
+class ErrorMetadataSchema(BaseModelNoExt):
+    task: TaskTypeEnum
+    status: StatusEnum
+    source_id: str = ""
+    error_msg: str
+
+
+class InfoMessageMetadataSchema(BaseModelNoExt):
+    task: TaskTypeEnum
+    status: StatusEnum
+    message: str
+    filter: bool
+
+
+# Main metadata schema
+class MetadataSchema(BaseModelNoExt):
+    content: str = ""
+    content_url: str = ""
+    embedding: Optional[List[float]] = None
+    source_metadata: Optional[SourceMetadataSchema] = None
+    content_metadata: Optional[ContentMetadataSchema] = None
+    audio_metadata: Optional[AudioMetadataSchema] = None
+    text_metadata: Optional[TextMetadataSchema] = None
+    image_metadata: Optional[ImageMetadataSchema] = None
+    table_metadata: Optional[TableMetadataSchema] = None
+    chart_metadata: Optional[ChartMetadataSchema] = None
+    error_metadata: Optional[ErrorMetadataSchema] = None
+    info_message_metadata: Optional[InfoMessageMetadataSchema] = None
+    debug_metadata: Optional[Dict[str, Any]] = None
+    raise_on_failure: bool = False
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_metadata_type(cls, values):
+        content_type = values.get("content_metadata", {}).get("type", None)
+        if content_type != ContentTypeEnum.AUDIO:
+            values["audio_metadata"] = None
+        if content_type != ContentTypeEnum.IMAGE:
+            values["image_metadata"] = None
+        if content_type != ContentTypeEnum.TEXT:
+            values["text_metadata"] = None
+        if content_type != ContentTypeEnum.STRUCTURED:
+            values["table_metadata"] = None
+        return values
+
+
+def validate_metadata(metadata: Dict[str, Any]) -> MetadataSchema:
+    """
+    Validates the given metadata dictionary against the MetadataSchema.
+
+    Parameters:
+    - metadata: A dictionary representing metadata to be validated.
+
+    Returns:
+    - An instance of MetadataSchema if validation is successful.
+
+    Raises:
+    - ValidationError: If the metadata does not conform to the schema.
+    """
+    return MetadataSchema(**metadata)

nv_ingest_api/internal/schemas/mutate/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0