cribl-control-plane 0.0.21__py3-none-any.whl → 0.4.0b23__py3-none-any.whl

cribl_control_plane/models/outputazureblob.py

@@ -1,9 +1,13 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from cribl_control_plane import models, utils
 from cribl_control_plane.types import BaseModel
+from cribl_control_plane.utils import validate_open_enum
 from enum import Enum
 import pydantic
+from pydantic import field_serializer
+from pydantic.functional_validators import PlainValidator
 from typing import List, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -12,70 +16,90 @@ class OutputAzureBlobType(str, Enum):
     AZURE_BLOB = "azure_blob"
 
 
-class OutputAzureBlobDataFormat(str, Enum):
+class OutputAzureBlobDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format of the output data"""
 
+    # JSON
     JSON = "json"
+    # Raw
     RAW = "raw"
+    # Parquet
     PARQUET = "parquet"
 
 
-class OutputAzureBlobBackpressureBehavior(str, Enum):
+class OutputAzureBlobBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
+    # Block
     BLOCK = "block"
+    # Drop
     DROP = "drop"
 
 
-class OutputAzureBlobDiskSpaceProtection(str, Enum):
+class OutputAzureBlobDiskSpaceProtection(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
+    # Block
     BLOCK = "block"
+    # Drop
     DROP = "drop"
 
 
-class OutputAzureBlobAuthenticationMethod(str, Enum):
+class OutputAzureBlobAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     MANUAL = "manual"
     SECRET = "secret"
     CLIENT_SECRET = "clientSecret"
     CLIENT_CERT = "clientCert"
 
 
-class BlobAccessTier(str, Enum):
+class BlobAccessTier(str, Enum, metaclass=utils.OpenEnumMeta):
+    # Default account access tier
     INFERRED = "Inferred"
+    # Hot tier
     HOT = "Hot"
+    # Cool tier
     COOL = "Cool"
+    # Cold tier
     COLD = "Cold"
+    # Archive tier
     ARCHIVE = "Archive"
 
 
-class OutputAzureBlobCompression(str, Enum):
+class OutputAzureBlobCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputAzureBlobCompressionLevel(str, Enum):
+class OutputAzureBlobCompressionLevel(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Compression level to apply before moving files to final destination"""
 
+    # Best Speed
     BEST_SPEED = "best_speed"
+    # Normal
     NORMAL = "normal"
+    # Best Compression
     BEST_COMPRESSION = "best_compression"
 
 
-class OutputAzureBlobParquetVersion(str, Enum):
+class OutputAzureBlobParquetVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Determines which data types are supported and how they are represented"""
 
+    # 1.0
     PARQUET_1_0 = "PARQUET_1_0"
+    # 2.4
     PARQUET_2_4 = "PARQUET_2_4"
+    # 2.6
     PARQUET_2_6 = "PARQUET_2_6"
 
 
-class OutputAzureBlobDataPageVersion(str, Enum):
+class OutputAzureBlobDataPageVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Serialization format of data pages. Note that some reader implementations use Data page V2's attributes to work more efficiently, while others ignore it."""
 
+    # V1
     DATA_PAGE_V1 = "DATA_PAGE_V1"
+    # V2
     DATA_PAGE_V2 = "DATA_PAGE_V2"
 
 
@@ -101,11 +125,11 @@ class OutputAzureBlobCertificate(BaseModel):
 
 
 class OutputAzureBlobTypedDict(TypedDict):
+    type: OutputAzureBlobType
     container_name: str
     r"""The Azure Blob Storage container name. Name can include only lowercase letters, numbers, and hyphens. For dynamic container names, enter a JavaScript expression within quotes or backticks, to be evaluated at initialization. The expression can evaluate to a constant value and can reference Global Variables, such as `myContainer-${C.env[\"CRIBL_WORKER_ID\"]}`."""
     id: NotRequired[str]
     r"""Unique ID for this output"""
-    type: NotRequired[OutputAzureBlobType]
     pipeline: NotRequired[str]
     r"""Pipeline to process data before sending out to this output"""
     system_fields: NotRequired[List[str]]
