cribl-control-plane 0.1.1rc6__py3-none-any.whl → 0.2.0__py3-none-any.whl

cribl_control_plane/models/input.py

@@ -66,10 +66,8 @@ from .inputwineventlogs import InputWinEventLogs, InputWinEventLogsTypedDict
 from .inputwiz import InputWiz, InputWizTypedDict
 from .inputwizwebhook import InputWizWebhook, InputWizWebhookTypedDict
 from .inputzscalerhec import InputZscalerHec, InputZscalerHecTypedDict
-from cribl_control_plane.utils import get_discriminator
-from pydantic import Discriminator, Tag
 from typing import Union
-from typing_extensions import Annotated, TypeAliasType
+from typing_extensions import TypeAliasType
 
 
 InputTypedDict = TypeAliasType(
@@ -138,67 +136,67 @@ InputTypedDict = TypeAliasType(
 )
 
 
-Input = Annotated[
+Input = TypeAliasType(
+    "Input",
     Union[
-        Annotated[InputCollection, Tag("collection")],
-        Annotated[InputKafka, Tag("kafka")],
-        Annotated[InputMsk, Tag("msk")],
-        Annotated[InputHTTP, Tag("http")],
-        Annotated[InputSplunk, Tag("splunk")],
-        Annotated[InputSplunkSearch, Tag("splunk_search")],
-        Annotated[InputSplunkHec, Tag("splunk_hec")],
-        Annotated[InputAzureBlob, Tag("azure_blob")],
-        Annotated[InputElastic, Tag("elastic")],
-        Annotated[InputConfluentCloud, Tag("confluent_cloud")],
-        Annotated[InputGrafana, Tag("grafana")],
-        Annotated[InputLoki, Tag("loki")],
-        Annotated[InputPrometheusRw, Tag("prometheus_rw")],
-        Annotated[InputPrometheus, Tag("prometheus")],
-        Annotated[InputEdgePrometheus, Tag("edge_prometheus")],
-        Annotated[InputOffice365Mgmt, Tag("office365_mgmt")],
-        Annotated[InputOffice365Service, Tag("office365_service")],
-        Annotated[InputOffice365MsgTrace, Tag("office365_msg_trace")],
-        Annotated[InputEventhub, Tag("eventhub")],
-        Annotated[InputExec, Tag("exec")],
-        Annotated[InputFirehose, Tag("firehose")],
-        Annotated[InputGooglePubsub, Tag("google_pubsub")],
-        Annotated[InputCribl, Tag("cribl")],
-        Annotated[InputCriblTCP, Tag("cribl_tcp")],
-        Annotated[InputCriblHTTP, Tag("cribl_http")],
-        Annotated[InputCriblLakeHTTP, Tag("cribl_lake_http")],
-        Annotated[InputTcpjson, Tag("tcpjson")],
-        Annotated[InputSystemMetrics, Tag("system_metrics")],
-        Annotated[InputSystemState, Tag("system_state")],
-        Annotated[InputKubeMetrics, Tag("kube_metrics")],
-        Annotated[InputKubeLogs, Tag("kube_logs")],
-        Annotated[InputKubeEvents, Tag("kube_events")],
-        Annotated[InputWindowsMetrics, Tag("windows_metrics")],
-        Annotated[InputCrowdstrike, Tag("crowdstrike")],
-        Annotated[InputDatadogAgent, Tag("datadog_agent")],
-        Annotated[InputDatagen, Tag("datagen")],
-        Annotated[InputHTTPRaw, Tag("http_raw")],
-        Annotated[InputKinesis, Tag("kinesis")],
-        Annotated[InputCriblmetrics, Tag("criblmetrics")],
-        Annotated[InputMetrics, Tag("metrics")],
-        Annotated[InputS3, Tag("s3")],
-        Annotated[InputS3Inventory, Tag("s3_inventory")],
-        Annotated[InputSnmp, Tag("snmp")],
-        Annotated[InputOpenTelemetry, Tag("open_telemetry")],
-        Annotated[InputModelDrivenTelemetry, Tag("model_driven_telemetry")],
-        Annotated[InputSqs, Tag("sqs")],
-        Annotated[InputSyslog, Tag("syslog")],
-        Annotated[InputFile, Tag("file")],
-        Annotated[InputTCP, Tag("tcp")],
-        Annotated[InputAppscope, Tag("appscope")],
-        Annotated[InputWef, Tag("wef")],
-        Annotated[InputWinEventLogs, Tag("win_event_logs")],
-        Annotated[InputRawUDP, Tag("raw_udp")],
-        Annotated[InputJournalFiles, Tag("journal_files")],
-        Annotated[InputWiz, Tag("wiz")],
-        Annotated[InputWizWebhook, Tag("wiz_webhook")],
-        Annotated[InputNetflow, Tag("netflow")],
-        Annotated[InputSecurityLake, Tag("security_lake")],
-        Annotated[InputZscalerHec, Tag("zscaler_hec")],
+        InputDatagen,
+        InputKubeEvents,
+        InputCribl,
+        InputCriblmetrics,
+        InputKubeMetrics,
+        InputCollection,
+        InputSystemState,
+        InputModelDrivenTelemetry,
+        InputSystemMetrics,
+        InputWindowsMetrics,
+        InputJournalFiles,
+        InputWinEventLogs,
+        InputRawUDP,
+        InputExec,
+        InputKubeLogs,
+        InputMetrics,
+        InputSnmp,
+        InputCriblTCP,
+        InputNetflow,
+        InputTcpjson,
+        InputGooglePubsub,
+        InputOffice365Service,
+        InputWiz,
+        InputTCP,
+        InputFirehose,
+        InputCriblHTTP,
+        InputDatadogAgent,
+        InputOffice365Mgmt,
+        InputFile,
+        InputSplunk,
+        InputWef,
+        InputAppscope,
+        InputHTTPRaw,
+        InputWizWebhook,
+        InputHTTP,
+        InputCriblLakeHTTP,
+        InputAzureBlob,
+        InputSqs,
+        InputZscalerHec,
+        InputKinesis,
+        InputConfluentCloud,
+        InputEventhub,
+        InputKafka,
+        InputElastic,
+        InputOffice365MsgTrace,
+        InputSplunkHec,
+        InputLoki,
+        InputPrometheusRw,
+        InputPrometheus,
+        InputCrowdstrike,
+        InputEdgePrometheus,
+        InputOpenTelemetry,
+        InputS3,
+        InputSecurityLake,
+        InputMsk,
+        InputS3Inventory,
+        InputSplunkSearch,
+        InputSyslog,
+        InputGrafana,
     ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
+)

cribl_control_plane/models/inputappscope.py

@@ -29,18 +29,14 @@ class InputAppscopeConnection(BaseModel):
 class InputAppscopeMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputAppscopeCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputazureblob.py

@@ -29,18 +29,14 @@ class InputAzureBlobConnection(BaseModel):
 class InputAzureBlobMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputAzureBlobCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputcollection.py

@@ -29,18 +29,14 @@ class InputCollectionConnection(BaseModel):
 class InputCollectionMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputCollectionCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputconfluentcloud.py

@@ -29,18 +29,14 @@ class InputConfluentCloudConnection(BaseModel):
 class InputConfluentCloudMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputConfluentCloudCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -191,6 +187,13 @@ class InputConfluentCloudTLSSettingsClientSide(BaseModel):
     ] = None
 
 
+class InputConfluentCloudSchemaType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""The schema format used to encode and decode event data"""
+
+    AVRO = "avro"
+    JSON = "json"
+
+
 class InputConfluentCloudAuthTypedDict(TypedDict):
     r"""Credentials to use when authenticating with the schema registry using basic HTTP authentication"""
 
@@ -301,6 +304,8 @@ class InputConfluentCloudKafkaSchemaRegistryAuthenticationTypedDict(TypedDict):
     disabled: NotRequired[bool]
     schema_registry_url: NotRequired[str]
     r"""URL for accessing the Confluent Schema Registry. Example: http://localhost:8081. To connect over TLS, use https instead of http."""
+    schema_type: NotRequired[InputConfluentCloudSchemaType]
+    r"""The schema format used to encode and decode event data"""
     connection_timeout: NotRequired[float]
     r"""Maximum time to wait for a Schema Registry connection to complete successfully"""
     request_timeout: NotRequired[float]
@@ -322,6 +327,15 @@ class InputConfluentCloudKafkaSchemaRegistryAuthentication(BaseModel):
     ] = "http://localhost:8081"
     r"""URL for accessing the Confluent Schema Registry. Example: http://localhost:8081. To connect over TLS, use https instead of http."""
 
+    schema_type: Annotated[
+        Annotated[
+            Optional[InputConfluentCloudSchemaType],
+            PlainValidator(validate_open_enum(False)),
+        ],
+        pydantic.Field(alias="schemaType"),
+    ] = InputConfluentCloudSchemaType.AVRO
+    r"""The schema format used to encode and decode event data"""
+
     connection_timeout: Annotated[
         Optional[float], pydantic.Field(alias="connectionTimeout")
     ] = 30000
@@ -342,13 +356,9 @@ class InputConfluentCloudKafkaSchemaRegistryAuthentication(BaseModel):
 
 
 class InputConfluentCloudSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
-    # PLAIN
     PLAIN = "plain"
-    # SCRAM-SHA-256
     SCRAM_SHA_256 = "scram-sha-256"
-    # SCRAM-SHA-512
     SCRAM_SHA_512 = "scram-sha-512"
-    # GSSAPI/Kerberos
     KERBEROS = "kerberos"
 
 

cribl_control_plane/models/inputcribl.py

@@ -29,18 +29,14 @@ class InputCriblConnection(BaseModel):
 class InputCriblMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputCriblCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputcriblhttp.py

@@ -29,18 +29,14 @@ class InputCriblHTTPConnection(BaseModel):
 class InputCriblHTTPMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputCriblHTTPCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputcribllakehttp.py

@@ -29,18 +29,14 @@ class InputCriblLakeHTTPConnection(BaseModel):
 class InputCriblLakeHTTPMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputCriblLakeHTTPCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputcriblmetrics.py

@@ -29,18 +29,14 @@ class InputCriblmetricsConnection(BaseModel):
 class InputCriblmetricsMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputCriblmetricsCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputcribltcp.py

@@ -29,18 +29,14 @@ class InputCriblTCPConnection(BaseModel):
 class InputCriblTCPMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputCriblTCPCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputcrowdstrike.py

@@ -29,18 +29,14 @@ class InputCrowdstrikeConnection(BaseModel):
 class InputCrowdstrikeMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputCrowdstrikeCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -110,11 +106,8 @@ class InputCrowdstrikePq(BaseModel):
 class InputCrowdstrikeAuthenticationMethod(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"
 
 

cribl_control_plane/models/inputdatadogagent.py

@@ -29,18 +29,14 @@ class InputDatadogAgentConnection(BaseModel):
 class InputDatadogAgentMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputDatadogAgentCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputdatagen.py

@@ -29,18 +29,14 @@ class InputDatagenConnection(BaseModel):
 class InputDatagenMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputDatagenCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputedgeprometheus.py

@@ -29,18 +29,14 @@ class InputEdgePrometheusConnection(BaseModel):
 class InputEdgePrometheusMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputEdgePrometheusPqCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -111,15 +107,10 @@ class InputEdgePrometheusPq(BaseModel):
 class InputEdgePrometheusDiscoveryType(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Target discovery mechanism. Use static to manually enter a list of targets."""
 
-    # Static
     STATIC = "static"
-    # DNS
     DNS = "dns"
-    # AWS EC2
     EC2 = "ec2"
-    # Kubernetes Node
     K8S_NODE = "k8s-node"
-    # Kubernetes Pods
     K8S_PODS = "k8s-pods"
 
 
@@ -257,11 +248,8 @@ class InputEdgePrometheusAwsAuthenticationMethodAuthenticationMethod(
 ):
     r"""AWS authentication method. Choose Auto to use IAM roles."""
 
-    # Auto
     AUTO = "auto"
-    # Manual
     MANUAL = "manual"
-    # Secret Key pair
     SECRET = "secret"
 
 

cribl_control_plane/models/inputelastic.py

@@ -29,18 +29,14 @@ class InputElasticConnection(BaseModel):
 class InputElasticMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputElasticCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -190,24 +186,17 @@ class InputElasticTLSSettingsServerSide(BaseModel):
 
 
 class InputElasticAuthenticationType(str, Enum, metaclass=utils.OpenEnumMeta):
-    # None
     NONE = "none"
-    # Basic
     BASIC = "basic"
-    # Basic (credentials secret)
     CREDENTIALS_SECRET = "credentialsSecret"
-    # Auth Tokens
     AUTH_TOKENS = "authTokens"
 
 
 class InputElasticAPIVersion(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""The API version to use for communicating with the server"""
 
-    # 6.8.4
     SIX_DOT_8_DOT_4 = "6.8.4"
-    # 8.3.2
     EIGHT_DOT_3_DOT_2 = "8.3.2"
-    # Custom
     CUSTOM = "custom"
 
 

cribl_control_plane/models/inputeventhub.py

@@ -29,18 +29,14 @@ class InputEventhubConnection(BaseModel):
 class InputEventhubMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputEventhubCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -108,9 +104,7 @@ class InputEventhubPq(BaseModel):
 
 
 class InputEventhubSASLMechanism(str, Enum, metaclass=utils.OpenEnumMeta):
-    # PLAIN
     PLAIN = "plain"
-    # OAUTHBEARER
     OAUTHBEARER = "oauthbearer"
 
 

cribl_control_plane/models/inputexec.py

@@ -29,18 +29,14 @@ class InputExecConnection(BaseModel):
 class InputExecMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputExecCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputfile.py

@@ -29,18 +29,14 @@ class InputFileConnection(BaseModel):
 class InputFilePqMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputFileCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -110,9 +106,7 @@ class InputFilePq(BaseModel):
 class InputFileMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Choose how to discover files to monitor"""
 
-    # Auto
     AUTO = "auto"
-    # Manual
     MANUAL = "manual"
 
 

cribl_control_plane/models/inputfirehose.py

@@ -29,18 +29,14 @@ class InputFirehoseConnection(BaseModel):
 class InputFirehoseMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputFirehoseCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputgooglepubsub.py

@@ -29,18 +29,14 @@ class InputGooglePubsubConnection(BaseModel):
 class InputGooglePubsubMode(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""With Smart mode, PQ will write events to the filesystem only when it detects backpressure from the processing engine. With Always On mode, PQ will always write events directly to the queue before forwarding them to the processing engine."""
 
-    # Smart
     SMART = "smart"
-    # Always On
     ALWAYS = "always"
 
 
 class InputGooglePubsubCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -113,11 +109,8 @@ class InputGooglePubsubGoogleAuthenticationMethod(
 ):
     r"""Choose Auto to use Google Application Default Credentials (ADC), Manual to enter Google service account credentials directly, or Secret to select or create a stored secret that references Google service account credentials."""
 
-    # Auto
     AUTO = "auto"
-    # Manual
     MANUAL = "manual"
-    # Secret
     SECRET = "secret"