zenml-nightly 0.55.0.dev20240124__py3-none-any.whl → 0.72.0.dev20250116__py3-none-any.whl

zenml/steps/step_decorator.py

@@ -13,12 +13,10 @@
 #  permissions and limitations under the License.
 """Step decorator function."""
 
-from types import FunctionType
 from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    ClassVar,
     Dict,
     Mapping,
     Optional,
@@ -30,67 +28,32 @@ from typing import (
 )
 
 from zenml.logger import get_logger
-from zenml.steps import BaseStep
 
 if TYPE_CHECKING:
     from zenml.config.base_settings import SettingsOrDict
+    from zenml.config.retry_config import StepRetryConfig
     from zenml.config.source import Source
     from zenml.materializers.base_materializer import BaseMaterializer
     from zenml.model.model import Model
+    from zenml.steps import BaseStep
+    from zenml.types import HookSpecification
+
+    MaterializerClassOrSource = Union[str, Source, Type[BaseMaterializer]]
 
-    MaterializerClassOrSource = Union[str, "Source", Type["BaseMaterializer"]]
-    HookSpecification = Union[str, "Source", FunctionType]
     OutputMaterializersSpecification = Union[
-        "MaterializerClassOrSource",
-        Sequence["MaterializerClassOrSource"],
-        Mapping[str, "MaterializerClassOrSource"],
-        Mapping[str, Sequence["MaterializerClassOrSource"]],
+        MaterializerClassOrSource,
+        Sequence[MaterializerClassOrSource],
+        Mapping[str, MaterializerClassOrSource],
+        Mapping[str, Sequence[MaterializerClassOrSource]],
     ]
+    F = TypeVar("F", bound=Callable[..., Any])
 
 
-STEP_INNER_FUNC_NAME = "entrypoint"
-PARAM_STEP_NAME = "name"
-PARAM_ENABLE_CACHE = "enable_cache"
-PARAM_ENABLE_ARTIFACT_METADATA = "enable_artifact_metadata"
-PARAM_ENABLE_ARTIFACT_VISUALIZATION = "enable_artifact_visualization"
-PARAM_ENABLE_STEP_LOGS = "enable_step_logs"
-PARAM_STEP_OPERATOR = "step_operator"
-PARAM_EXPERIMENT_TRACKER = "experiment_tracker"
-CLASS_CONFIGURATION = "_CLASS_CONFIGURATION"
-PARAM_OUTPUT_ARTIFACTS = "output_artifacts"
-PARAM_OUTPUT_MATERIALIZERS = "output_materializers"
-PARAM_SETTINGS = "settings"
-PARAM_EXTRA_OPTIONS = "extra"
-PARAM_ON_FAILURE = "on_failure"
-PARAM_ON_SUCCESS = "on_success"
-PARAM_MODEL = "model"
-
 logger = get_logger(__name__)
 
-F = TypeVar("F", bound=Callable[..., Any])
-
-
-class _DecoratedStep(BaseStep):
-    _CLASS_CONFIGURATION: ClassVar[Optional[Dict[str, Any]]] = None
-
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        class_config = self._CLASS_CONFIGURATION or {}
-        kwargs = {**class_config, **kwargs}
-        super().__init__(*args, **kwargs)
-
-    @property
-    def source_object(self) -> Any:
-        """The source object of this step.
-
-        Returns:
-            The source object of this step.
-        """
-        return self.entrypoint
-
 
 @overload
-def step(_func: F) -> Type[BaseStep]:
-    ...
+def step(_func: "F") -> "BaseStep": ...
 
 
 @overload