@@ -152,6 +176,8 @@ class OutputAzureBlobTypedDict(TypedDict):
     r"""If a file fails to move to its final destination after the maximum number of retries, move it to a designated directory to prevent further errors"""
     on_disk_full_backpressure: NotRequired[OutputAzureBlobDiskSpaceProtection]
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
+    force_close_on_shutdown: NotRequired[bool]
+    r"""Force all staged files to close during an orderly Node shutdown. This triggers immediate upload of in-progress data — regardless of idle time, file age, or size thresholds — to minimize data loss."""
     auth_type: NotRequired[OutputAzureBlobAuthenticationMethod]
     storage_class: NotRequired[BlobAccessTier]
     description: NotRequired[str]
@@ -161,6 +187,8 @@ class OutputAzureBlobTypedDict(TypedDict):
     r"""Compression level to apply before moving files to final destination"""
     automatic_schema: NotRequired[bool]
     r"""Automatically calculate the schema based on the events of each Parquet file generated"""
+    parquet_schema: NotRequired[str]
+    r"""To add a new schema, navigate to Processing > Knowledge > Parquet Schemas"""
     parquet_version: NotRequired[OutputAzureBlobParquetVersion]
     r"""Determines which data types are supported and how they are represented"""
     parquet_data_page_version: NotRequired[OutputAzureBlobDataPageVersion]
@@ -181,6 +209,8 @@ class OutputAzureBlobTypedDict(TypedDict):
     r"""Parquet tools can use the checksum of a Parquet page to verify data integrity"""
     empty_dir_cleanup_sec: NotRequired[float]
     r"""How frequently, in seconds, to clean up empty directories"""
+    directory_batch_size: NotRequired[float]
+    r"""Number of directories to process in each batch during cleanup of empty directories. Minimum is 10, maximum is 10000. Higher values may require more memory."""
     deadletter_path: NotRequired[str]
     r"""Storage location for files that fail to reach their final destination after maximum retries are exceeded"""
     max_retry_num: NotRequired[float]
@@ -205,14 +235,14 @@ class OutputAzureBlobTypedDict(TypedDict):
 
 
 class OutputAzureBlob(BaseModel):
+    type: OutputAzureBlobType
+
     container_name: Annotated[str, pydantic.Field(alias="containerName")]
     r"""The Azure Blob Storage container name. Name can include only lowercase letters, numbers, and hyphens. For dynamic container names, enter a JavaScript expression within quotes or backticks, to be evaluated at initialization. The expression can evaluate to a constant value and can reference Global Variables, such as `myContainer-${C.env[\"CRIBL_WORKER_ID\"]}`."""
 
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Optional[OutputAzureBlobType] = None
-
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
 
@@ -261,7 +291,11 @@ class OutputAzureBlob(BaseModel):
     r"""JavaScript expression defining how files are partitioned and organized. Default is date-based. If blank, Stream will fall back to the event's __partition field value – if present – otherwise to each location's root directory."""
 
     format_: Annotated[
-        Optional[OutputAzureBlobDataFormat], pydantic.Field(alias="format")
+        Annotated[
+            Optional[OutputAzureBlobDataFormat],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="format"),
     ] = OutputAzureBlobDataFormat.JSON
     r"""Format of the output data"""
 
