class_docstr: :obj:`File` defines API specification for the inputs/outputs of a Service, where either
  inputs will be converted to or outputs will be converted from file-like objects as
  specified in your API function signature.
  
  A sample ViT service:
  
  .. code-block:: python
     :caption: `service.py`
  
     from __future__ import annotations
  
     import io
     from typing import TYPE_CHECKING
     from typing import Any
  
     import bentoml
     from bentoml.io import File
  
     if TYPE_CHECKING:
         from numpy.typing import NDArray
  
     runner = bentoml.tensorflow.get('image-classification:latest').to_runner()
  
     svc = bentoml.Service("vit-pdf-classifier", runners=[runner])
  
     @svc.api(input=File(), output=NumpyNdarray(dtype="float32"))
     async def predict(input_pdf: io.BytesIO[Any]) -> NDArray[Any]:
         return await runner.async_run(input_pdf)
  
  Users then can then serve this service with :code:`bentoml serve`:
  
  .. code-block:: bash
  
      % bentoml serve ./service.py:svc --reload
  
  Users can then send requests to the newly started services with any client:
  
  .. tab-set::
  
      .. tab-item:: Bash
  
          .. code-block:: bash
  
             % curl -H "Content-Type: multipart/form-data" \
                    -F 'fileobj=@test.pdf;type=application/pdf' \
                    http://0.0.0.0:3000/predict
  
      .. tab-item:: Python
  
         .. code-block:: python
            :caption: `request.py`
  
            import requests
  
            requests.post(
                "http://0.0.0.0:3000/predict",
                files = {"upload_file": open('test.pdf', 'rb')},
                headers = {"content-type": "multipart/form-data"}
            ).text
  
  Args:
      kind: The kind of file-like object to be used. Currently, the only accepted value is ``binaryio``.
      mime_type: Return MIME type of the :code:`starlette.response.Response`, only available when used as output descriptor
  
  Returns:
      :obj:`File`: IO Descriptor that represents file-like objects.
code: def openapi_responses(self) -> OpenAPIResponse:
      return {
          "description": SUCCESS_DESCRIPTION,
          "content": {
              "*/*"
              if self._mime_type is None
              else self._mime_type: MediaType(
                  schema=self.openapi_schema()
              )
          },
          "x-bentoml-io-descriptor": self.to_spec(),
      }
  
imports: from __future__ import annotations
  import io
  import logging
  import os
  import typing
  from functools import lru_cache
  from multipart.multipart import parse_options_header
  from starlette.datastructures import UploadFile
  from starlette.requests import Request
  from starlette.responses import Response
  from ...exceptions import BadInput
  from ...exceptions import BentoMLException
  from ...exceptions import InvalidArgument
  from ...exceptions import MissingDependencyException
  from ...grpc.utils import import_generated_stubs
  from ..service.openapi import SUCCESS_DESCRIPTION
  from ..service.openapi.specification import MediaType
  from ..service.openapi.specification import Schema
  from ..types import FileLike
  from ..utils import resolve_user_filepath
  from ..utils.http import set_cookies
  from .base import IODescriptor
label_desc: Use image node_id 9 for calling the File obj's underlying member method code with example usage: obj.openapi_responses() and returns: dict