






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

	__a       :	Any             = True
except (ImportError, AttributeError):
	__a       :	Optional[int]             = object





	def        SCREAMING_SNAKE_CASE       (      *lowerCamelCase_ ,     **lowerCamelCase_):
						pass
	__a       :	str             = False


__a       :	Any             = logging.get_logger('transformers-cli/serving')





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					a__          =  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        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =42







class        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =42
							_SCREAMING_SNAKE_CASE    =42







class        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =42







class        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    =42







class        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							@staticmethod
							def  lowercase		(   __A:     ArgumentParser    ):

												'''simple docstring'''

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




							def __init__(   self:     List[Any]				,		__A:     Pipeline				,		__A:     str				,		__A:     int				,		__A:     int    ):

												'''simple docstring'''

												a__          =  pipeline

												a__          =  host
												a__          =  port
												a__          =  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}'    )
																	a__          =  FastAPI(
																	    routes=[
																	        APIRoute(
																	            '''/'''				,		self.model_info				,		response_model=__A				,		response_class=__A				,		methods=['''GET''']				,		),
																	        APIRoute(
																	            '''/tokenize'''				,		self.tokenize				,		response_model=__A				,		response_class=__A				,		methods=['''POST''']				,		),
																	        APIRoute(
																	            '''/detokenize'''				,		self.detokenize				,		response_model=__A				,		response_class=__A				,		methods=['''POST''']				,		),
																	        APIRoute(
																	            '''/forward'''				,		self.forward				,		response_model=__A				,		response_class=__A				,		methods=['''POST''']				,		),
																	    ]				,		timeout=600				,		)




							def  lowercase		(   self:     Dict    ):

												'''simple docstring'''

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




							def  lowercase		(   self:     Optional[int]    ):

												'''simple docstring'''

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




							def  lowercase		(   self:     Optional[Any]				,		__A:     str = Body(__A				,		embed=__A    )				,		__A:     bool = Body(__A				,		embed=__A    )    ):

												'''simple docstring'''

												try:
																	a__          =  self._pipeline.tokenizer.tokenize(__A    )

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

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




							def  lowercase		(   self:     Union[str, Any]				,		__A:     List[int] = Body(__A				,		embed=__A    )				,		__A:     bool = Body(__A				,		embed=__A    )				,		__A:     bool = Body(__A				,		embed=__A    )				,		):

												'''simple docstring'''

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





							async def  lowercase		(   self:     List[Any]				,		__A:     List[str]=Body(__A				,		embed=__A    )    ):

												'''simple docstring'''

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

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










"""simple docstring"""







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__a       :	str             = logging.get_logger(__name__)

__a       :	Dict             = {
    'xlm-mlm-en-2048': 'https://huggingface.co/xlm-mlm-en-2048/resolve/main/config.json',
    'xlm-mlm-ende-1024': 'https://huggingface.co/xlm-mlm-ende-1024/resolve/main/config.json',
    'xlm-mlm-enfr-1024': 'https://huggingface.co/xlm-mlm-enfr-1024/resolve/main/config.json',
    'xlm-mlm-enro-1024': 'https://huggingface.co/xlm-mlm-enro-1024/resolve/main/config.json',
    'xlm-mlm-tlm-xnli15-1024': 'https://huggingface.co/xlm-mlm-tlm-xnli15-1024/resolve/main/config.json',
    'xlm-mlm-xnli15-1024': 'https://huggingface.co/xlm-mlm-xnli15-1024/resolve/main/config.json',
    'xlm-clm-enfr-1024': 'https://huggingface.co/xlm-clm-enfr-1024/resolve/main/config.json',
    'xlm-clm-ende-1024': 'https://huggingface.co/xlm-clm-ende-1024/resolve/main/config.json',
    'xlm-mlm-17-1280': 'https://huggingface.co/xlm-mlm-17-1280/resolve/main/config.json',
    'xlm-mlm-100-1280': 'https://huggingface.co/xlm-mlm-100-1280/resolve/main/config.json',
}







class        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE    ='xlm'
							_SCREAMING_SNAKE_CASE    ={
							    'hidden_size': 'emb_dim',
							    'num_attention_heads': 'n_heads',
							    'num_hidden_layers': 'n_layers',
							    'n_words': 'vocab_size',  # For backward compatibility
							}




							def __init__(   self:     Optional[Any]				,		__A:     str=30145				,		__A:     Union[str, Any]=2048				,		__A:     Union[str, Any]=12				,		__A:     List[Any]=16				,		__A:     List[Any]=0.1				,		__A:     int=0.1				,		__A:     str=True				,		__A:     int=False				,		__A:     Optional[int]=False				,		__A:     Union[str, Any]=False				,		__A:     List[Any]=1				,		__A:     Dict=True				,		__A:     List[Any]=512				,		__A:     Optional[int]=2048**-0.5				,		__A:     Tuple=1e-12				,		__A:     Optional[int]=0.0_2				,		__A:     Optional[int]=0				,		__A:     Union[str, Any]=1				,		__A:     List[Any]=2				,		__A:     Union[str, Any]=3				,		__A:     Tuple=5				,		__A:     Tuple=True				,		__A:     Dict="first"				,		__A:     Optional[int]=True				,		__A:     int=None				,		__A:     Optional[Any]=True				,		__A:     Dict=0.1				,		__A:     Tuple=5				,		__A:     Union[str, Any]=5				,		__A:     Tuple=0				,		__A:     List[str]=0				,		__A:     int=2				,		__A:     Optional[int]=0				,		**__A:     Union[str, Any]				,		):

												'''simple docstring'''

												a__          =  vocab_size
												a__          =  emb_dim
												a__          =  n_layers
												a__          =  n_heads
												a__          =  dropout
												a__          =  attention_dropout
												a__          =  gelu_activation
												a__          =  sinusoidal_embeddings
												a__          =  causal
												a__          =  asm
												a__          =  n_langs
												a__          =  use_lang_emb
												a__          =  layer_norm_eps
												a__          =  bos_index
												a__          =  eos_index
												a__          =  pad_index
												a__          =  unk_index
												a__          =  mask_index
												a__          =  is_encoder
												a__          =  max_position_embeddings
												a__          =  embed_init_std
												a__          =  init_std
												a__          =  summary_type
												a__          =  summary_use_proj
												a__          =  summary_activation
												a__          =  summary_proj_to_labels
												a__          =  summary_first_dropout
												a__          =  start_n_top
												a__          =  end_n_top
												a__          =  mask_token_id
												a__          =  lang_id

												if "n_words" in kwargs:
																	a__          =  kwargs['''n_words''']

												super().__init__(pad_token_id=__A				,		bos_token_id=__A				,		**__A    )







class        _SCREAMING_SNAKE_CASE						(  __snake_case							):





							"""simple docstring"""





							@property
							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												if self.task == "multiple-choice":
																	a__          =  {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
												else:
																	a__          =  {0: '''batch''', 1: '''sequence'''}
												return OrderedDict(
												    [
												        ('''input_ids''', dynamic_axis),
												        ('''attention_mask''', dynamic_axis),
												        ('''token_type_ids''', dynamic_axis),
												    ]    )


