ob-metaflow-extensions 1.1.175rc2__py2.py3-none-any.whl → 1.1.175rc4__py2.py3-none-any.whl

metaflow_extensions/outerbounds/plugins/__init__.py

@@ -324,7 +324,6 @@ CLIS_DESC = [
     ("nvct", ".nvct.nvct_cli.cli"),
     ("fast-bakery", ".fast_bakery.fast_bakery_cli.cli"),
     ("snowpark", ".snowpark.snowpark_cli.cli"),
-    ("app", ".apps.app_cli.cli"),
 ]
 STEP_DECORATORS_DESC = [
     ("nvidia", ".nvcf.nvcf_decorator.NvcfDecorator"),
@@ -339,7 +338,7 @@ STEP_DECORATORS_DESC = [
     ("nim", ".nim.nim_decorator.NimDecorator"),
     ("ollama", ".ollama.OllamaDecorator"),
     ("vllm", ".vllm.VLLMDecorator"),
-    ("app_deploy", ".apps.deploy_decorator.WorkstationAppDeployDecorator"),
+    ("app_deploy", ".apps.app_deploy_decorator.AppDeployDecorator"),
 ]
 
 TOGGLE_STEP_DECORATOR = [

metaflow_extensions/outerbounds/plugins/apps/app_cli.py

@@ -1,3 +0,0 @@
-from .core import app_cli as ob_apps_cli
-
-cli = ob_apps_cli.cli

metaflow_extensions/outerbounds/plugins/apps/app_deploy_decorator.py

@@ -0,0 +1,112 @@
+from metaflow.exception import MetaflowException
+from metaflow.decorators import StepDecorator
+from metaflow import current
+from .core import AppDeployer, apps
+from .core.perimeters import PerimeterExtractor
+import os
+import hashlib
+
+
+class AppDeployDecorator(StepDecorator):
+
+    """
+    MF Add To Current
+    -----------------
+    apps -> metaflow_extensions.outerbounds.plugins.apps.core.apps
+
+        @@ Returns
+        ----------
+        apps
+            The object carrying the Deployer class to deploy apps.
+    """
+
+    name = "app_deploy"
+    defaults = {}
+
+    package_url = None
+    package_sha = None
+
+    def step_init(self, flow, graph, step, decos, environment, flow_datastore, logger):
+        self.logger = logger
+        self.environment = environment
+        self.step = step
+        self.flow_datastore = flow_datastore
+
+    def _resolve_package_url_and_sha(self):
+        return os.environ.get("METAFLOW_CODE_URL", self.package_url), os.environ.get(
+            "METAFLOW_CODE_SHA", self.package_sha
+        )
+
+    def task_pre_step(
+        self,
+        step_name,
+        task_datastore,
+        metadata,
+        run_id,
+        task_id,
+        flow,
+        graph,
+        retry_count,
+        max_user_code_retries,
+        ubf_context,
+        inputs,
+    ):
+        perimeter, api_server = PerimeterExtractor.during_metaflow_execution()
+        package_url, package_sha = self._resolve_package_url_and_sha()
+        if package_url is None or package_sha is None:
+            raise MetaflowException(
+                "METAFLOW_CODE_URL or METAFLOW_CODE_SHA is not set. "
+                "Please set METAFLOW_CODE_URL and METAFLOW_CODE_SHA in your environment."
+            )
+        default_name = "-".join(current.pathspec.split("/")).lower()
+        image = os.environ.get("FASTBAKERY_IMAGE", None)
+
+        hash_key = hashlib.sha256(package_url.encode()).hexdigest()[:6]
+
+        default_name = (
+            (current.flow_name + "-" + current.step_name)[:12] + "-" + hash_key
+        ).lower()
+
+        AppDeployer._set_state(
+            perimeter,
+            api_server,
+            code_package_url=package_url,
+            code_package_key=package_sha,
+            name=default_name,
+            image=image,
+        )
+        current._update_env(
+            {
+                "apps": apps(),
+            }
+        )
+
+    def task_post_step(
+        self, step_name, flow, graph, retry_count, max_user_code_retries
+    ):
+        pass
+
+    def runtime_init(self, flow, graph, package, run_id):
+        # Set some more internal state.
+        self.flow = flow
+        self.graph = graph
+        self.package = package
+        self.run_id = run_id
+
+    def runtime_task_created(
+        self, task_datastore, task_id, split_index, input_paths, is_cloned, ubf_context
+    ):
+        # To execute the Kubernetes job, the job container needs to have
+        # access to the code package. We store the package in the datastore
+        # which the pod is able to download as part of it's entrypoint.
+        if not is_cloned:
+            self._save_package_once(self.flow_datastore, self.package)
+
+    @classmethod
+    def _save_package_once(cls, flow_datastore, package):
+        if cls.package_url is None:
+            cls.package_url, cls.package_sha = flow_datastore.save_data(
+                [package.blob], len_hint=1
+            )[0]
+            os.environ["METAFLOW_CODE_URL"] = cls.package_url
+            os.environ["METAFLOW_CODE_SHA"] = cls.package_sha

metaflow_extensions/outerbounds/plugins/apps/core/__init__.py

@@ -1 +1,10 @@
 from . import app_cli
+from . import config
+from .deployer import AppDeployer, apps
+from .config.typed_configs import (
+    ReplicaConfigDict,
+    ResourceConfigDict,
+    AuthConfigDict,
+    DependencyConfigDict,
+    PackageConfigDict,
+)

metaflow_extensions/outerbounds/plugins/apps/core/_state_machine.py

@@ -1,4 +1,24 @@
-from typing import List, Tuple, Dict, Union
+import sys
+from typing import TYPE_CHECKING, Dict, List, Tuple, Union
+
+
+# on 3.8+ use the stdlib TypedDict;
+# in TYPE_CHECKING blocks mypy/pyright still pick it up on older Pythons
+if sys.version_info >= (3, 8):
+    from typing import TypedDict
+else:
+    if TYPE_CHECKING:
+        # for the benefit of type-checkers
+        from typing import TypedDict  # noqa: F401
+    # runtime no-op TypedDict shim
+    class _TypedDictMeta(type):
+        def __new__(cls, name, bases, namespace, total=True):
+            # ignore total at runtime
+            return super().__new__(cls, name, bases, namespace)
+
+    class TypedDict(dict, metaclass=_TypedDictMeta):
+        # Runtime stand-in for typing.TypedDict on <3.8.
+        pass
 
 
 class _dagNode:
@@ -134,9 +154,6 @@ class _capsuleDeployerStateMachine:
         dot.render("state_machine", view=False)
 
 
-from typing import TypedDict
-
-
 class AccessInfo(TypedDict):
     outOfClusterURL: str
     inClusterURL: str
@@ -158,9 +175,6 @@ class WorkerStatus(TypedDict):
     version: str
 
 
-from typing import Dict, List, TypedDict
-
-
 class WorkerInfoDict(TypedDict):
     # TODO : Check if we need to account for the `Terminating` state
     pending: Dict[str, List[WorkerStatus]]
@@ -191,7 +205,7 @@ class DEPLOYMENT_READY_CONDITIONS:
     2) [all_running] Atleast min_replicas number of workers are running for the deployment to be considered ready.
         - Usecase: Operators may require that all replicas are available before traffic is routed. Needed when inference endpoints maybe under some SLA or require a larger load
     3) [fully_finished] Atleast min_replicas number of workers are running for the deployment and there are no pending or crashlooping workers from previous versions lying around.
