


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_(					*_A :int					,  **_A :Any	)->		List[Any]:
									pass







						__UpperCamelCase     		=							False


__UpperCamelCase     		=							logging.get_logger('transformers-cli/serving')
def 							UpperCamelCase_(					_A :Namespace	)->		Tuple:
			UpperCamelCase__       =							pipeline(
			    task=args.task					,  model=args.model if args.model else None					,  config=args.config					,  tokenizer=args.tokenizer					,  device=args.device					,  )
			return ServeCommand(lowerCamelCase_					,  args.host					,  args.port					,  args.workers	)







class 							lowerCamelCase__						(				SCREAMING_SNAKE_CASE__   ):






			"""simple docstring"""






			_UpperCamelCase		:       List[str] 			=		42







class 							lowerCamelCase__						(				SCREAMING_SNAKE_CASE__   ):






			"""simple docstring"""






			_UpperCamelCase		:       Any 			=		42
			_UpperCamelCase		:       Dict 			=		42







class 							lowerCamelCase__						(				SCREAMING_SNAKE_CASE__   ):






			"""simple docstring"""






			_UpperCamelCase		:       List[Any] 			=		42







class 							lowerCamelCase__						(				SCREAMING_SNAKE_CASE__   ):






			"""simple docstring"""






			_UpperCamelCase		:       List[str] 			=		42







class 							lowerCamelCase__						(				SCREAMING_SNAKE_CASE__   ):






			"""simple docstring"""






			@staticmethod
			def 					snake_case__					(				snake_case  ):

						'''simple docstring'''


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




			def __init__(				self   ,    snake_case   ,    snake_case   ,    snake_case   ,    snake_case  ):

						'''simple docstring'''


						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=_lowercase   ,    response_class=_lowercase   ,    methods=["GET"]   ,    ),
									        APIRoute(
									            "/tokenize"   ,    self.tokenize   ,    response_model=_lowercase   ,    response_class=_lowercase   ,    methods=["POST"]   ,    ),
									        APIRoute(
									            "/detokenize"   ,    self.detokenize   ,    response_model=_lowercase   ,    response_class=_lowercase   ,    methods=["POST"]   ,    ),
									        APIRoute(
									            "/forward"   ,    self.forward   ,    response_model=_lowercase   ,    response_class=_lowercase   ,    methods=["POST"]   ,    ),
									    ]   ,    timeout=600   ,    )




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						run(self._app   ,    host=self.host   ,    port=self.port   ,    workers=self.workers  )




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						return ServeModelInfoResult(infos=vars(self._pipeline.model.config  )  )




			def 					snake_case__					(				self   ,    snake_case = Body(_lowercase   ,    embed=_lowercase  )   ,    snake_case = Body(_lowercase   ,    embed=_lowercase  )  ):

						'''simple docstring'''


						try:
									UpperCamelCase__       =							self._pipeline.tokenizer.tokenize(_lowercase  )

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

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




			def 					snake_case__					(				self   ,    snake_case = Body(_lowercase   ,    embed=_lowercase  )   ,    snake_case = Body(_lowercase   ,    embed=_lowercase  )   ,    snake_case = Body(_lowercase   ,    embed=_lowercase  )   ,    ):

						'''simple docstring'''


						try:
									UpperCamelCase__       =							self._pipeline.tokenizer.decode(_lowercase   ,    _lowercase   ,    _lowercase  )
									return ServeDeTokenizeResult(model=""   ,    text=_lowercase  )
						except Exception as e:
									raise HTTPException(status_code=500   ,    detail={"model": "", "error": str(_lowercase  )}  )







			async def 					snake_case__					(				self   ,    snake_case=Body(_lowercase   ,    embed=_lowercase  )  ):

						'''simple docstring'''


						if len(_lowercase  ) == 0:
									return ServeForwardResult(output=[]   ,    attention=[]  )

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







"""simple docstring"""







import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
			from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
			from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
			from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


A		=						DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

