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

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"
 
 

cribl_control_plane/models/inputgrafana.py

@@ -29,18 +29,14 @@ class InputGrafanaConnection2(BaseModel):
 class InputGrafanaMode2(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 InputGrafanaCompression2(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -659,18 +655,14 @@ class InputGrafanaConnection1(BaseModel):
 class InputGrafanaMode1(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 InputGrafanaCompression1(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputhttp.py

@@ -29,18 +29,14 @@ class InputHTTPConnection(BaseModel):
 class InputHTTPMode(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 InputHTTPCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputhttpraw.py

@@ -29,18 +29,14 @@ class InputHTTPRawConnection(BaseModel):
 class InputHTTPRawMode(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 InputHTTPRawCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputjournalfiles.py

@@ -29,18 +29,14 @@ class InputJournalFilesConnection(BaseModel):
 class InputJournalFilesMode(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 InputJournalFilesCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputkafka.py

@@ -29,18 +29,14 @@ class InputKafkaConnection(BaseModel):
 class InputKafkaMode(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 InputKafkaCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -107,6 +103,13 @@ class InputKafkaPq(BaseModel):
     ] = None
 
 
+class InputKafkaSchemaType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""The schema format used to encode and decode event data"""
+
+    AVRO = "avro"
+    JSON = "json"
+
+
 class InputKafkaAuthTypedDict(TypedDict):
     r"""Credentials to use when authenticating with the schema registry using basic HTTP authentication"""
 
@@ -217,6 +220,8 @@ class InputKafkaKafkaSchemaRegistryAuthenticationTypedDict(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[InputKafkaSchemaType]
+    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]
@@ -236,6 +241,14 @@ class InputKafkaKafkaSchemaRegistryAuthentication(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[InputKafkaSchemaType], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="schemaType"),
+    ] = InputKafkaSchemaType.AVRO
+    r"""The schema format used to encode and decode event data"""
+
     connection_timeout: Annotated[
         Optional[float], pydantic.Field(alias="connectionTimeout")
     ] = 30000
@@ -256,13 +269,9 @@ class InputKafkaKafkaSchemaRegistryAuthentication(BaseModel):
 
 
 class InputKafkaSASLMechanism(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/inputkinesis.py

@@ -29,18 +29,14 @@ class InputKinesisConnection(BaseModel):
 class InputKinesisMode(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 InputKinesisCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -110,42 +106,31 @@ class InputKinesisPq(BaseModel):
 class ShardIteratorStart(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Location at which to start reading a shard for the first time"""
 
-    # Earliest record
     TRIM_HORIZON = "TRIM_HORIZON"
-    # Latest record
     LATEST = "LATEST"
 
 
 class InputKinesisRecordDataFormat(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Format of data inside the Kinesis Stream records. Gzip compression is automatically detected."""
 
-    # Cribl
     CRIBL = "cribl"
-    # Newline JSON
     NDJSON = "ndjson"
-    # Cloudwatch Logs
     CLOUDWATCH = "cloudwatch"
-    # Event per line
     LINE = "line"
 
 
 class ShardLoadBalancing(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""The load-balancing algorithm to use for spreading out shards across Workers and Worker Processes"""
 
-    # Consistent Hashing
     CONSISTENT_HASHING = "ConsistentHashing"
-    # Round Robin
     ROUND_ROBIN = "RoundRobin"
 
 
 class InputKinesisAuthenticationMethod(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/inputkubeevents.py

@@ -29,18 +29,14 @@ class InputKubeEventsConnection(BaseModel):
 class InputKubeEventsMode(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 InputKubeEventsCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputkubelogs.py

@@ -29,18 +29,14 @@ class InputKubeLogsConnection(BaseModel):
 class InputKubeLogsMode(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 InputKubeLogsPqCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputkubemetrics.py

@@ -29,18 +29,14 @@ class InputKubeMetricsConnection(BaseModel):
 class InputKubeMetricsMode(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 InputKubeMetricsCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputloki.py

@@ -29,18 +29,14 @@ class InputLokiConnection(BaseModel):
 class InputLokiMode(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 InputLokiCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputmetrics.py

@@ -29,18 +29,14 @@ class InputMetricsConnection(BaseModel):
 class InputMetricsMode(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 InputMetricsCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputmodeldriventelemetry.py

@@ -29,18 +29,14 @@ class InputModelDrivenTelemetryConnection(BaseModel):
 class InputModelDrivenTelemetryMode(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 InputModelDrivenTelemetryCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 

cribl_control_plane/models/inputmsk.py

@@ -29,18 +29,14 @@ class InputMskConnection(BaseModel):
 class InputMskMode(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 InputMskCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"
 
 
@@ -120,6 +116,13 @@ class InputMskMetadatum(BaseModel):
     r"""JavaScript expression to compute field's value, enclosed in quotes or backticks. (Can evaluate to a constant.)"""
 
 
+class InputMskSchemaType(str, Enum, metaclass=utils.OpenEnumMeta):
+    r"""The schema format used to encode and decode event data"""
+
+    AVRO = "avro"
+    JSON = "json"
+
+
 class InputMskAuthTypedDict(TypedDict):
     r"""Credentials to use when authenticating with the schema registry using basic HTTP authentication"""
 
@@ -230,6 +233,8 @@ class InputMskKafkaSchemaRegistryAuthenticationTypedDict(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[InputMskSchemaType]
+    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]
@@ -249,6 +254,14 @@ class InputMskKafkaSchemaRegistryAuthentication(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[InputMskSchemaType], PlainValidator(validate_open_enum(False))
+        ],
+        pydantic.Field(alias="schemaType"),
+    ] = InputMskSchemaType.AVRO
+    r"""The schema format used to encode and decode event data"""
+
     connection_timeout: Annotated[
         Optional[float], pydantic.Field(alias="connectionTimeout")
     ] = 30000
@@ -271,11 +284,8 @@ class InputMskKafkaSchemaRegistryAuthentication(BaseModel):
 class InputMskAuthenticationMethod(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/inputnetflow.py

@@ -29,18 +29,14 @@ class InputNetflowConnection(BaseModel):
 class InputNetflowMode(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 InputNetflowCompression(str, Enum, metaclass=utils.OpenEnumMeta):
     r"""Codec to use to compress the persisted data"""
 
-    # None
     NONE = "none"
-    # Gzip
     GZIP = "gzip"