-        - Usecase: Ensuring endpoint is fully available and no other versions are running.
+        - Usecase: Ensuring endpoint is fully available and no other versions are running or endpoint has been fully scaled down.
     4) [async] The deployment will be assumed ready as soon as the server responds with a 200.
         - Usecase: Operators may only care that the URL is minted for the deployment or the deployment eventually scales down to 0.
     """
@@ -203,7 +217,7 @@ class DEPLOYMENT_READY_CONDITIONS:
     # It doesn't imply that all the workers relating to other deployments have been torn down.
     ALL_RUNNING = "all_running"
 
-    # `FULLY_FINISHED` implies that the deployment has the minimum number of replicas and all the workers are related to the current deployment instance's version.
+    # `FULLY_FINISHED` implies Atleast min_replicas number of workers are running for the deployment and there are no pending or crashlooping workers from previous versions lying around.
     FULLY_FINISHED = "fully_finished"
 
     # `ASYNC` implies that the deployment will be assumed ready after the URL is minted and the worker statuses are not checked.
@@ -273,10 +287,13 @@ class DEPLOYMENT_READY_CONDITIONS:
                 and not capsule_status["updateInProgress"]
             )
         elif readiness_condition == cls.FULLY_FINISHED:
-            _readiness_condition_satisfied = (
-                worker_semantic_status["status"]["fully_finished"]
-                and not capsule_status["updateInProgress"]
-            )
+            # We dont wait for updateInProgress in this condition since
+            # UpdateInProgress can switch to false when users scale all replicas down to 0.
+            # So for this condition to satisfy we will only rely on the worker semantic status.
+            # ie. the thing actually tracking what is running and what is not.
+            _readiness_condition_satisfied = worker_semantic_status["status"][
+                "fully_finished"
+            ]
         elif readiness_condition == cls.ASYNC:
             # The async readiness condition is satisfied immediately after the server responds
             # with the URL.
@@ -402,6 +419,11 @@ def _capsule_worker_status_diff(
 def _capsule_worker_semantic_status(
     workers: List[WorkerStatus], version: str, min_replicas: int
 ) -> CapsuleWorkerSemanticStatus:
+    def _filter_workers_by_phase(
+        workers: List[WorkerStatus], phase: str
+    ) -> List[WorkerStatus]:
+        return [w for w in workers if w.get("phase") == phase]
+
     def _make_version_dict(
         _workers: List[WorkerStatus], phase: str
     ) -> Dict[str, List[WorkerStatus]]:
@@ -447,8 +469,12 @@ def _capsule_worker_semantic_status(
         "all_running": count_for_version(running_workers) >= min_replicas,
         "fully_finished": (
             count_for_version(running_workers) >= min_replicas
-            and len(pending_workers) == 0
-            and len(crashlooping_workers) == 0
+            # count the workers of different versions that are runnning
+            # and ensure that only the current version's workers are running.
+            and count_for_version(running_workers)
+            == len(_filter_workers_by_phase(workers, "Running"))
+            and len(_filter_workers_by_phase(workers, "Pending")) == 0
+            and len(_filter_workers_by_phase(workers, "CrashLoopBackOff")) == 0
         ),
         "current_info": {
             "pending": count_for_version(pending_workers),

metaflow_extensions/outerbounds/plugins/apps/core/app_config.py

@@ -81,14 +81,14 @@ class AppConfig:
         try:
             self._core_config.commit()
             self.config = self._core_config.to_dict()
-        except ConfigValidationFailedException as e:
-            raise AppConfigError(
-                "The configuration is invalid. \n\tException: %s" % (e.message)
-            )
         except RequiredFieldMissingException as e:
             raise AppConfigError(
                 "The configuration is missing the following required fields: %s. \n\tException: %s"
-                % (", ".join(e.field_name), e.message)
+                % (e.field_name, e.message)
+            )
+        except ConfigValidationFailedException as e:
+            raise AppConfigError(
+                "The configuration is invalid. \n\n\tException: %s" % (e.message)
             )
 
     def get(self, key: str, default: Any = None) -> Any:
@@ -141,5 +141,5 @@ class AppConfig:
         except MergingNotAllowedFieldsException as e:
             raise AppConfigError(
                 "CLI Overrides are not allowed for the following fields: %s. \n\tException: %s"
-                % (", ".join(e.field_name), e.message)
+                % (e.field_name, e.message)
             )

metaflow_extensions/outerbounds/plugins/apps/core/capsule.py

@@ -206,7 +206,7 @@ class CapsuleWorkersStateMachine:
 
 class CapsuleInput:
     @classmethod
-    def construct_exec_command(cls, commands: list[str]):
+    def construct_exec_command(cls, commands: List[str]):
         commands = ["set -eEuo pipefail"] + commands
         command_string = "\n".join(commands)
         # First constuct a base64 encoded string of the quoted command
@@ -246,7 +246,16 @@ class CapsuleInput:
         return _return
 
     @classmethod
-    def from_app_config(self, app_config: AppConfig):
+    def from_app_config(cls, app_config: AppConfig):
+        ## Replica settings
+        replicas = app_config.get_state("replicas", {})
+        fixed, _min, _max = (
+            replicas.get("fixed"),
+            replicas.get("min"),
+            replicas.get("max"),
+        )
+        if fixed is not None:
+            _min, _max = fixed, fixed
         gpu_resource = app_config.get_state("resources").get("gpu")
         resources = {}
         shared_memory = app_config.get_state("resources").get("shared_memory")
@@ -284,16 +293,16 @@ class CapsuleInput:
                 **resources,
             },
             "autoscalingConfig": {
-                "minReplicas": app_config.get_state("replicas", {}).get("min"),
-                "maxReplicas": app_config.get_state("replicas", {}).get("max"),
+                "minReplicas": _min,
+                "maxReplicas": _max,
             },
             **_scheduling_config,
             "containerStartupConfig": {
-                "entrypoint": self.construct_exec_command(
+                "entrypoint": cls.construct_exec_command(
                     app_config.get_state("commands")
                 )
             },
-            "environmentVariables": self._marshal_environment_variables(app_config),
+            "environmentVariables": cls._marshal_environment_variables(app_config),
             # "assets": [{"name": "startup-script.sh"}],
             "authConfig": {
                 "authType": app_config.get_state("auth").get("type"),
@@ -699,6 +708,13 @@ class CapsuleDeployer:
         logs = self.capsule_api.logs(self.identifier, worker_id, previous=True)
         return logs, worker_id
 
+    def _get_min_replicas(self):
+        replicas = self._app_config.get_state("replicas", {})
+        fixed, _min, _ = replicas.get("fixed"), replicas.get("min"), replicas.get("max")
+        if fixed is not None:
+            return fixed
+        return _min
+
     def wait_for_terminal_state(
         self,
     ):
@@ -708,7 +724,7 @@ class CapsuleDeployer:
             self.identifier, self.current_deployment_instance_version
         )
         # min_replicas will always be present
-        min_replicas = self._app_config.get_state("replicas", {}).get("min")
+        min_replicas = self._get_min_replicas()
         workers_state_machine = CapsuleWorkersStateMachine(
             self.identifier,
             self.current_deployment_instance_version,
@@ -724,9 +740,9 @@ class CapsuleDeployer:
             # We first need to check if someone has not upgraded the capsule under the hood and
             # the current deployment instance is invalid.
             self._backend_version_mismatch_check(
-                capsule_response, self.current_deployment_instance_version
+                capsule_response, self.current_deployment_instance_version  # type: ignore
             )
-            state_machine.add_status(capsule_response.get("status", {}))
+            state_machine.add_status(capsule_response.get("status", {}))  # type: ignore
             workers_state_machine.add_status(workers_response)
             state_machine.report_current_status(logger)
 

metaflow_extensions/outerbounds/plugins/apps/core/config/__init__.py

@@ -9,3 +9,4 @@ from .config_utils import (
     RequiredFieldMissingException,
 )
 from . import schema_export
+from .typed_configs import TypedCoreConfig

metaflow_extensions/outerbounds/plugins/apps/core/config/config_utils.py

@@ -237,8 +237,9 @@ class ConfigField:
         behavior: str = FieldBehavior.UNION,
         example=None,
         strict_types=True,
-        validation_fn: Optional[callable] = None,
+        validation_fn: Optional[Callable] = None,
         is_experimental=False,  # This property is for bookkeeping purposes and for export in schema.
+        parsing_fn: Optional[Callable] = None,
     ):
         if behavior == FieldBehavior.NOT_ALLOWED and ConfigMeta.is_instance(field_type):
             raise ValueError(
@@ -262,6 +263,19 @@ class ConfigField:
         self.name = None
         self.validation_fn = validation_fn
         self.is_experimental = is_experimental
+        self.parsing_fn = parsing_fn
+        self._qual_name_stack = []
+
+    # This function allows config fields to be made aware of the
+    # owner instance's names. Its via in the ConfigMeta classes'
+    # _set_owner_instance function. But the  _set_owner_instance gets
+    # called within the ConfigField's __set__ function
+    # (when the actual instance of the value is being set)
+    def _set_owner_name(self, owner_name: str):
+        self._qual_name_stack.append(owner_name)
+
+    def fully_qualified_name(self):
+        return ".".join(self._qual_name_stack + [self.name])
 
     def __set_name__(self, owner, name):
         self.name = name
@@ -274,10 +288,23 @@ class ConfigField:
         return instance.__dict__.get(self.name)
 
     def __set__(self, instance, value):
-        # TODO: handle this execption at top level if necessary.
-        if value is not None and self.strict_types:
+
+        if self.parsing_fn:
+            value = self.parsing_fn(value)
+
+        # TODO: handle this exception at top level if necessary.
+        if value is not None and self.strict_types and self.field_type is not None:
             if not isinstance(value, self.field_type):
-                raise ValueError(f"Value {value} is not of type {self.field_type}")
+                raise ValueError(
+                    f"Value {value} is not of type {self.field_type} for the field {self.name}"
+                )
+
+        # We set the owner instance in the ConfigMeta based classes so they
+        # propagate it down to the ConfigField based classes.
+        if ConfigMeta.is_instance(value):
+            for x in self._qual_name_stack + [self.name]:
+                value._set_owner_instance(x)
+
         instance.__dict__[self.name] = value
 
     def __str__(self) -> str:
@@ -290,31 +317,63 @@ class ConfigField:
 
 
 class ConfigMeta(type):
-    """Metaclass that transforms regular classes into configuration classes with automatic field management.
-
-    ConfigMeta is the core metaclass that enables the declarative configuration system. It automatically
-    processes ConfigField descriptors defined in class bodies and transforms them into fully functional
-    configuration classes with standardized initialization, field access, and metadata management.
-
-    Key Transformations:
-    - **Field Collection**: Automatically discovers and collects all ConfigField instances from the class body.
-    - **Metadata Storage**: Stores field metadata in a `_fields` class attribute for runtime introspection.
-    - **Auto-Generated __init__**: Creates a standardized __init__ method that handles field initialization.
-    - **Field Access**: Injects helper methods like `_get_field` for programmatic field access.
-    - **Nested Object Support**: Automatically instantiates nested configuration objects during initialization.
-
-    Class Transformation Process:
-    1. **Discovery**: Scan the class namespace for ConfigField instances
-    2. **Registration**: Store found fields in `_fields` dictionary
-    3. **Method Injection**: Add `_get_field` helper method to the class
-    4. **__init__ Generation**: Create standardized initialization logic
-    5. **Class Creation**: Return the transformed class with all enhancements
-
-    Generated __init__ Behavior:
-    - Initializes all fields to None by default (explicit defaulting is done separately)
-    - Automatically creates instances of nested ConfigMeta-based classes
-    - Accepts keyword arguments to override field values during instantiation
-    - Ensures consistent initialization patterns across all configuration classes
+    """Metaclass implementing the configuration system's class transformation layer.
+
+    This metaclass exists to solve the fundamental problem of creating a declarative configuration
+    system that can automatically generate runtime behavior from field definitions. Without a
+    metaclass, each configuration class would need to manually implement field discovery,
+    validation, CLI integration, and nested object handling, leading to boilerplate code and
+    inconsistent behavior across the system.
+
+    Technical Implementation:
+
+    During class creation (__new__), this metaclass intercepts the class namespace and performs
+    several critical transformations:
+
+    1. Field Discovery: Scans the class namespace for ConfigField instances and extracts their
+       metadata into a `_fields` registry. This registry becomes the source of truth for all
+       runtime operations including validation, CLI generation, and serialization.
+
+    2. Method Injection: Adds the `_get_field` method to enable programmatic access to field
+       metadata. This method is used throughout the system by validation functions, CLI
+       generators, and configuration mergers.
+
+    3. __init__ Override: Replaces the class's __init__ method with a standardized version that
+       handles three critical initialization phases:
+       - Field initialization to None (explicit defaulting happens later via apply_defaults)
+       - Nested config object instantiation for ConfigMeta-based field types
+       - Keyword argument processing for programmatic configuration
+
+    System Integration and Lifecycle:
+
+    The metaclass integrates with the broader configuration system through several key interfaces:
+
+    - populate_config_recursive: Uses the _fields registry to map external data sources
+      (CLI options, config files) to object attributes
+    - apply_defaults: Traverses the _fields registry to apply default values after population
+    - validate_config_meta: Uses field metadata to execute validation functions
+    - merge_field_values: Consults field behavior settings to determine merge strategies
+    - config_meta_to_dict: Converts instances back to dictionaries for serialization
+
+    Lifecycle Phases:
+
+    1. Class Definition: Metaclass transforms the class, creating _fields registry
+    2. Instance Creation: Auto-generated __init__ initializes fields and nested objects
+    3. Population: External systems use _fields to populate from CLI/config files
+    4. Validation: Field metadata drives validation and required field checking
+    5. Default Application: Fields with None values receive their defaults
+    6. Runtime Usage: Descriptor protocol provides controlled field access
+
+    Why a Metaclass:
+
+    The alternatives to a metaclass would be:
+    - Manual field registration in each class (error-prone, inconsistent)
+    - Inheritance-based approach (doesn't solve the field discovery problem)
+    - Decorator-based approach (requires manual application, less automatic)
+    - Runtime introspection (performance overhead, less reliable)
+
+    The metaclass provides automatic, consistent behavior while maintaining the declarative
+    syntax that makes configuration classes readable and maintainable.
 
     Usage Pattern:
     ```python
@@ -322,22 +381,7 @@ class ConfigMeta(type):
         name = ConfigField(field_type=str, required=True)
         port = ConfigField(field_type=int, default=8080)
         resources = ConfigField(field_type=ResourceConfig)
-
-    # The metaclass transforms this into a fully functional config class
-    config = MyConfig()  # Uses auto-generated __init__
-    config.name = "myapp"  # Uses ConfigField descriptor
-    field_info = config._get_field("name")  # Uses injected helper method
     ```
-
-    Integration Points:
-    - **CLI Generation**: Field metadata is used to automatically generate CLI options
-    - **Config Loading**: Fields are populated from dictionaries, YAML, or JSON files
-    - **Validation**: Field validation functions are called during config commit
-    - **Merging**: Field behaviors control how values are merged from different sources
-    - **Export**: Configuration instances can be exported back to dictionaries
-
-    The metaclass ensures that all configuration classes have consistent behavior and
-    interfaces, regardless of their specific field definitions.
     """
 
     @staticmethod
