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

cribl_control_plane/models/outputs3.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,100 +16,137 @@ class OutputS3Type(str, Enum):
     S3 = "s3"
 
 
-class OutputS3AuthenticationMethod(str, Enum):
+class OutputS3AuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""AWS authentication method. Choose Auto to use IAM roles."""
 
+    # Auto
     AUTO = "auto"
+    # Manual
     MANUAL = "manual"
+    # Secret Key pair
     SECRET = "secret"
 
 
-class OutputS3SignatureVersion(str, Enum):
+class OutputS3SignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Signature version to use for signing S3 requests"""
 
     V2 = "v2"
     V4 = "v4"
 
 
-class OutputS3ObjectACL(str, Enum):
+class OutputS3ObjectACL(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Object ACL to assign to uploaded objects"""
 
+    # Private
     PRIVATE = "private"
+    # Public Read Only
     PUBLIC_READ = "public-read"
+    # Public Read/Write
     PUBLIC_READ_WRITE = "public-read-write"
+    # Authenticated Read Only
     AUTHENTICATED_READ = "authenticated-read"
+    # AWS EC2 AMI Read Only
     AWS_EXEC_READ = "aws-exec-read"
+    # Bucket Owner Read Only
     BUCKET_OWNER_READ = "bucket-owner-read"
+    # Bucket Owner Full Control
     BUCKET_OWNER_FULL_CONTROL = "bucket-owner-full-control"
 
 
-class OutputS3StorageClass(str, Enum):
+class OutputS3StorageClass(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Storage class to select for uploaded objects"""
 
+    # Standard
     STANDARD = "STANDARD"
+    # Reduced Redundancy Storage
     REDUCED_REDUNDANCY = "REDUCED_REDUNDANCY"
+    # Standard, Infrequent Access
     STANDARD_IA = "STANDARD_IA"
+    # One Zone, Infrequent Access
     ONEZONE_IA = "ONEZONE_IA"
+    # Intelligent Tiering
     INTELLIGENT_TIERING = "INTELLIGENT_TIERING"
+    # Glacier Flexible Retrieval
     GLACIER = "GLACIER"
+    # Glacier Instant Retrieval
     GLACIER_IR = "GLACIER_IR"
+    # Glacier Deep Archive
     DEEP_ARCHIVE = "DEEP_ARCHIVE"
 
 
-class OutputS3ServerSideEncryptionForUploadedObjects(str, Enum):
+class OutputS3ServerSideEncryptionForUploadedObjects(
+    str, Enum, metaclass=utils.OpenEnumMeta
+):
+    # Amazon S3 Managed Key
     AES256 = "AES256"
+    # AWS KMS Managed Key
     AWS_KMS = "aws:kms"
 
 
-class OutputS3DataFormat(str, Enum):
+class OutputS3DataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format of the output data"""
 
+    # JSON
     JSON = "json"
+    # Raw
     RAW = "raw"
+    # Parquet
     PARQUET = "parquet"
 
 
-class OutputS3BackpressureBehavior(str, Enum):
+class OutputS3BackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
+    # Block
     BLOCK = "block"
+    # Drop
     DROP = "drop"
 
 
-class OutputS3DiskSpaceProtection(str, Enum):
+class OutputS3DiskSpaceProtection(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 OutputS3Compression(str, Enum):
+class OutputS3Compression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     NONE = "none"
     GZIP = "gzip"
 
 
-class OutputS3CompressionLevel(str, Enum):
+class OutputS3CompressionLevel(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 OutputS3ParquetVersion(str, Enum):
+class OutputS3ParquetVersion(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 OutputS3DataPageVersion(str, Enum):
+class OutputS3DataPageVersion(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"
 
 
@@ -121,11 +162,11 @@ class OutputS3KeyValueMetadatum(BaseModel):
 
 
 class OutputS3TypedDict(TypedDict):
+    type: OutputS3Type
     bucket: str
     r"""Name of the destination S3 bucket. Must be a JavaScript expression (which can evaluate to a constant value), enclosed in quotes or backticks. Can be evaluated only at initialization time. Example referencing a Global Variable: `myBucket-${C.vars.myVar}`"""
     id: NotRequired[str]
     r"""Unique ID for this output"""
-    type: NotRequired[OutputS3Type]
     pipeline: NotRequired[str]
     r"""Pipeline to process data before sending out to this output"""
     system_fields: NotRequired[List[str]]
@@ -161,7 +202,7 @@ class OutputS3TypedDict(TypedDict):
     add_id_to_stage_path: NotRequired[bool]
     r"""Add the Output ID value to staging location"""
     dest_path: NotRequired[str]
-    r"""Prefix to append to files before uploading. Must be a JavaScript expression (which can evaluate to a constant value), enclosed in quotes or backticks. Can be evaluated only at init time. Example referencing a Global Variable: `myKeyPrefix-${C.vars.myVar}`"""
+    r"""Prefix to prepend to files before uploading. Must be a JavaScript expression (which can evaluate to a constant value), enclosed in quotes or backticks. Can be evaluated only at init time. Example referencing a Global Variable: `myKeyPrefix-${C.vars.myVar}`"""
     object_acl: NotRequired[OutputS3ObjectACL]
     r"""Object ACL to assign to uploaded objects"""
     storage_class: NotRequired[OutputS3StorageClass]
@@ -193,6 +234,8 @@ class OutputS3TypedDict(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[OutputS3DiskSpaceProtection]
     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."""
     max_file_open_time_sec: NotRequired[float]
     r"""Maximum amount of time to write to a file. Files open for longer than this will be closed and moved to final output location."""
     max_file_idle_time_sec: NotRequired[float]
@@ -214,6 +257,8 @@ class OutputS3TypedDict(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[OutputS3ParquetVersion]
     r"""Determines which data types are supported and how they are represented"""
     parquet_data_page_version: NotRequired[OutputS3DataPageVersion]
@@ -234,6 +279,8 @@ class OutputS3TypedDict(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]
@@ -241,14 +288,14 @@ class OutputS3TypedDict(TypedDict):
 
 
 class OutputS3(BaseModel):
+    type: OutputS3Type
+
     bucket: str
     r"""Name of the destination S3 bucket. Must be a JavaScript expression (which can evaluate to a constant value), enclosed in quotes or backticks. Can be evaluated only at initialization time. Example referencing a Global Variable: `myBucket-${C.vars.myVar}`"""
 
     id: Optional[str] = None
     r"""Unique ID for this output"""
 
-    type: Optional[OutputS3Type] = None
-
     pipeline: Optional[str] = None
     r"""Pipeline to process data before sending out to this output"""
 
@@ -272,7 +319,10 @@ class OutputS3(BaseModel):
     r"""Secret key. This value can be a constant or a JavaScript expression. Example: `${C.env.SOME_SECRET}`)"""
 
     aws_authentication_method: Annotated[
-        Optional[OutputS3AuthenticationMethod],
+        Annotated[
+            Optional[OutputS3AuthenticationMethod],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="awsAuthenticationMethod"),
     ] = OutputS3AuthenticationMethod.AUTO
     r"""AWS authentication method. Choose Auto to use IAM roles."""
@@ -281,7 +331,11 @@ class OutputS3(BaseModel):
     r"""S3 service endpoint. If empty, defaults to the AWS Region-specific endpoint. Otherwise, it must point to S3-compatible endpoint."""
 
     signature_version: Annotated[
-        Optional[OutputS3SignatureVersion], pydantic.Field(alias="signatureVersion")
+        Annotated[
+            Optional[OutputS3SignatureVersion],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="signatureVersion"),
     ] = OutputS3SignatureVersion.V4
     r"""Signature version to use for signing S3 requests"""
 
@@ -326,20 +380,29 @@ class OutputS3(BaseModel):
     r"""Add the Output ID value to staging location"""
 
     dest_path: Annotated[Optional[str], pydantic.Field(alias="destPath")] = ""
-    r"""Prefix to append to files before uploading. Must be a JavaScript expression (which can evaluate to a constant value), enclosed in quotes or backticks. Can be evaluated only at init time. Example referencing a Global Variable: `myKeyPrefix-${C.vars.myVar}`"""
+    r"""Prefix to prepend to files before uploading. Must be a JavaScript expression (which can evaluate to a constant value), enclosed in quotes or backticks. Can be evaluated only at init time. Example referencing a Global Variable: `myKeyPrefix-${C.vars.myVar}`"""
 
     object_acl: Annotated[
-        Optional[OutputS3ObjectACL], pydantic.Field(alias="objectACL")
+        Annotated[
+            Optional[OutputS3ObjectACL], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="objectACL"),
     ] = OutputS3ObjectACL.PRIVATE
     r"""Object ACL to assign to uploaded objects"""
 
     storage_class: Annotated[
-        Optional[OutputS3StorageClass], pydantic.Field(alias="storageClass")
+        Annotated[
+            Optional[OutputS3StorageClass], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="storageClass"),
     ] = None
     r"""Storage class to select for uploaded objects"""
 
     server_side_encryption: Annotated[
-        Optional[OutputS3ServerSideEncryptionForUploadedObjects],
+        Annotated[
+            Optional[OutputS3ServerSideEncryptionForUploadedObjects],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="serverSideEncryption"),
     ] = None
 
@@ -356,9 +419,12 @@ class OutputS3(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[OutputS3DataFormat], pydantic.Field(alias="format")] = (
-        OutputS3DataFormat.JSON
-    )
+    format_: Annotated[
+        Annotated[
+            Optional[OutputS3DataFormat], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="format"),
+    ] = OutputS3DataFormat.JSON
     r"""Format of the output data"""
 
     base_file_name: Annotated[Optional[str], pydantic.Field(alias="baseFileName")] = (
@@ -390,7 +456,11 @@ class OutputS3(BaseModel):
     r"""Buffer size used to write to a file"""
 
     on_backpressure: Annotated[
-        Optional[OutputS3BackpressureBehavior], pydantic.Field(alias="onBackpressure")
+        Annotated[
+            Optional[OutputS3BackpressureBehavior],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="onBackpressure"),
     ] = OutputS3BackpressureBehavior.BLOCK
     r"""How to handle events when all receivers are exerting backpressure"""
 
@@ -400,11 +470,19 @@ class OutputS3(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[OutputS3DiskSpaceProtection],
+        Annotated[
+            Optional[OutputS3DiskSpaceProtection],
+            PlainValidator(validate_open_enum(False)),
+        ],
         pydantic.Field(alias="onDiskFullBackpressure"),
     ] = OutputS3DiskSpaceProtection.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."""
+
     max_file_open_time_sec: Annotated[
         Optional[float], pydantic.Field(alias="maxFileOpenTimeSec")
     ] = 300
@@ -438,11 +516,17 @@ class OutputS3(BaseModel):
     aws_secret: Annotated[Optional[str], pydantic.Field(alias="awsSecret")] = None
     r"""Select or create a stored secret that references your access key and secret key"""
 
-    compress: Optional[OutputS3Compression] = OutputS3Compression.GZIP
+    compress: Annotated[
+        Optional[OutputS3Compression], PlainValidator(validate_open_enum(False))
+    ] = OutputS3Compression.GZIP
     r"""Data compression format to apply to HTTP content before it is delivered"""
 
     compression_level: Annotated[
-        Optional[OutputS3CompressionLevel], pydantic.Field(alias="compressionLevel")
+        Annotated[
+            Optional[OutputS3CompressionLevel],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="compressionLevel"),
     ] = OutputS3CompressionLevel.BEST_SPEED
     r"""Compression level to apply before moving files to final destination"""
 
@@ -451,13 +535,23 @@ class OutputS3(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[OutputS3ParquetVersion], pydantic.Field(alias="parquetVersion")
+        Annotated[
+            Optional[OutputS3ParquetVersion], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="parquetVersion"),
     ] = OutputS3ParquetVersion.PARQUET_2_6
     r"""Determines which data types are supported and how they are represented"""
 
     parquet_data_page_version: Annotated[
-        Optional[OutputS3DataPageVersion],
+        Annotated[
+            Optional[OutputS3DataPageVersion], PlainValidator(validate_open_enum(False))
+        ],
         pydantic.Field(alias="parquetDataPageVersion"),
     ] = OutputS3DataPageVersion.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."""
@@ -503,6 +597,11 @@ class OutputS3(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"
@@ -510,3 +609,111 @@ class OutputS3(BaseModel):
 
     max_retry_num: Annotated[Optional[float], pydantic.Field(alias="maxRetryNum")] = 20
     r"""The maximum number of times a file will attempt to move to its final destination before being dead-lettered"""
+
+    @field_serializer("aws_authentication_method")
+    def serialize_aws_authentication_method(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3AuthenticationMethod(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("signature_version")
+    def serialize_signature_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3SignatureVersion(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("object_acl")
+    def serialize_object_acl(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3ObjectACL(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("storage_class")
+    def serialize_storage_class(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3StorageClass(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("server_side_encryption")
+    def serialize_server_side_encryption(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3ServerSideEncryptionForUploadedObjects(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("format_")
+    def serialize_format_(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3DataFormat(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("on_backpressure")
+    def serialize_on_backpressure(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3BackpressureBehavior(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.OutputS3DiskSpaceProtection(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compress")
+    def serialize_compress(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3Compression(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("compression_level")
+    def serialize_compression_level(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3CompressionLevel(value)
+            except ValueError:
+                return value
+        return value
+
+    @field_serializer("parquet_version")
+    def serialize_parquet_version(self, value):
+        if isinstance(value, str):
+            try:
+                return models.OutputS3ParquetVersion(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.OutputS3DataPageVersion(value)
+            except ValueError:
+                return value
+        return value