

'''simple docstring'''


from pickle import UnpicklingError

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict

from ..utils import logging


lowerCAmelCase__						:       List[str]										=						logging.get_logger(__name__)




def 	_a       (				__lowerCAmelCase		:      Any   ,							__lowerCAmelCase		:      Any     ):

		"""simple docstring"""

		try:
				with open(__lowerCAmelCase   ,							'''rb'''     ) as flax_state_f:
						snake_case__						:       Any       						=  from_bytes(__lowerCAmelCase   ,							flax_state_f.read()     )
		except UnpicklingError as e:
				try:
						with open(__lowerCAmelCase     ) as f:
								if f.read().startswith('''version'''     ):
										raise OSError(
										    '''You seem to have cloned a repository without having git-lfs installed. Please'''
										    ''' install git-lfs and run `git lfs install` followed by `git lfs pull` in the'''
										    ''' folder you cloned.'''     )
								else:
										raise ValueError from e
				except (UnicodeDecodeError, ValueError):
						raise EnvironmentError(F"""Unable to convert {model_file} to Flax deserializable object. """     )

		return load_flax_weights_in_pytorch_model(__lowerCAmelCase   ,							__lowerCAmelCase     )





def 	_a       (				__lowerCAmelCase		:      Union[str, Any]   ,							__lowerCAmelCase		:      List[Any]     ):

		"""simple docstring"""

		try:
				import torch  # noqa: F401
		except ImportError:
				logger.error(
				    '''Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see'''
				    ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation'''
				    ''' instructions.'''     )
				raise

		# check if we have bf16 weights
		snake_case__						:       int       						=  flatten_dict(jax.tree_util.tree_map(lambda __lowerCAmelCase     : x.dtype == jnp.bfloataa   ,							__lowerCAmelCase     )     ).values()
		if any(__lowerCAmelCase     ):
				# convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16

				# and bf16 is not fully supported in PT yet.
				logger.warning(
				    '''Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` '''
				    '''before loading those in PyTorch model.'''     )
				snake_case__						:       int       						=  jax.tree_util.tree_map(
				    lambda __lowerCAmelCase     : params.astype(np.floataa     ) if params.dtype == jnp.bfloataa else params   ,							__lowerCAmelCase     )

		snake_case__						:       int       						=  ''''''

		snake_case__						:       Tuple       						=  flatten_dict(__lowerCAmelCase   ,							sep='''.'''     )
		snake_case__						:       int       						=  pt_model.state_dict()

		# keep track of unexpected & missing keys
		snake_case__						:       Dict       						=  []
		snake_case__						:       Optional[Any]       						=  set(pt_model_dict.keys()     )

		for flax_key_tuple, flax_tensor in flax_state_dict.items():
				snake_case__						:       Dict       						=  flax_key_tuple.split('''.'''     )

				if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
						snake_case__						:       Optional[Any]       						=  flax_key_tuple_array[:-1] + ['''weight''']
						snake_case__						:       Any       						=  jnp.transpose(__lowerCAmelCase   ,							(3, 2, 0, 1)     )
				elif flax_key_tuple_array[-1] == "kernel":
						snake_case__						:       str       						=  flax_key_tuple_array[:-1] + ['''weight''']
						snake_case__						:       List[Any]       						=  flax_tensor.T
				elif flax_key_tuple_array[-1] == "scale":
						snake_case__						:       Dict       						=  flax_key_tuple_array[:-1] + ['''weight''']

				if "time_embedding" not in flax_key_tuple_array:
						for i, flax_key_tuple_string in enumerate(__lowerCAmelCase     ):
								snake_case__						:       Optional[int]       						=  (
								    flax_key_tuple_string.replace('''_0'''   ,							'''.0'''     )
								    .replace('''_1'''   ,							'''.1'''     )
								    .replace('''_2'''   ,							'''.2'''     )
								    .replace('''_3'''   ,							'''.3'''     )
								    .replace('''_4'''   ,							'''.4'''     )
								    .replace('''_5'''   ,							'''.5'''     )
								    .replace('''_6'''   ,							'''.6'''     )
								    .replace('''_7'''   ,							'''.7'''     )
								    .replace('''_8'''   ,							'''.8'''     )
								    .replace('''_9'''   ,							'''.9'''     )
								)

				snake_case__						:       int       						=  '''.'''.join(__lowerCAmelCase     )

				if flax_key in pt_model_dict:
						if flax_tensor.shape != pt_model_dict[flax_key].shape:
								raise ValueError(
								    F"""Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected """
								    F"""to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}."""     )
						else:
								# add weight to pytorch dict
								snake_case__						:       Any       						=  np.asarray(__lowerCAmelCase     ) if not isinstance(__lowerCAmelCase   ,							np.ndarray     ) else flax_tensor
								snake_case__						:       int       						=  torch.from_numpy(__lowerCAmelCase     )
								# remove from missing keys
								missing_keys.remove(__lowerCAmelCase     )
				else:
						# weight is not expected by PyTorch model
						unexpected_keys.append(__lowerCAmelCase     )

		pt_model.load_state_dict(__lowerCAmelCase     )

		# re-transform missing_keys to list
		snake_case__						:       int       						=  list(__lowerCAmelCase     )

		if len(__lowerCAmelCase     ) > 0:
				logger.warning(
				    '''Some weights of the Flax model were not used when initializing the PyTorch model'''
				    F""" {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing"""
				    F""" {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture"""
				    ''' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This'''
				    F""" IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect"""
				    ''' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a'''
				    ''' FlaxBertForSequenceClassification model).'''     )
		if len(__lowerCAmelCase     ) > 0:
				logger.warning(
				    F"""Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly"""
				    F""" initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to"""
				    ''' use it for predictions and inference.'''     )

		return pt_model






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

					lowerCAmelCase__						:       Any										=						True
except (ImportError, AttributeError):
					lowerCAmelCase__						:       Dict										=						object




					def 	_a       (				*__lowerCAmelCase		:      List[str]   ,							**__lowerCAmelCase		:      Tuple     ):

							"""simple docstring"""

							pass





					lowerCAmelCase__						:       str										=						False


lowerCAmelCase__						:       List[str]										=						logging.get_logger("""transformers-cli/serving""")




def 	_a       (				__lowerCAmelCase		:      Namespace     ):

		"""simple docstring"""

		snake_case__						:       Union[str, Any]       						=  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     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    42





class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    42
						__UpperCAmelCase			     =    42





class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    42





class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    42





class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						@staticmethod
						def       __magic_name__							(							snake_case_					:      ArgumentParser  ):



								'''simple docstring'''



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







						def __init__(							self					:      Union[str, Any]			,			snake_case_					:      Pipeline			,			snake_case_					:      str			,			snake_case_					:      int			,			snake_case_					:      int  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  pipeline

								snake_case__						:       Tuple       						=  host
								snake_case__						:       Optional[Any]       						=  port
								snake_case__						:       Tuple       						=  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}"""  )
										snake_case__						:       str       						=  FastAPI(
										    routes=[
										        APIRoute(
										            '''/'''			,			self.model_info			,			response_model=snake_case_			,			response_class=snake_case_			,			methods=['''GET''']			,			),
										        APIRoute(
										            '''/tokenize'''			,			self.tokenize			,			response_model=snake_case_			,			response_class=snake_case_			,			methods=['''POST''']			,			),
										        APIRoute(
										            '''/detokenize'''			,			self.detokenize			,			response_model=snake_case_			,			response_class=snake_case_			,			methods=['''POST''']			,			),
										        APIRoute(
										            '''/forward'''			,			self.forward			,			response_model=snake_case_			,			response_class=snake_case_			,			methods=['''POST''']			,			),
										    ]			,			timeout=6_0_0			,			)







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



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







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



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







						def       __magic_name__							(							self					:      List[str]			,			snake_case_					:      str = Body(snake_case_			,			embed=snake_case_  )			,			snake_case_					:      bool = Body(snake_case_			,			embed=snake_case_  )  ):



								'''simple docstring'''



								try:
										snake_case__						:       Optional[Any]       						=  self._pipeline.tokenizer.tokenize(snake_case_  )

										if return_ids:
												snake_case__						:       Optional[int]       						=  self._pipeline.tokenizer.convert_tokens_to_ids(snake_case_  )
												return ServeTokenizeResult(tokens=snake_case_			,			tokens_ids=snake_case_  )
										else:
												return ServeTokenizeResult(tokens=snake_case_  )

								except Exception as e:
										raise HTTPException(status_code=5_0_0			,			detail={'''model''': '''''', '''error''': str(snake_case_  )}  )







						def       __magic_name__							(							self					:      List[Any]			,			snake_case_					:      List[int] = Body(snake_case_			,			embed=snake_case_  )			,			snake_case_					:      bool = Body(snake_case_			,			embed=snake_case_  )			,			snake_case_					:      bool = Body(snake_case_			,			embed=snake_case_  )			,			):



								'''simple docstring'''



								try:
										snake_case__						:       Optional[int]       						=  self._pipeline.tokenizer.decode(snake_case_			,			snake_case_			,			snake_case_  )
										return ServeDeTokenizeResult(model=''''''			,			text=snake_case_  )
								except Exception as e:
										raise HTTPException(status_code=5_0_0			,			detail={'''model''': '''''', '''error''': str(snake_case_  )}  )







						async def       __magic_name__							(							self					:      Tuple			,			snake_case_					:      List[str]=Body(snake_case_			,			embed=snake_case_  )  ):



								'''simple docstring'''



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

								try:
										# Forward through the model
										snake_case__						:       Tuple       						=  self._pipeline(snake_case_  )
										return ServeForwardResult(output=snake_case_  )
								except Exception as e:
										raise HTTPException(5_0_0			,			{'''error''': str(snake_case_  )}  )