@@ -351,6 +395,10 @@ class ConfigMeta(type):
             if isinstance(value, ConfigField):
                 fields[key] = value
 
+        def _set_owner_to_instance(self, instance_name: str):
+            for field_name, field_info in fields.items():  # field_info is a ConfigField
+                field_info._set_owner_name(instance_name)
+
         # Store fields metadata on the class
         namespace["_fields"] = fields
 
@@ -359,6 +407,7 @@ class ConfigMeta(type):
             return fields[field_name]
 
         namespace["_get_field"] = get_field
+        namespace["_set_owner_instance"] = _set_owner_to_instance
 
         # Auto-generate __init__ method;
         # Override it for all classes.
@@ -419,7 +468,7 @@ class ConfigValidationFailedException(Exception):
         field_name: str,
         field_info: ConfigField,
         current_value,
-        message: str = None,
+        message: Optional[str] = None,
     ):
         self.field_name = field_name
         self.field_info = field_info
@@ -430,6 +479,17 @@ class ConfigValidationFailedException(Exception):
         if message is not None:
             self.message = message
 
+        suffix = "\n\tThis configuration is set via the the following interfaces:\n\n"
+        suffix += "\t\t1. Config file: `%s`\n" % field_info.fully_qualified_name()
+        suffix += (
+            "\t\t2. Programatic API (Python): `%s`\n"
+            % field_info.fully_qualified_name()
+        )
+        if field_info.cli_meta:
+            suffix += "\t\t3. CLI: `%s`\n" % field_info.cli_meta.cli_option_str
+
+        self.message += suffix
+
         super().__init__(self.message)
 
 