@@ -109,12 +72,13 @@ def step(
     on_failure: Optional["HookSpecification"] = None,
     on_success: Optional["HookSpecification"] = None,
     model: Optional["Model"] = None,
-) -> Callable[[F], Type[BaseStep]]:
-    ...
+    retry: Optional["StepRetryConfig"] = None,
+    substitutions: Optional[Dict[str, str]] = None,
+) -> Callable[["F"], "BaseStep"]: ...
 
 
 def step(
-    _func: Optional[F] = None,
+    _func: Optional["F"] = None,
     *,
     name: Optional[str] = None,
     enable_cache: Optional[bool] = None,
@@ -129,11 +93,10 @@ def step(
     on_failure: Optional["HookSpecification"] = None,
     on_success: Optional["HookSpecification"] = None,
     model: Optional["Model"] = None,
-) -> Union[Type[BaseStep], Callable[[F], Type[BaseStep]]]:
-    """Outer decorator function for the creation of a ZenML step.
-
-    In order to be able to work with parameters such as `name`, it features a
-    nested decorator structure.
+    retry: Optional["StepRetryConfig"] = None,
+    substitutions: Optional[Dict[str, str]] = None,
+) -> Union["BaseStep", Callable[["F"], "BaseStep"]]:
+    """Decorator to create a ZenML step.
 
     Args:
         _func: The decorated function.
@@ -161,56 +124,47 @@ def step(
         on_success: Callback function in event of success of the step. Can be a
             function with no arguments, or a source path to such a function
             (e.g. `module.my_function`).
-        model: configuration of the model version in the Model Control Plane.
+        model: configuration of the model in the Model Control Plane.
+        retry: configuration of step retry in case of step failure.
+        substitutions: Extra placeholders for the step name.
 
     Returns:
-        The inner decorator which creates the step class based on the
-        ZenML BaseStep
+        The step instance.
     """
 
-    def inner_decorator(func: F) -> Type[BaseStep]:
-        """Inner decorator function for the creation of a ZenML Step.
-
-        Args:
-            func: types.FunctionType, this function will be used as the
-                "process" method of the generated Step.
-
-        Returns:
-            The class of a newly generated ZenML Step.
-        """
-        step_name = name or func.__name__
-        logger.warning(
-            f"The `@step` decorator that you used to define your {step_name} "
-            "step is deprecated. Check out the 0.40.0 migration guide for more "
-            "information on how to migrate your steps to the new syntax: "
-            "https://docs.zenml.io/reference/migration-guide/migration-zero-forty"
-        )
+    def inner_decorator(func: "F") -> "BaseStep":
+        from zenml.steps.decorated_step import _DecoratedStep
 
-        return type(  # noqa
+        class_: Type["BaseStep"] = type(
             func.__name__,
             (_DecoratedStep,),
             {
-                STEP_INNER_FUNC_NAME: staticmethod(func),
-                CLASS_CONFIGURATION: {
-                    PARAM_STEP_NAME: name,
-                    PARAM_ENABLE_CACHE: enable_cache,
-                    PARAM_ENABLE_ARTIFACT_METADATA: enable_artifact_metadata,
-                    PARAM_ENABLE_ARTIFACT_VISUALIZATION: enable_artifact_visualization,
-                    PARAM_ENABLE_STEP_LOGS: enable_step_logs,
-                    PARAM_EXPERIMENT_TRACKER: experiment_tracker,
-                    PARAM_STEP_OPERATOR: step_operator,
-                    PARAM_OUTPUT_MATERIALIZERS: output_materializers,
-                    PARAM_SETTINGS: settings,
-                    PARAM_EXTRA_OPTIONS: extra,
-                    PARAM_ON_FAILURE: on_failure,
-                    PARAM_ON_SUCCESS: on_success,
-                    PARAM_MODEL: model,
-                },
+                "entrypoint": staticmethod(func),
                 "__module__": func.__module__,
                 "__doc__": func.__doc__,
             },
         )
 
+        step_instance = class_(
+            name=name or func.__name__,
+            enable_cache=enable_cache,
+            enable_artifact_metadata=enable_artifact_metadata,
+            enable_artifact_visualization=enable_artifact_visualization,
+            enable_step_logs=enable_step_logs,
+            experiment_tracker=experiment_tracker,
+            step_operator=step_operator,
+            output_materializers=output_materializers,
+            settings=settings,
+            extra=extra,
+            on_failure=on_failure,
+            on_success=on_success,
+            model=model,
+            retry=retry,
+            substitutions=substitutions,
+        )
+
+        return step_instance
+
     if _func is None:
         return inner_decorator
     else:

zenml/steps/step_invocation.py

@@ -12,13 +12,17 @@
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
 """Step invocation class definition."""
-from typing import TYPE_CHECKING, Any, Dict, Set
+
+from typing import TYPE_CHECKING, Any, Dict, Set, Union
+
+from zenml.models import ArtifactVersionResponse
 
 if TYPE_CHECKING:
     from zenml.artifacts.external_artifact import ExternalArtifact
+    from zenml.client_lazy_loader import ClientLazyLoader
     from zenml.config.step_configurations import StepConfiguration
     from zenml.model.lazy_load import ModelVersionDataLazyLoader
-    from zenml.new.pipelines.pipeline import Pipeline
+    from zenml.pipelines.pipeline_definition import Pipeline
     from zenml.steps import BaseStep
     from zenml.steps.entrypoint_function_utils import StepArtifact
 
@@ -31,8 +35,11 @@ class StepInvocation:
         id: str,
         step: "BaseStep",
         input_artifacts: Dict[str, "StepArtifact"],
-        external_artifacts: Dict[str, "ExternalArtifact"],
+        external_artifacts: Dict[
+            str, Union["ExternalArtifact", "ArtifactVersionResponse"]
+        ],
         model_artifacts_or_metadata: Dict[str, "ModelVersionDataLazyLoader"],
+        client_lazy_loaders: Dict[str, "ClientLazyLoader"],
         parameters: Dict[str, Any],
         default_parameters: Dict[str, Any],
         upstream_steps: Set[str],
@@ -47,6 +54,7 @@ class StepInvocation:
             external_artifacts: The external artifacts for the invocation.
             model_artifacts_or_metadata: The model artifacts or metadata for
                 the invocation.
+            client_lazy_loaders: The client lazy loaders for the invocation.
             parameters: The parameters for the invocation.
             default_parameters: The default parameters for the invocation.
             upstream_steps: The upstream steps for the invocation.
@@ -57,61 +65,12 @@ class StepInvocation:
         self.input_artifacts = input_artifacts
         self.external_artifacts = external_artifacts
         self.model_artifacts_or_metadata = model_artifacts_or_metadata
+        self.client_lazy_loaders = client_lazy_loaders
         self.parameters = parameters
         self.default_parameters = default_parameters
-        self.invocation_upstream_steps = upstream_steps
+        self.upstream_steps = upstream_steps
         self.pipeline = pipeline
 
-    @property
-    def upstream_steps(self) -> Set[str]:
-        """The upstream steps of the invocation.
-
-        Returns:
-            The upstream steps of the invocation.
-        """
-        return self.invocation_upstream_steps.union(
-            self._get_and_validate_step_upstream_steps()
-        )
-
-    def _get_and_validate_step_upstream_steps(self) -> Set[str]:
-        """Validates the upstream steps defined on the step instance.
-
-        This is only allowed in legacy pipelines when calling `step.after(...)`
-        and we need to make sure that both the upstream and downstream steps
-        of such a relationship are only invoked once inside a pipeline.
-
-        Returns:
-            The upstream steps defined on the step instance.
-        """
-
-        def _verify_single_invocation(step: "BaseStep") -> str:
-            invocations = {
-                invocation
-                for invocation in self.pipeline.invocations.values()
-                if invocation.step is step
-            }
-            if len(invocations) > 1:
-                raise RuntimeError(
-                    "Setting upstream steps for a step using "
-                    "`step_1.after(step_2)` is not allowed in combination "
-                    "with calling one of the two steps multiple times."
-                )
-            return invocations.pop().id
-
-        if self.step.upstream_steps:
-            # If the step has upstream steps, make sure it only got invoked once
-            _verify_single_invocation(step=self.step)
-
-        upstream_steps = set()
-
-        for upstream_step in self.step.upstream_steps:
-            upstream_step_invocation_id = _verify_single_invocation(
-                step=upstream_step
-            )
-            upstream_steps.add(upstream_step_invocation_id)
-
-        return upstream_steps
-
     def finalize(self, parameters_to_ignore: Set[str]) -> "StepConfiguration":
         """Finalizes a step invocation.
 
@@ -129,9 +88,6 @@ class StepInvocation:
             ExternalArtifactConfiguration,
         )
 
-        # Validate the upstream steps for legacy .after() calls
-        self._get_and_validate_step_upstream_steps()
-
         parameters_to_apply = {
             key: value
             for key, value in self.parameters.items()
@@ -149,12 +105,18 @@ class StepInvocation:
 
         external_artifacts: Dict[str, ExternalArtifactConfiguration] = {}
         for key, artifact in self.external_artifacts.items():
-            if artifact.value is not None:
-                artifact.upload_by_value()
-            external_artifacts[key] = artifact.config
+            if isinstance(artifact, ArtifactVersionResponse):
+                external_artifacts[key] = ExternalArtifactConfiguration(
+                    id=artifact.id
+                )
+            else:
+                if artifact.value is not None:
+                    artifact.upload_by_value()
+                external_artifacts[key] = artifact.config
 
         return self.step._finalize_configuration(
             input_artifacts=self.input_artifacts,
             external_artifacts=external_artifacts,
             model_artifacts_or_metadata=self.model_artifacts_or_metadata,
+            client_lazy_loaders=self.client_lazy_loaders,
         )

zenml/steps/utils.py

@@ -14,26 +14,41 @@
 
 """Utility functions and classes to run ZenML steps."""
 
-
 import ast
 import contextlib
 import inspect
 import textwrap
-from typing import Any, Callable, Dict, Optional, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Optional,
+    Tuple,
+    Union,
+)
 from uuid import UUID
 
-import pydantic.typing as pydantic_typing
 from pydantic import BaseModel
 from typing_extensions import Annotated
 
 from zenml.artifacts.artifact_config import ArtifactConfig
 from zenml.client import Client
-from zenml.enums import MetadataResourceTypes
+from zenml.enums import (
+    ArtifactSaveType,
+    ExecutionStatus,
+    MetadataResourceTypes,
+)
+from zenml.exceptions import StepInterfaceError
 from zenml.logger import get_logger
 from zenml.metadata.metadata_types import MetadataType
-from zenml.new.steps.step_context import get_step_context
-from zenml.steps.step_output import Output
-from zenml.utils import source_code_utils
+from zenml.models import RunMetadataResource
+from zenml.steps.step_context import get_step_context
+from zenml.utils import settings_utils, source_code_utils, typing_utils
+
+if TYPE_CHECKING:
+    from zenml.steps import BaseStep
+
 
 logger = get_logger(__name__)
 
@@ -43,10 +58,32 @@ SINGLE_RETURN_OUT_NAME = "output"
 class OutputSignature(BaseModel):
     """The signature of an output artifact."""
 
-    resolved_annotation: Any
-    artifact_config: Optional[ArtifactConfig]
+    resolved_annotation: Any = None
+    artifact_config: Optional[ArtifactConfig] = None
     has_custom_name: bool = False
 
+    def get_output_types(self) -> Tuple[Any, ...]:
+        """Get all output types that match the type annotation.
+
+        Returns:
+            All output types that match the type annotation.
+        """
+        if self.resolved_annotation is Any:
+            return ()
+
+        if typing_utils.is_union(
+            typing_utils.get_origin(self.resolved_annotation)
+            or self.resolved_annotation
+        ):
+            return tuple(
+                type(None)
+                if typing_utils.is_none_type(output_type)
+                else output_type
+                for output_type in get_args(self.resolved_annotation)
+            )
+        else:
+            return (self.resolved_annotation,)
+
 
 def get_args(obj: Any) -> Tuple[Any, ...]:
     """Get arguments of a type annotation.
@@ -61,13 +98,13 @@ def get_args(obj: Any) -> Tuple[Any, ...]:
         The args of the annotation.
     """
     return tuple(
-        pydantic_typing.get_origin(v) or v
-        for v in pydantic_typing.get_args(obj)
+        typing_utils.get_origin(v) or v for v in typing_utils.get_args(obj)
     )
 
 
 def parse_return_type_annotations(
-    func: Callable[..., Any], enforce_type_annotations: bool = False
+    func: Callable[..., Any],
+    enforce_type_annotations: bool = False,
 ) -> Dict[str, OutputSignature]:
     """Parse the return type annotation of a step function.
 
@@ -105,30 +142,11 @@ def parse_return_type_annotations(
         else:
             return_annotation = Any
 
-    # Return type annotated using deprecated `Output(...)`
-    if isinstance(return_annotation, Output):
-        logger.warning(
-            "Using the `Output` class to define the outputs of your steps is "
-            "deprecated. You should instead use the standard Python way of "
-            "type annotating your functions. Check out our documentation "
-            "https://docs.zenml.io/user-guide/advanced-guide/pipelining-features/configure-steps-pipelines#step-output-names "
-            "for more information on how to assign custom names to your step "
-            "outputs."
-        )
-        return {
-            output_name: OutputSignature(
-                resolved_annotation=resolve_type_annotation(output_type),
-                artifact_config=None,
-                has_custom_name=True,
-            )
-            for output_name, output_type in return_annotation.items()
-        }
-
-    elif pydantic_typing.get_origin(return_annotation) is tuple:
+    if typing_utils.get_origin(return_annotation) is tuple:
         requires_multiple_artifacts = has_tuple_return(func)
         if requires_multiple_artifacts:
             output_signature: Dict[str, Any] = {}
-            args = pydantic_typing.get_args(return_annotation)
+            args = typing_utils.get_args(return_annotation)
             if args[-1] is Ellipsis:
                 raise RuntimeError(
                     "Variable length output annotations are not allowed."
@@ -180,12 +198,12 @@ def resolve_type_annotation(obj: Any) -> Any:
     Returns:
         The non-generic class for generic aliases of the typing module.
     """
-    origin = pydantic_typing.get_origin(obj) or obj
+    origin = typing_utils.get_origin(obj) or obj
 
     if origin is Annotated:
-        annotation, *_ = pydantic_typing.get_args(obj)
+        annotation, *_ = typing_utils.get_args(obj)
         return resolve_type_annotation(annotation)
-    elif pydantic_typing.is_union(origin):
+    elif typing_utils.is_union(origin):
         return obj
 
     return origin
@@ -213,16 +231,19 @@ def get_artifact_config_from_annotation_metadata(
     Returns:
         The artifact config.
     """
-    if (pydantic_typing.get_origin(annotation) or annotation) is not Annotated:
+    if (typing_utils.get_origin(annotation) or annotation) is not Annotated:
         return None
 
-    annotation, *metadata = pydantic_typing.get_args(annotation)
+    annotation, *metadata = typing_utils.get_args(annotation)
 
     error_message = (
         "Artifact annotation should only contain two elements: the artifact "
-        "type, and either an output name or an `ArtifactConfig`, e.g.: "
-        "`Annotated[int, 'output_name']` or "
-        "`Annotated[int, ArtifactConfig(name='output_name'), ...]`."
+        "type, and one of the following: { a static or dynamic name || "
+        "an `ArtifactConfig` }, e.g.: "
+        "`Annotated[int, 'output_name']` || "
+        "`Annotated[int, 'output_{placeholder}']` || "
+        "`Annotated[int, ArtifactConfig(name='output_{placeholder}')]` ||"
+        "`Annotated[int, ArtifactConfig(name='output_name')]`."
     )
 
     if len(metadata) > 2:
@@ -252,7 +273,7 @@ def get_artifact_config_from_annotation_metadata(
         if not artifact_config:
             artifact_config = ArtifactConfig(name=output_name)
         elif not artifact_config.name:
-            artifact_config = artifact_config.copy()
+            artifact_config = artifact_config.model_copy()
             artifact_config.name = output_name
 
     if artifact_config and artifact_config.name == "":
@@ -416,7 +437,6 @@ def log_step_metadata(
     metadata: Dict[str, "MetadataType"],
     step_name: Optional[str] = None,
     pipeline_name_id_or_prefix: Optional[Union[str, UUID]] = None,
-    pipeline_version: Optional[str] = None,
     run_id: Optional[str] = None,
 ) -> None:
     """Logs step metadata.
@@ -427,8 +447,6 @@ def log_step_metadata(
             when being called inside a step.
         pipeline_name_id_or_prefix: The name of the pipeline to log metadata
             for. Can be omitted when being called inside a step.
-        pipeline_version: The version of the pipeline to log metadata for.
-            Can be omitted when being called inside a step.
         run_id: The ID of the run to log metadata for. Can be omitted when
             being called inside a step.
 
@@ -437,6 +455,11 @@ def log_step_metadata(
             from within a step or if no pipeline name or ID is provided and
             the function is not called from within a step.
     """
+    logger.warning(
+        "The `log_step_metadata` function is deprecated and will soon be "
+        "removed. Please use `log_metadata` instead."
+    )
+
     step_context = None
     if not step_name:
         with contextlib.suppress(RuntimeError):
@@ -463,11 +486,101 @@ def log_step_metadata(
             )
         pipeline_run = client.get_pipeline(
             name_id_or_prefix=pipeline_name_id_or_prefix,
-            version=pipeline_version,
         ).last_run
         step_run_id = pipeline_run.steps[step_name].id
     client.create_run_metadata(
         metadata=metadata,
-        resource_id=step_run_id,
-        resource_type=MetadataResourceTypes.STEP_RUN,
+        resources=[
+            RunMetadataResource(
+                id=step_run_id, type=MetadataResourceTypes.STEP_RUN
+            )
+        ],
     )
+
+
+def run_as_single_step_pipeline(
+    __step: "BaseStep", *args: Any, **kwargs: Any
+) -> Any:
+    """Runs the step as a single step pipeline.
+
+    - All inputs that are not JSON serializable will be uploaded to the
+    artifact store before the pipeline is being executed.
+    - All output artifacts of the step will be loaded using the materializer
+    that was used to store them.
+
+    Args:
+        *args: Entrypoint function arguments.
+        **kwargs: Entrypoint function keyword arguments.
+
+    Raises:
+        RuntimeError: If the step execution failed.
+        StepInterfaceError: If the arguments to the entrypoint function are
+            invalid.
+
+    Returns:
+        The output of the step entrypoint function.
+    """
+    from zenml import ExternalArtifact, pipeline
+    from zenml.config.base_settings import BaseSettings
+    from zenml.pipelines.run_utils import (
+        wait_for_pipeline_run_to_finish,
+    )
+
+    logger.info(
+        "Running single step pipeline to execute step `%s`", __step.name
+    )
+
+    try:
+        validated_arguments = (
+            inspect.signature(__step.entrypoint)
+            .bind(*args, **kwargs)
+            .arguments
+        )
+    except TypeError as e:
+        raise StepInterfaceError(
+            "Invalid step function entrypoint arguments. Check out the "
+            "error above for more details."
+        ) from e
+
+    inputs: Dict[str, Any] = {}
+    for key, value in validated_arguments.items():
+        try:
+            __step.entrypoint_definition.validate_input(key=key, value=value)
+            inputs[key] = value
+        except Exception:
+            inputs[key] = ExternalArtifact(value=value)
+
+    orchestrator = Client().active_stack.orchestrator
+
+    pipeline_settings: Any = {}
+    if "synchronous" in orchestrator.config.model_fields:
+        # Make sure the orchestrator runs sync so we stream the logs
+        key = settings_utils.get_stack_component_setting_key(orchestrator)
+        pipeline_settings[key] = BaseSettings(synchronous=True)
+
+    @pipeline(name=__step.name, enable_cache=False, settings=pipeline_settings)
+    def single_step_pipeline() -> None:
+        __step(**inputs)
+
+    run = single_step_pipeline.with_options(unlisted=True)()
+    assert run
+    run = wait_for_pipeline_run_to_finish(run.id)
+
+    if run.status != ExecutionStatus.COMPLETED:
+        raise RuntimeError("Failed to execute step %s.", __step.name)
+
+    # 4. Load output artifacts
+    step_run = next(iter(run.steps.values()))
+    outputs = [
+        artifact_version.load()
+        for output_name in step_run.config.outputs.keys()
+        for artifact_version in step_run.outputs[output_name]
+        if artifact_version.save_type == ArtifactSaveType.STEP_OUTPUT
+    ]
+
+    if len(outputs) == 0:
+        return None
+    elif len(outputs) == 1:
+        return outputs[0]
+    else:
+        return tuple(outputs)

zenml/types.py

@@ -11,7 +11,16 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
-"""Custom types that are used to indicate how to handle data."""
+"""Custom ZenML types."""
+
+from typing import TYPE_CHECKING, Callable, Union
+
+if TYPE_CHECKING:
+    from types import FunctionType
+
+    from zenml.config.source import Source
+
+    HookSpecification = Union[str, Source, FunctionType, Callable[..., None]]
 
 
 class HTMLString(str):
@@ -24,3 +33,7 @@ class MarkdownString(str):
 
 class CSVString(str):
     """Special string class to indicate a CSV string."""
+
+
+class JSONString(str):
+    """Special string class to indicate a JSON string."""