A		=						'main'
# Default branch name
A		=						'f2c752cfc5c0ab6f4bdec59acea69eefbee381c2'
# One particular commit (not the top of `main`)
A		=						'aaaaaaa'
# This commit does not exist, so we should 404.

A		=						'd9e9f15bc825e4b2c9249e9578f884bbcb5e3684'
# Sha-1 of config.json on the top of `main`, for checking purposes
A		=						'4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3'

@contextlib.contextmanager
def  __SCREAMING_SNAKE_CASE		(			):
						"""simple docstring"""






						print("Welcome!" )
						yield
						print("Bye!" )

@contextlib.contextmanager
def  __SCREAMING_SNAKE_CASE		(			):
						"""simple docstring"""






						print("Bonjour!" )
						yield
						print("Au revoir!" )

class       _a  ( unittest.TestCase):



			def 				__lowercase					(			self							:				Dict		)							->					Optional[int]:
									# If the spec is missing, importlib would not be able to import the module dynamically.
									assert transformers.__spec__ is not None
									assert importlib.util.find_spec("transformers"		) is not None



class       _a  ( unittest.TestCase):



			@unittest.mock.patch("sys.stdout"   ,	new_callable=io.StringIO		)
			def 				__lowercase					(			self							:				Union[str, Any]   ,	_lowercase							:				Optional[int]		)							->					Optional[Any]:
									with ContextManagers([]		):
															print("Transformers are awesome!"		)
									# The print statement adds a new line at the end of the output
									self.assertEqual(mock_stdout.getvalue()   ,	"Transformers are awesome!\n"		)



			@unittest.mock.patch("sys.stdout"   ,	new_callable=io.StringIO		)
			def 				__lowercase					(			self							:				Any   ,	_lowercase							:				Any		)							->					Dict:
									with ContextManagers([context_en()]		):
															print("Transformers are awesome!"		)
									# The output should be wrapped with an English welcome and goodbye
									self.assertEqual(mock_stdout.getvalue()   ,	"Welcome!\nTransformers are awesome!\nBye!\n"		)



			@unittest.mock.patch("sys.stdout"   ,	new_callable=io.StringIO		)
			def 				__lowercase					(			self							:				str   ,	_lowercase							:				List[Any]		)							->					Optional[int]:
									with ContextManagers([context_fr(), context_en()]		):
															print("Transformers are awesome!"		)
									# The output should be wrapped with an English and French welcome and goodbye
									self.assertEqual(mock_stdout.getvalue()   ,	"Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"		)



			@require_torch
			def 				__lowercase					(			self							:				Any		)							->					Union[str, Any]:
									self.assertEqual(find_labels(_lowercase		)   ,	["labels"]		)
									self.assertEqual(find_labels(_lowercase		)   ,	["labels", "next_sentence_label"]		)
									self.assertEqual(find_labels(_lowercase		)   ,	["start_positions", "end_positions"]		)

									class       _a  ( SCREAMING_SNAKE_CASE__):
												pass



									self.assertEqual(find_labels(_lowercase		)   ,	["labels"]		)



			@require_tf
			def 				__lowercase					(			self							:				Optional[Any]		)							->					int:
									self.assertEqual(find_labels(_lowercase		)   ,	["labels"]		)
									self.assertEqual(find_labels(_lowercase		)   ,	["labels", "next_sentence_label"]		)
									self.assertEqual(find_labels(_lowercase		)   ,	["start_positions", "end_positions"]		)

									class       _a  ( SCREAMING_SNAKE_CASE__):
												pass



									self.assertEqual(find_labels(_lowercase		)   ,	["labels"]		)



			@require_flax
			def 				__lowercase					(			self							:				Tuple		)							->					List[Any]:
									# Flax models don't have labels
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)
									self.assertEqual(find_labels(_lowercase		)   ,	[]		)

									class       _a  ( SCREAMING_SNAKE_CASE__):
												pass



									self.assertEqual(find_labels(_lowercase		)   ,	[]		)



