code: def save_model(
      name: Tag | str,
      model: torch.ScriptModule,
      *,
      signatures: ModelSignaturesType | None = None,
      labels: t.Dict[str, str] | None = None,
      custom_objects: t.Dict[str, t.Any] | None = None,
      external_modules: t.List[ModuleType] | None = None,
      metadata: t.Dict[str, t.Any] | None = None,
      _framework_name: str = "torchscript",
      _module_name: str = MODULE_NAME,
      _extra_files: dict[str, t.Any] | None = None,
  ) -> bentoml.Model:
      """
      Save a model instance to BentoML modelstore.
  
      Args:
          name (:code:`str`):
              Name for given model instance. This should pass Python identifier check.
          model (`torch.ScriptModule`):
              Instance of model to be saved
          signatures (:code:`dict`, `optional`):
              A dictionary of method names and their corresponding signatures.
          labels (:code:`Dict[str, str]`, `optional`, default to :code:`None`):
              user-defined labels for managing models, e.g. team=nlp, stage=dev
          custom_objects (:code:`Dict[str, Any]]`, `optional`, default to :code:`None`):
              user-defined additional python objects to be saved alongside the model,
              e.g. a tokenizer instance, preprocessor function, model configuration json
          external_modules (:code:`List[ModuleType]`, `optional`, default to :code:`None`):
              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 (:code:`Dict[str, Any]`, `optional`, default to :code:`None`):
              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` by BentoML.
  
      Examples:
  
      .. code-block:: python
  
          import bentoml
          import torch
      """
      if not isinstance(
          model, (torch.ScriptModule, torch.jit.ScriptModule)
      ):
          raise TypeError(
              f"Given model ({model}) is not a torch.ScriptModule."
          )
  
      if _framework_name == "pytorch_lightning":
          framework_versions = {
              "torch": get_pkg_version("torch"),
              "pytorch_lightning": get_pkg_version("pytorch_lightning"),
          }
      else:
          framework_versions = {"torch": get_pkg_version("torch")}
  
      context: ModelContext = ModelContext(
          framework_name=_framework_name,
          framework_versions=framework_versions,
      )
      if _extra_files is not None:
          if metadata is None:
              metadata = {}
          metadata["_extra_files"] = [f for f in _extra_files]
  
      if signatures is None:
          signatures = {"__call__": {"batchable": False}}
          logger.info(
              'Using the default model signature for torchscript (%s) for model "%s".',
              signatures,
              name,
          )
  
      with bentoml.models.create(
          name,
          module=_module_name,
          api_version=API_VERSION,
          labels=labels,
          signatures=signatures,
          custom_objects=custom_objects,
          external_modules=external_modules,
          options=ModelOptions(),
          context=context,
          metadata=metadata,
      ) as bento_model:
          torch.jit.save(
              model,
              bento_model.path_of(MODEL_FILENAME),
              _extra_files=_extra_files,
          )
          return bento_model
  
file_path: BentoML/grpc-client/bentoml/_internal/frameworks/torchscript.py
imports: from __future__ import annotations
  import logging
  import typing
  from types import ModuleType
  from typing import TYPE_CHECKING
  import bentoml
  from bentoml import Tag
  from ...exceptions import NotFound
  from ..models.model import Model
  from ..models.model import ModelContext
  from ..models.model import PartialKwargsModelOptions
  from ..utils.pkg import get_pkg_version
  from .common.pytorch import torch
label_desc: Use image node_id 3 for calling a global function with example usage: save_model(name, model) and returns: bento_model