def METHOD_NAME(
    name: Tag | str,
    reader: easyocr.Reader,
    *,
    signatures: ModelSignaturesType | None = None,
    labels: dict[str, str] | None = None,
    custom_objects: dict[str, t.Any] | None = None,
    external_modules: t.List[ModuleType] | None = None,
    metadata: dict[str, t.Any] | None = None,
) -> bentoml.Model:
    """
    Save a model instance to BentoML modelstore.
    Args:
        name: Name for given model instance. This should pass Python identifier check.
        reader: The EasyOCR model to be saved. Currently only supports pre-trained models from easyocr.
                Custom models are not yet supported.
        signatures: Methods to expose for running inference on the target model. Signatures are used for creating :obj:`~bentoml.Runner` instances when serving model with :obj:`~bentoml.Service`
        labels: User-defined labels for managing models, e.g. ``team=nlp``, ``stage=dev``.
        custom_objects: Custom objects to be saved with the model. An example is ``{"my-normalizer": normalizer}``.
                        Custom objects are currently serialized with cloudpickle, but this implementation is subject to change.
        external_modules: user-defined additional python modules to be saved alongside the model or custom objects,
                          e.g. a tokenizer module, preprocessor module, model configuration module
        metadata: Custom metadata for given model.
    Returns:
        :obj:`~bentoml.Tag`: A :obj:`tag` with a format ``name:version`` where ``name`` is the user-defined model's name, and a generated ``version``.
    Examples:
    .. code-block:: python
        import bentoml
        import easyocr
        reader = easyocr.Reader(['en'])
        bento_model = bentoml.easyocr.save_model('en_reader', reader)
    """  # noqa
    context = ModelContext(
        framework_name="easyocr",
        framework_versions={"easyocr": get_pkg_version("easyocr")},
    )
    if signatures is None:
        signatures = {
            k: {"batchable": False}
            for k in ("detect", "readtext", "readtextlang", "recognize")
        }
        signatures["readtext_batched"] = {"batchable": True}
        logger.info(
            'Using the default model signature for Transformers (%s) for model "%s".',
            signatures,
            name,
        )
    with bentoml.models.create(
        name,
        module=MODULE_NAME,
        api_version=API_VERSION,
        labels=labels,
        context=context,
        options=ModelOptions(),
        signatures=signatures,
        custom_objects=custom_objects,
        external_modules=external_modules,
        metadata=metadata,
    ) as bento_model:
        with open(bento_model.path_of(MODEL_FILENAME), "wb") as f:
            cloudpickle.dump(reader, f)
        return bento_model