cribl-control-plane 0.2.1rc7__py3-none-any.whl → 0.3.0a1__py3-none-any.whl

cribl_control_plane/models/outputdataset.py

@@ -1,12 +1,11 @@
 """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 import 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
@@ -19,19 +18,12 @@ class OutputDatasetType(str, Enum):
 class OutputDatasetSeverity(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Default value for event severity. If the `sev` or `__severity` fields are set on an event, the first one matching will override this value."""
 
-    # 0 - finest
     FINEST = "finest"
-    # 1 - finer
     FINER = "finer"
-    # 2 - fine
     FINE = "fine"
-    # 3 - info
     INFO = "info"
-    # 4 - warning
     WARNING = "warning"
-    # 5 - error
     ERROR = "error"
-    # 6 - fatal
     FATAL = "fatal"
 
 
@@ -92,11 +84,8 @@ class OutputDatasetTimeoutRetrySettings(BaseModel):
 class DataSetSite(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""DataSet site to which events should be sent"""
 
-    # US
     US = "us"
-    # Europe
     EU = "eu"
-    # Custom
     CUSTOM = "custom"
 
 
@@ -114,22 +103,16 @@ class OutputDatasetExtraHTTPHeader(BaseModel):
 class OutputDatasetFailedRequestLoggingMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Data to log when a request fails. All headers are redacted by default, unless listed as safe headers below."""
 
-    # Payload
     PAYLOAD = "payload"
-    # Payload + Headers
     PAYLOAD_AND_HEADERS = "payloadAndHeaders"
-    # None
     NONE = "none"
 
 
 class OutputDatasetBackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
-    # Block
     BLOCK = "block"
-    # Drop
     DROP = "drop"
-    # Persistent Queue
     QUEUE = "queue"
 
 
@@ -140,35 +123,28 @@ class OutputDatasetAuthenticationMethod(str, Enum, metaclass=utils.OpenEnumMeta)
     SECRET = "secret"
 
 
-class OutputDatasetMode(str, Enum, metaclass=utils.OpenEnumMeta):
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    # Error
-    ERROR = "error"
-    # Backpressure
-    ALWAYS = "always"
-    # Always On
-    BACKPRESSURE = "backpressure"
-
-
 class OutputDatasetCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
 class OutputDatasetQueueFullBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
-    # Block
     BLOCK = "block"
-    # Drop new data
     DROP = "drop"
 
 
+class OutputDatasetMode(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
+    ERROR = "error"
+    BACKPRESSURE = "backpressure"
+    ALWAYS = "always"
+
+
 class OutputDatasetPqControlsTypedDict(TypedDict):
     pass
 
@@ -241,16 +217,6 @@ class OutputDatasetTypedDict(TypedDict):
     r"""Maximum total size of the batches waiting to be sent. If left blank, defaults to 5 times the max body size (if set). If 0, no limit is enforced."""
     description: NotRequired[str]
     custom_url: NotRequired[str]
-    pq_strict_ordering: NotRequired[bool]
-    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
-    pq_rate_per_sec: NotRequired[float]
-    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
-    pq_mode: NotRequired[OutputDatasetMode]
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-    pq_max_buffer_size: NotRequired[float]
-    r"""The maximum number of events to hold in memory before writing the events to disk"""
-    pq_max_backpressure_sec: NotRequired[float]
-    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
     pq_max_file_size: NotRequired[str]
     r"""The maximum size to store in each queue file before closing and optionally compressing (KB, MB, etc.)"""
     pq_max_size: NotRequired[str]
@@ -261,6 +227,8 @@ class OutputDatasetTypedDict(TypedDict):
     r"""Codec to use to compress the persisted data"""
     pq_on_backpressure: NotRequired[OutputDatasetQueueFullBehavior]
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
+    pq_mode: NotRequired[OutputDatasetMode]
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
     pq_controls: NotRequired[OutputDatasetPqControlsTypedDict]
     api_key: NotRequired[str]
     r"""A 'Log Write Access' API key for the DataSet account"""
@@ -419,34 +387,6 @@ class OutputDataset(BaseModel):
 
     custom_url: Annotated[Optional[str], pydantic.Field(alias="customUrl")] = None
 
-    pq_strict_ordering: Annotated[
-        Optional[bool], pydantic.Field(alias="pqStrictOrdering")
-    ] = True
-    r"""Use FIFO (first in, first out) processing. Disable to forward new events to receivers before queue is flushed."""
-
-    pq_rate_per_sec: Annotated[
-        Optional[float], pydantic.Field(alias="pqRatePerSec")
-    ] = 0
-    r"""Throttling rate (in events per second) to impose while writing to Destinations from PQ. Defaults to 0, which disables throttling."""
-
-    pq_mode: Annotated[
-        Annotated[
-            Optional[OutputDatasetMode], PlainValidator(validate_open_enum(False))
-        ],
-        pydantic.Field(alias="pqMode"),
-    ] = OutputDatasetMode.ERROR
-    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
-
-    pq_max_buffer_size: Annotated[
-        Optional[float], pydantic.Field(alias="pqMaxBufferSize")
-    ] = 42
-    r"""The maximum number of events to hold in memory before writing the events to disk"""
-
-    pq_max_backpressure_sec: Annotated[
-        Optional[float], pydantic.Field(alias="pqMaxBackpressureSec")
-    ] = 30
-    r"""How long (in seconds) to wait for backpressure to resolve before engaging the queue"""
-
     pq_max_file_size: Annotated[
         Optional[str], pydantic.Field(alias="pqMaxFileSize")
     ] = "1 MB"
@@ -478,6 +418,14 @@ class OutputDataset(BaseModel):
     ] = OutputDatasetQueueFullBehavior.BLOCK
     r"""How to handle events when the queue is exerting backpressure (full capacity or low disk). 'Block' is the same behavior as non-PQ blocking. 'Drop new data' throws away incoming data, while leaving the contents of the PQ unchanged."""
 
+    pq_mode: Annotated[
+        Annotated[
+            Optional[OutputDatasetMode], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="pqMode"),
+    ] = OutputDatasetMode.ERROR
+    r"""In Error mode, PQ writes events to the filesystem if the Destination is unavailable. In Backpressure mode, PQ writes events to the filesystem when it detects backpressure from the Destination. In Always On mode, PQ always writes events to the filesystem."""
+
     pq_controls: Annotated[
         Optional[OutputDatasetPqControls], pydantic.Field(alias="pqControls")
     ] = None
@@ -487,75 +435,3 @@ class OutputDataset(BaseModel):
 
     text_secret: Annotated[Optional[str], pydantic.Field(alias="textSecret")] = None
     r"""Select or create a stored text secret"""
-
-    @field_serializer("default_severity")
-    def serialize_default_severity(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatasetSeverity(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("site")
-    def serialize_site(self, value):
-        if isinstance(value, str):
-            try:
-                return models.DataSetSite(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("failed_request_logging_mode")
-    def serialize_failed_request_logging_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatasetFailedRequestLoggingMode(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("on_backpressure")
-    def serialize_on_backpressure(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatasetBackpressureBehavior(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("auth_type")
-    def serialize_auth_type(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatasetAuthenticationMethod(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("pq_mode")
-    def serialize_pq_mode(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatasetMode(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("pq_compress")
-    def serialize_pq_compress(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatasetCompression(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("pq_on_backpressure")
-    def serialize_pq_on_backpressure(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDatasetQueueFullBehavior(value)
-            except ValueError:
-                return value
-        return value

cribl_control_plane/models/outputdiskspool.py

@@ -1,12 +1,11 @@
 """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 import 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
@@ -88,12 +87,3 @@ class OutputDiskSpool(BaseModel):
     r"""JavaScript expression defining how files are partitioned and organized within the time-buckets. If blank, the event's __partition property is used and otherwise, events go directly into the time-bucket directory."""
 
     description: Optional[str] = None
-
-    @field_serializer("compress")
-    def serialize_compress(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDiskSpoolCompression(value)
-            except ValueError:
-                return value
-        return value

cribl_control_plane/models/outputdls3.py

@@ -1,12 +1,11 @@
 """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 import 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
@@ -19,11 +18,8 @@ class OutputDlS3Type(str, Enum):
 class OutputDlS3AuthenticationMethod(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"
 
 
@@ -37,78 +33,54 @@ class OutputDlS3SignatureVersion(str, Enum, metaclass=utils.OpenEnumMeta):
 class OutputDlS3ObjectACL(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 OutputDlS3StorageClass(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 OutputDlS3ServerSideEncryptionForUploadedObjects(
     str, Enum, metaclass=utils.OpenEnumMeta
 ):
-    # Amazon S3 Managed Key
     AES256 = "AES256"
-    # AWS KMS Managed Key
     AWS_KMS = "aws:kms"
 
 
 class OutputDlS3DataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format of the output data"""
 
-    # JSON
     JSON = "json"
-    # Raw
     RAW = "raw"
-    # Parquet
     PARQUET = "parquet"
 
 
 class OutputDlS3BackpressureBehavior(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""How to handle events when all receivers are exerting backpressure"""
 
-    # Block
     BLOCK = "block"
-    # Drop
     DROP = "drop"
 
 
 class OutputDlS3DiskSpaceProtection(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"
 
 
@@ -122,31 +94,23 @@ class OutputDlS3Compression(str, Enum, metaclass=utils.OpenEnumMeta):
 class OutputDlS3CompressionLevel(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 OutputDlS3ParquetVersion(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 OutputDlS3DataPageVersion(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"
 
 
@@ -257,8 +221,6 @@ class OutputDlS3TypedDict(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[OutputDlS3ParquetVersion]
     r"""Determines which data types are supported and how they are represented"""
     parquet_data_page_version: NotRequired[OutputDlS3DataPageVersion]
@@ -528,11 +490,6 @@ class OutputDlS3(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[
         Annotated[
             Optional[OutputDlS3ParquetVersion],
@@ -599,111 +556,3 @@ class OutputDlS3(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.OutputDlS3AuthenticationMethod(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("signature_version")
-    def serialize_signature_version(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDlS3SignatureVersion(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("object_acl")
-    def serialize_object_acl(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDlS3ObjectACL(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("storage_class")
-    def serialize_storage_class(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDlS3StorageClass(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.OutputDlS3ServerSideEncryptionForUploadedObjects(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("format_")
-    def serialize_format_(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDlS3DataFormat(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("on_backpressure")
-    def serialize_on_backpressure(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDlS3BackpressureBehavior(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.OutputDlS3DiskSpaceProtection(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("compress")
-    def serialize_compress(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDlS3Compression(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("compression_level")
-    def serialize_compression_level(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDlS3CompressionLevel(value)
-            except ValueError:
-                return value
-        return value
-
-    @field_serializer("parquet_version")
-    def serialize_parquet_version(self, value):
-        if isinstance(value, str):
-            try:
-                return models.OutputDlS3ParquetVersion(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.OutputDlS3DataPageVersion(value)
-            except ValueError:
-                return value
-        return value