code: def save_model(
      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
  
file_path: BentoML/src/bentoml/_internal/frameworks/easyocr.py
imports: from __future__ import annotations
  import logging
  import typing
  from types import ModuleType
  import cloudpickle
  import bentoml
  from ...exceptions import MissingDependencyException
  from ...exceptions import NotFound
  from ..models.model import Model
  from ..models.model import ModelContext
  from ..models.model import ModelOptions
  from ..models.model import ModelSignature
  from ..tag import Tag
  from ..utils.pkg import get_pkg_version
  from .common.pytorch import PyTorchTensorContainer
label_desc: Use image node_id 3 for calling a global function with example usage: save_model(name, reader) and returns: bento_model