code: def import_model(
      path: str,
      input_format: t.Optional[str] = None,
      *,
      protocol: t.Optional[str] = None,
      user: t.Optional[str] = None,
      passwd: t.Optional[str] = None,
      params: t.Optional[t.Dict[str, str]] = None,
      subpath: t.Optional[str] = None,
      _model_store: "ModelStore" = Provide[
          BentoMLContainer.model_store
      ],
  ) -> Model:
      """
      Import a bento model exported with :code:`bentoml.models.export_model`. To import a model saved
      with a framework, see the :code:`save` function under the relevant framework, e.g.
      :code:`bentoml.sklearn.save`.
  
      Examples:
  
      .. code-block:: python
  
          # imports 'my_model' from '/path/to/folder/my_model.bentomodel'
          bentoml.models.import_model('/path/to/folder/my_model.bentomodel')
  
          # imports 'my_model' from '/path/to/folder/my_model.tar.gz'
          # currently supported formats are tar.gz ('gz'), tar.xz ('xz'), tar.bz2 ('bz2'), and zip
          bentoml.models.import_model('/path/to/folder/my_model.tar.gz')
          # treats 'my_model.ext' as a gzipped tarfile
          bentoml.models.import_model('/path/to/folder/my_model.ext', 'gz')
  
          # imports 'my_model', which is stored as an uncompressed folder, from '/path/to/folder/my_model/'
          bentoml.models.import_model('/path/to/folder/my_model', 'folder')
  
          # imports 'my_model' from the S3 bucket 'my_bucket', path 'folder/my_model.bentomodel'
          # requires `fs-s3fs <https://pypi.org/project/fs-s3fs/>`_ ('pip install fs-s3fs')
          bentoml.models.import_model('s3://my_bucket/folder/my_model.bentomodel')
          bentoml.models.import_model('my_bucket/folder/my_model.bentomodel', protocol='s3')
          bentoml.models.import_model('my_bucket', protocol='s3', subpath='folder/my_model.bentomodel')
          bentoml.models.import_model('my_bucket', protocol='s3', subpath='folder/my_model.bentomodel',
                                      user='<AWS access key>', passwd='<AWS secret key>',
                                      params={'acl': 'public-read', 'cache-control': 'max-age=2592000,public'})
  
      For a more comprehensive description of what each of the keyword arguments (:code:`protocol`,
      :code:`user`, :code:`passwd`, :code:`params`, and :code:`subpath`) mean, see the
      `FS URL documentation <https://docs.pyfilesystem.org/en/latest/openers.html>`_.
  
      Args:
          tag: the tag of the model to export
          path: can be one of two things:
                * a folder on the local filesystem
                * an `FS URL <https://docs.pyfilesystem.org/en/latest/openers.html>`_, for example :code:`'s3://my_bucket/folder/my_model.bentomodel'`
          protocol: (expert) The FS protocol to use when exporting. Some example protocols are :code:`'ftp'`, :code:`'s3'`, and :code:`'userdata'`
          user: (expert) the username used for authentication if required, e.g. for FTP
          passwd: (expert) the username used for authentication if required, e.g. for FTP
          params: (expert) a map of parameters to be passed to the FS used for export, e.g. :code:`{'proxy': 'myproxy.net'}` for setting a proxy for FTP
          subpath: (expert) the path inside the FS that the model should be exported to
          _model_store: the model store to save the model to
  
      Returns:
          Model: the imported model
      """
      return Model.import_from(
          path,
          input_format,
          protocol=protocol,
          user=user,
          passwd=passwd,
          params=params,
          subpath=subpath,
      ).save(_model_store)
  
imports: from __future__ import annotations
  import typing
  from contextlib import contextmanager
  from types import ModuleType
  from typing import TYPE_CHECKING
  from simple_di import Provide
  from simple_di import inject
  from ._internal.configuration.containers import BentoMLContainer
  from ._internal.models import Model
  from ._internal.models import ModelContext
  from ._internal.models import ModelOptions
  from ._internal.tag import Tag
  from ._internal.utils import calc_dir_size
  from ._internal.utils.analytics import ModelSaveEvent
  from ._internal.utils.analytics import track
  from .exceptions import BentoMLException
label_desc: Use image node_id 4 for calling a global function with example usage: import_model(path, input_format) and returns: Model