"""simple docstring"""


import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


UpperCAmelCase__  		=						get_tests_dir("""fixtures/test_sentencepiece_with_bytefallback.model""")


@require_sentencepiece
@require_tokenizers
class        a				(		_snake_case	,							unittest.TestCase   ):
    _snake_case     :  Dict     							=							GPTSwaTokenizer
    _snake_case     :  List[str]     							=							False
    _snake_case     :  List[Any]     							=							True
    _snake_case     :  List[Any]     							=							False


    def      lowerCAmelCase_  (					self	:  Tuple					):
      super().setUp()

      # We have a SentencePiece fixture for testing
      _UpperCAmelCase						 =      GPTSwaTokenizer(snake_case_   ,				eos_token="""<unk>"""   ,				bos_token="""<unk>"""   ,				pad_token="""<unk>"""					)

      tokenizer.save_pretrained(self.tmpdirname					)


    def      lowerCAmelCase_  (					self	:  Any   ,				__lowerCAmelCase	:  str					):
      _UpperCAmelCase						 =      "This is a test"
      _UpperCAmelCase						 =      "This is a test"
      return input_text, output_text


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      _UpperCAmelCase						 =      "<s>"
      _UpperCAmelCase						 =      1

      self.assertEqual(self.get_tokenizer()._convert_token_to_id(snake_case_					)   ,				snake_case_					)
      self.assertEqual(self.get_tokenizer()._convert_id_to_token(snake_case_					)   ,				snake_case_					)


    def      lowerCAmelCase_  (					self	:  int					):
      _UpperCAmelCase						 =      list(self.get_tokenizer().get_vocab().keys()					)

      self.assertEqual(vocab_keys[0]   ,				"""<unk>"""					)
      self.assertEqual(vocab_keys[1]   ,				"""<s>"""					)
      self.assertEqual(vocab_keys[-1]   ,				"""j"""					)
      self.assertEqual(len(snake_case_					)   ,				2000					)


    def      lowerCAmelCase_  (					self	:  Optional[int]					):
      self.assertEqual(self.get_tokenizer().vocab_size   ,				2000					)


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      _UpperCAmelCase						 =      GPTSwaTokenizer(snake_case_					)

      _UpperCAmelCase						 =      tokenizer.tokenize("""This is a test"""					)
      self.assertListEqual(snake_case_   ,				["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]					)

      self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case_					)   ,				[465, 287, 265, 631, 842]					)

      _UpperCAmelCase						 =      tokenizer.tokenize("""I was born in 92000, and this is falsé."""					)
      # fmt: off
      self.assertListEqual(
          snake_case_   ,				["""▁I""", """▁was""", """▁bor""", """n""", """▁in""", """▁""", """<0x39>""", """2""", """0""", """0""", """0""", """,""", """▁and""", """▁this""", """▁is""", """▁f""", """al""", """s""", """<0xC3>""", """<0xA9>""", """."""]   ,				)
      # fmt: on

      _UpperCAmelCase						 =      tokenizer.convert_tokens_to_ids(snake_case_					)
      self.assertListEqual(
          snake_case_   ,				[262, 272, 1525, 286, 271, 268, 60, 916, 633, 633, 633, 259, 266, 301, 287, 384, 367, 263, 198, 172, 260]   ,				)

      _UpperCAmelCase						 =      tokenizer.convert_ids_to_tokens(snake_case_					)
      # fmt: off
      self.assertListEqual(
          snake_case_   ,				["""▁I""", """▁was""", """▁bor""", """n""", """▁in""", """▁""", """<0x39>""", """2""", """0""", """0""", """0""", """,""", """▁and""", """▁this""", """▁is""", """▁f""", """al""", """s""", """<0xC3>""", """<0xA9>""", """."""]					)
      # fmt: on


    def      lowerCAmelCase_  (					self	:  List[Any]					):
      _UpperCAmelCase						 =      GPTSwaTokenizer(snake_case_					)
      _UpperCAmelCase						 =      ["This is a test", "I was born in 92000, and this is falsé."]
      _UpperCAmelCase						 =      [
          [465, 287, 265, 631, 842],
          [262, 272, 1525, 286, 271, 268, 60, 916, 633, 633, 633, 259, 266, 301, 287, 384, 367, 263, 198, 172, 260],
      ]

      # Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
      for text, expected_ids in zip(snake_case_   ,				snake_case_					):
        self.assertListEqual(tokenizer.encode_fast(snake_case_					)   ,				snake_case_					)

      # Test that decode_fast returns the input text
      for text, token_ids in zip(snake_case_   ,				snake_case_					):
        self.assertEqual(tokenizer.decode_fast(snake_case_					)   ,				snake_case_					)


    @slow
    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      _UpperCAmelCase						 =      [
          "<|python|>def fibonacci(n)\n    if n < 0:\n        print('Incorrect input')",
          "Hey there, how are you doing this fine day?",
          "This is a text with a trailing spaces followed by a dot     .",
          "Häj sväjs lillebrör! =)",
          "Det är inget fel på Mr. Cool",
      ]

      # fmt: off
      _UpperCAmelCase						 =      {"input_ids": [[6_3423, 5, 6811, 1_4954, 282, 816, 3821, 6_3466, 6_3425, 6_3462, 18, 6_3978, 678, 301, 1320, 6_3423, 6_3455, 6_3458, 18, 6_3982, 4246, 3940, 1901, 4_7789, 5547, 1_8994], [1_9630, 1100, 6_3446, 1342, 633, 544, 4488, 593, 5102, 2416, 6_3495, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1652, 428, 268, 1936, 515, 268, 5_8593, 2_2413, 9106, 546, 268, 3_3213, 6_3979, 698, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_5130, 6_3450, 924, 6_3449, 2249, 4062, 1558, 318, 6_3504, 2_1498, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [509, 377, 2827, 2559, 332, 6575, 6_3443, 2_6801, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "token_type_ids": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
      # fmt: on
      self.tokenizer_integration_test_util(
          expected_encoding=snake_case_   ,				model_name="""AI-Sweden/gpt-sw3-126m"""   ,				sequences=snake_case_   ,				)




"""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					)}					)