@@ -304,7 +338,10 @@ class OutputAzureBlob(BaseModel):
     r"""Buffer size used to write to a file"""
 
     on_backpressure: Annotated[
-        Optional[OutputAzureBlobBackpressureBehavior],
+        Annotated[
+            Optional[OutputAzureBlobBackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onBackpressure"),
     ] = OutputAzureBlobBackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
@@ -315,26 +352,44 @@ class OutputAzureBlob(BaseModel):
     r"""If a file fails to move to its final destination after the maximum number of retries, move it to a designated directory to prevent further errors"""
 
     on_disk_full_backpressure: Annotated[
-        Optional[OutputAzureBlobDiskSpaceProtection],
+        Annotated[
+            Optional[OutputAzureBlobDiskSpaceProtection],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onDiskFullBackpressure"),
     ] = OutputAzureBlobDiskSpaceProtection.BLOCK
     r"""How to handle events when disk space is below the global 'Min free disk space' limit"""
 
+    force_close_on_shutdown: Annotated[
+        Optional[bool], pydantic.Field(alias="forceCloseOnShutdown")
+    ] = False
+    r"""Force all staged files to close during an orderly Node shutdown. This triggers immediate upload of in-progress data — regardless of idle time, file age, or size thresholds — to minimize data loss."""
+
     auth_type: Annotated[
-        Optional[OutputAzureBlobAuthenticationMethod], pydantic.Field(alias="authType")
+        Annotated[
+            Optional[OutputAzureBlobAuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="authType"),
     ] = OutputAzureBlobAuthenticationMethod.MANUAL
 
     storage_class: Annotated[
-        Optional[BlobAccessTier], pydantic.Field(alias="storageClass")
+        Annotated[Optional[BlobAccessTier], PlainValidator(validate_open_enum(False))],
+        pydantic.Field(alias="storageClass"),
     ] = BlobAccessTier.INFERRED
 
     description: Optional[str] = None
 
-    compress: Optional[OutputAzureBlobCompression] = OutputAzureBlobCompression.GZIP
+    compress: Annotated[
+        Optional[OutputAzureBlobCompression], PlainValidator(validate_open_enum(False))
+    ] = OutputAzureBlobCompression.GZIP
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     compression_level: Annotated[
-        Optional[OutputAzureBlobCompressionLevel],
+        Annotated[
+            Optional[OutputAzureBlobCompressionLevel],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="compressionLevel"),
     ] = OutputAzureBlobCompressionLevel.BEST_SPEED
     r"""Compression level to apply before moving files to final destination"""
@@ -344,13 +399,25 @@ class OutputAzureBlob(BaseModel):
     ] = False
     r"""Automatically calculate the schema based on the events of each Parquet file generated"""
 
+    parquet_schema: Annotated[Optional[str], pydantic.Field(alias="parquetSchema")] = (
+        None
+    )
+    r"""To add a new schema, navigate to Processing > Knowledge > Parquet Schemas"""
+
     parquet_version: Annotated[
-        Optional[OutputAzureBlobParquetVersion], pydantic.Field(alias="parquetVersion")
+        Annotated[
+            Optional[OutputAzureBlobParquetVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="parquetVersion"),
     ] = OutputAzureBlobParquetVersion.PARQUET_2_6
     r"""Determines which data types are supported and how they are represented"""
 
     parquet_data_page_version: Annotated[
-        Optional[OutputAzureBlobDataPageVersion],
+        Annotated[
+            Optional[OutputAzureBlobDataPageVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="parquetDataPageVersion"),
     ] = OutputAzureBlobDataPageVersion.DATA_PAGE_V2
     r"""Serialization format of data pages. Note that some reader implementations use Data page V2's attributes to work more efficiently, while others ignore it."""
@@ -396,6 +463,11 @@ class OutputAzureBlob(BaseModel):
     ] = 300
     r"""How frequently, in seconds, to clean up empty directories"""
 
+    directory_batch_size: Annotated[
+        Optional[float], pydantic.Field(alias="directoryBatchSize")
+    ] = 1000
+    r"""Number of directories to process in each batch during cleanup of empty directories. Minimum is 10, maximum is 10000. Higher values may require more memory."""
+
     deadletter_path: Annotated[
         Optional[str], pydantic.Field(alias="deadletterPath")
     ] = "$CRIBL_HOME/state/outputs/dead-letter"
@@ -437,3 +509,84 @@ class OutputAzureBlob(BaseModel):
     r"""Select or create a stored text secret"""
 
     certificate: Optional[OutputAzureBlobCertificate] = None
+
+    @field_serializer("format_")
+    def serialize_format_(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobDataFormat(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("on_backpressure")
+    def serialize_on_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobBackpressureBehavior(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("on_disk_full_backpressure")
+    def serialize_on_disk_full_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobDiskSpaceProtection(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("auth_type")
+    def serialize_auth_type(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobAuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("storage_class")
+    def serialize_storage_class(self, value):
+        if isinstance(value, str):
+            try:
+                return models.BlobAccessTier(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobCompression(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compression_level")
+    def serialize_compression_level(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobCompressionLevel(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("parquet_version")
+    def serialize_parquet_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobParquetVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("parquet_data_page_version")
+    def serialize_parquet_data_page_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputAzureBlobDataPageVersion(value)
+            except ValueError:
+                return value
+        return value