"""simple docstring"""


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_distilbert import DistilBertTokenizer


UpperCAmelCase__  		=						logging.get_logger(__name__)

UpperCAmelCase__  		=						{"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

UpperCAmelCase__  		=						{
    """vocab_file""": {
        """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt""",
        """distilbert-base-uncased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt"""
        ),
        """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt""",
        """distilbert-base-cased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt"""
        ),
        """distilbert-base-german-cased""": """https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt""",
        """distilbert-base-multilingual-cased""": (
            """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json""",
        """distilbert-base-uncased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json""",
        """distilbert-base-cased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-german-cased""": (
            """https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-multilingual-cased""": (
            """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json"""
        ),
    },
}

UpperCAmelCase__  		=						{
    """distilbert-base-uncased""": 5_1_2,
    """distilbert-base-uncased-distilled-squad""": 5_1_2,
    """distilbert-base-cased""": 5_1_2,
    """distilbert-base-cased-distilled-squad""": 5_1_2,
    """distilbert-base-german-cased""": 5_1_2,
    """distilbert-base-multilingual-cased""": 5_1_2,
}


UpperCAmelCase__  		=						{
    """distilbert-base-uncased""": {"""do_lower_case""": True},
    """distilbert-base-uncased-distilled-squad""": {"""do_lower_case""": True},
    """distilbert-base-cased""": {"""do_lower_case""": False},
    """distilbert-base-cased-distilled-squad""": {"""do_lower_case""": False},
    """distilbert-base-german-cased""": {"""do_lower_case""": False},
    """distilbert-base-multilingual-cased""": {"""do_lower_case""": False},
}


class        a				(		lowerCAmelCase_   ):
    _snake_case     :  Tuple     							=							VOCAB_FILES_NAMES
    _snake_case     :  Optional[int]     							=							PRETRAINED_VOCAB_FILES_MAP
    _snake_case     :  List[str]     							=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    _snake_case     :  List[Any]     							=							PRETRAINED_INIT_CONFIGURATION
    _snake_case     :  Union[str, Any]     							=							['input_ids', 'attention_mask']
    _snake_case     :  int     							=							DistilBertTokenizer


    def __init__(					self	:  Dict   ,				__lowerCAmelCase	:  Tuple=None   ,				__lowerCAmelCase	:  Tuple=None   ,				__lowerCAmelCase	:  Dict=True   ,				__lowerCAmelCase	:  Dict="[UNK]"   ,				__lowerCAmelCase	:  str="[SEP]"   ,				__lowerCAmelCase	:  Union[str, Any]="[PAD]"   ,				__lowerCAmelCase	:  Any="[CLS]"   ,				__lowerCAmelCase	:  Optional[int]="[MASK]"   ,				__lowerCAmelCase	:  Optional[int]=True   ,				__lowerCAmelCase	:  Tuple=None   ,				**__lowerCAmelCase	:  int   ,				):
      super().__init__(
          __lowerCAmelCase   ,				tokenizer_file=__lowerCAmelCase   ,				do_lower_case=__lowerCAmelCase   ,				unk_token=__lowerCAmelCase   ,				sep_token=__lowerCAmelCase   ,				pad_token=__lowerCAmelCase   ,				cls_token=__lowerCAmelCase   ,				mask_token=__lowerCAmelCase   ,				tokenize_chinese_chars=__lowerCAmelCase   ,				strip_accents=__lowerCAmelCase   ,				**__lowerCAmelCase   ,				)

      _UpperCAmelCase						 =      json.loads(self.backend_tokenizer.normalizer.__getstate__()					)
      if (
          normalizer_state.get("""lowercase"""   ,				__lowerCAmelCase					) != do_lower_case
          or normalizer_state.get("""strip_accents"""   ,				__lowerCAmelCase					) != strip_accents
          or normalizer_state.get("""handle_chinese_chars"""   ,				__lowerCAmelCase					) != tokenize_chinese_chars
      ):
        _UpperCAmelCase						 =      getattr(__lowerCAmelCase   ,				normalizer_state.pop("""type"""					)					)
        _UpperCAmelCase						 =      do_lower_case
        _UpperCAmelCase						 =      strip_accents
        _UpperCAmelCase						 =      tokenize_chinese_chars
        _UpperCAmelCase						 =      normalizer_class(**__lowerCAmelCase					)

      _UpperCAmelCase						 =      do_lower_case


    def      lowerCAmelCase_  (					self	:  str   ,				__lowerCAmelCase	:  Tuple   ,				__lowerCAmelCase	:  List[Any]=None					):
      _UpperCAmelCase						 =      [self.cls_token_id] + token_ids_a + [self.sep_token_id]

      if token_ids_a:
        output += token_ids_a + [self.sep_token_id]

      return output


    def      lowerCAmelCase_  (					self	:  Tuple   ,				__lowerCAmelCase	:  List[int]   ,				__lowerCAmelCase	:  Optional[List[int]] = None					):
      _UpperCAmelCase						 =      [self.sep_token_id]
      _UpperCAmelCase						 =      [self.cls_token_id]
      if token_ids_a is None:
        return len(cls + token_ids_a + sep					) * [0]
      return len(cls + token_ids_a + sep					) * [0] + len(token_ids_a + sep					) * [1]


    def      lowerCAmelCase_  (					self	:  Any   ,				__lowerCAmelCase	:  str   ,				__lowerCAmelCase	:  Optional[str] = None					):
      _UpperCAmelCase						 =      self._tokenizer.model.save(__lowerCAmelCase   ,				name=__lowerCAmelCase					)
      return tuple(__lowerCAmelCase					)

"""simple docstring"""


from argparse import ArgumentParser, Namespace
from typing import Any, List, Optional

from ..pipelines import Pipeline, get_supported_tasks, pipeline
from ..utils import logging
from . import BaseTransformersCLICommand


try:
    from fastapi import Body, FastAPI, HTTPException
    from fastapi.routing import APIRoute
    from pydantic import BaseModel
    from starlette.responses import JSONResponse
    from uvicorn import run

    UpperCAmelCase__  		=						True
except (ImportError, AttributeError):
    UpperCAmelCase__  		=						object






    def     __UpperCAmelCase					(			*lowercase   ,**lowercase		):







      """simple docstring"""
      pass

    UpperCAmelCase__  		=						False


UpperCAmelCase__  		=						logging.get_logger("""transformers-cli/serving""")






def     __UpperCAmelCase					(			lowercase		):







  """simple docstring"""
  _UpperCAmelCase						 =      pipeline(
      task=args.task   ,model=args.model if args.model else None   ,config=args.config   ,tokenizer=args.tokenizer   ,device=args.device   ,)
  return ServeCommand(lowercase   ,args.host   ,args.port   ,args.workers		)


class        a				(		lowerCAmelCase_   ):
    _snake_case     :  dict



class        a				(		lowerCAmelCase_   ):
    _snake_case     :  List[str]
    _snake_case     :  Optional[List[int]]



class        a				(		lowerCAmelCase_   ):
    _snake_case     :  str



class        a				(		lowerCAmelCase_   ):
    _snake_case     :  Any



class        a				(		lowerCAmelCase_   ):


    @staticmethod
    def      lowerCAmelCase_  (					__lowerCAmelCase	:  ArgumentParser					):
      _UpperCAmelCase						 =      parser.add_parser(
          """serve"""   ,				help="""CLI tool to run inference requests through REST and GraphQL endpoints."""					)
      serve_parser.add_argument(
          """--task"""   ,				type=__lowerCAmelCase   ,				choices=get_supported_tasks()   ,				help="""The task to run the pipeline on"""   ,				)
      serve_parser.add_argument("""--host"""   ,				type=__lowerCAmelCase   ,				default="""localhost"""   ,				help="""Interface the server will listen on."""					)
      serve_parser.add_argument("""--port"""   ,				type=__lowerCAmelCase   ,				default=8888   ,				help="""Port the serving will listen to."""					)
      serve_parser.add_argument("""--workers"""   ,				type=__lowerCAmelCase   ,				default=1   ,				help="""Number of http workers"""					)
      serve_parser.add_argument("""--model"""   ,				type=__lowerCAmelCase   ,				help="""Model's name or path to stored model."""					)
      serve_parser.add_argument("""--config"""   ,				type=__lowerCAmelCase   ,				help="""Model's config name or path to stored model."""					)
      serve_parser.add_argument("""--tokenizer"""   ,				type=__lowerCAmelCase   ,				help="""Tokenizer name to use."""					)
      serve_parser.add_argument(
          """--device"""   ,				type=__lowerCAmelCase   ,				default=-1   ,				help="""Indicate the device to run onto, -1 indicates CPU, >= 0 indicates GPU (default: -1)"""   ,				)
      serve_parser.set_defaults(func=__lowerCAmelCase					)


    def __init__(					self	:  Tuple   ,				__lowerCAmelCase	:  Pipeline   ,				__lowerCAmelCase	:  str   ,				__lowerCAmelCase	:  int   ,				__lowerCAmelCase	:  int					):
      _UpperCAmelCase						 =      pipeline

      _UpperCAmelCase						 =      host
      _UpperCAmelCase						 =      port
      _UpperCAmelCase						 =      workers

      if not _serve_dependencies_installed:
        raise RuntimeError(
            """Using serve command requires FastAPI and uvicorn. """
            """Please install transformers with [serving]: pip install \"transformers[serving]\"."""
            """Or install FastAPI and uvicorn separately."""					)
      else:
        logger.info(f'''Serving model over {host}:{port}'''					)
        _UpperCAmelCase						 =      FastAPI(
            routes=[
                APIRoute(
                    """/"""   ,				self.model_info   ,				response_model=__lowerCAmelCase   ,				response_class=__lowerCAmelCase   ,				methods=["""GET"""]   ,				),
                APIRoute(
                    """/tokenize"""   ,				self.tokenize   ,				response_model=__lowerCAmelCase   ,				response_class=__lowerCAmelCase   ,				methods=["""POST"""]   ,				),
                APIRoute(
                    """/detokenize"""   ,				self.detokenize   ,				response_model=__lowerCAmelCase   ,				response_class=__lowerCAmelCase   ,				methods=["""POST"""]   ,				),
                APIRoute(
                    """/forward"""   ,				self.forward   ,				response_model=__lowerCAmelCase   ,				response_class=__lowerCAmelCase   ,				methods=["""POST"""]   ,				),
            ]   ,				timeout=600   ,				)


    def      lowerCAmelCase_  (					self	:  Optional[int]					):
      run(self._app   ,				host=self.host   ,				port=self.port   ,				workers=self.workers					)


    def      lowerCAmelCase_  (					self	:  str					):
      return ServeModelInfoResult(infos=vars(self._pipeline.model.config					)					)


    def      lowerCAmelCase_  (					self	:  Tuple   ,				__lowerCAmelCase	:  str = Body(__lowerCAmelCase   ,				embed=__lowerCAmelCase					)   ,				__lowerCAmelCase	:  bool = Body(__lowerCAmelCase   ,				embed=__lowerCAmelCase					)					):
      try:
        _UpperCAmelCase						 =      self._pipeline.tokenizer.tokenize(__lowerCAmelCase					)

        if return_ids:
          _UpperCAmelCase						 =      self._pipeline.tokenizer.convert_tokens_to_ids(__lowerCAmelCase					)
          return ServeTokenizeResult(tokens=__lowerCAmelCase   ,				tokens_ids=__lowerCAmelCase					)
        else:
          return ServeTokenizeResult(tokens=__lowerCAmelCase					)

      except Exception as e:
        raise HTTPException(status_code=500   ,				detail={"""model""": """""", """error""": str(__lowerCAmelCase					)}					)


    def      lowerCAmelCase_  (					self	:  int   ,				__lowerCAmelCase	:  List[int] = Body(__lowerCAmelCase   ,				embed=__lowerCAmelCase					)   ,				__lowerCAmelCase	:  bool = Body(__lowerCAmelCase   ,				embed=__lowerCAmelCase					)   ,				__lowerCAmelCase	:  bool = Body(__lowerCAmelCase   ,				embed=__lowerCAmelCase					)   ,				):
      try:
        _UpperCAmelCase						 =      self._pipeline.tokenizer.decode(__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase					)
        return ServeDeTokenizeResult(model=""""""   ,				text=__lowerCAmelCase					)
      except Exception as e:
        raise HTTPException(status_code=500   ,				detail={"""model""": """""", """error""": str(__lowerCAmelCase					)}					)


    async def      lowerCAmelCase_  (					self	:  str   ,				__lowerCAmelCase	:  List[Any]=Body(__lowerCAmelCase   ,				embed=__lowerCAmelCase					)					):

      # Check we don't have empty string
      if len(__lowerCAmelCase					) == 0:
        return ServeForwardResult(output=[]   ,				attention=[]					)

      try:
        # Forward through the model
        _UpperCAmelCase						 =      self._pipeline(__lowerCAmelCase					)
        return ServeForwardResult(output=__lowerCAmelCase					)
      except Exception as e:
        raise HTTPException(500   ,				{"""error""": str(__lowerCAmelCase					)}					)