@@ -466,7 +526,7 @@ def validate_required_fields(config_instance):
             current_value
         ):
             validate_required_fields(current_value)
-            # TODO : Fix the exception handling over here.
+            # TODO: Fix the exception handling over here.
 
 
 def validate_config_meta(config_instance):
@@ -485,7 +545,7 @@ def validate_config_meta(config_instance):
                 )
 
 
-def config_meta_to_dict(config_instance) -> Dict[str, Any]:
+def config_meta_to_dict(config_instance) -> Optional[Dict[str, Any]]:
     """Convert a configuration instance to a nested dictionary.
 
     Recursively converts ConfigMeta-based configuration instances to dictionaries,
@@ -645,7 +705,7 @@ def merge_field_values(
     )
 
 
-class JsonFriendlyKeyValuePair(click.ParamType):
+class JsonFriendlyKeyValuePair(click.ParamType):  # type: ignore
     name = "KV-PAIR"  # type: ignore
 
     def convert(self, value, param, ctx):
@@ -670,7 +730,7 @@ class JsonFriendlyKeyValuePair(click.ParamType):
         return "KV-PAIR"
 
 
-class CommaSeparatedList(click.ParamType):
+class CommaSeparatedList(click.ParamType):  # type: ignore
     name = "COMMA-SEPARATED-LIST"  # type: ignore
 
     def convert(self, value, param, ctx):
@@ -687,7 +747,7 @@ class CommaSeparatedList(click.ParamType):
         return "COMMA-SEPARATED-LIST"
 
 
-class PureStringKVPair(click.ParamType):
+class PureStringKVPair(click.ParamType):  # type: ignore
     """Click type for key-value pairs (KEY=VALUE)."""
 
     name = "key=value"