






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


SCREAMING_SNAKE_CASE__      :			Any							=		logging.get_logger(__name__)

def      __lowercase					( snake_case,  snake_case ):







				"""simple docstring"""






				try:
								with open(snake_case,  '''rb''' ) as flax_state_f:
												__magic_name__		:Optional[int]        =      from_bytes(snake_case,  flax_state_f.read() )
				except UnpicklingError as e:
								try:
												with open(snake_case ) 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(snake_case,  snake_case )

def      __lowercase					( snake_case,  snake_case ):







				"""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
				__magic_name__		:str        =      flatten_dict(jax.tree_util.tree_map(lambda snake_case : x.dtype == jnp.bfloataa,  snake_case ) ).values()
				if any(snake_case ):
								# 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.''' )
								__magic_name__		:Optional[Any]        =      jax.tree_util.tree_map(
								    lambda snake_case : params.astype(np.floataa ) if params.dtype == jnp.bfloataa else params,  snake_case )

				__magic_name__		:Optional[int]        =      ''''''

				__magic_name__		:List[str]        =      flatten_dict(snake_case,  sep='''.''' )
				__magic_name__		:Union[str, Any]        =      pt_model.state_dict()

				# keep track of unexpected & missing keys
				__magic_name__		:str        =      []
				__magic_name__		:Tuple        =      set(pt_model_dict.keys() )

				for flax_key_tuple, flax_tensor in flax_state_dict.items():
								__magic_name__		:List[Any]        =      flax_key_tuple.split('''.''' )

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

								if "time_embedding" not in flax_key_tuple_array:
												for i, flax_key_tuple_string in enumerate(snake_case ):
																__magic_name__		: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''' )
																)

								__magic_name__		:Tuple        =      '''.'''.join(snake_case )

								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
																__magic_name__		:Optional[Any]        =      np.asarray(snake_case ) if not isinstance(snake_case,  np.ndarray ) else flax_tensor
																__magic_name__		:Any        =      torch.from_numpy(snake_case )
																# remove from missing keys
																missing_keys.remove(snake_case )
								else:
												# weight is not expected by PyTorch model
												unexpected_keys.append(snake_case )

				pt_model.load_state_dict(snake_case )

				# re-transform missing_keys to list
				__magic_name__		:Optional[int]        =      list(snake_case )

				if len(snake_case ) > 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(snake_case ) > 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














from ...processing_utils import ProcessorMixin
class 						lowerCamelCase_				(      lowerCamelCase ):
				a__					       =  '''WhisperFeatureExtractor'''
				a__					       =  '''WhisperTokenizer'''







				def __init__(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase     ):
								"""simple docstring"""
								super().__init__(__lowerCAmelCase       ,					__lowerCAmelCase     )
								__magic_name__		:int        =      self.feature_extractor
								__magic_name__		:int        =      False







				def 			A	(						self       ,					__lowerCAmelCase=None       ,					__lowerCAmelCase=None       ,					__lowerCAmelCase=True     ):
								"""simple docstring"""
								return self.tokenizer.get_decoder_prompt_ids(task=__lowerCAmelCase       ,					language=__lowerCAmelCase       ,					no_timestamps=__lowerCAmelCase     )







				def __call__(						self       ,					*__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								# For backward compatibility
								if self._in_target_context_manager:
												return self.current_processor(*__lowerCAmelCase       ,					**__lowerCAmelCase     )

								__magic_name__		:List[Any]        =      kwargs.pop('''audio'''       ,					__lowerCAmelCase     )
								__magic_name__		:Any        =      kwargs.pop('''sampling_rate'''       ,					__lowerCAmelCase     )
								__magic_name__		:str        =      kwargs.pop('''text'''       ,					__lowerCAmelCase     )
								if len(__lowerCAmelCase     ) > 0:
												__magic_name__		:Any        =      args[0]
												__magic_name__		:Union[str, Any]        =      args[1:]

								if audio is None and text is None:
												raise ValueError('''You need to specify either an `audio` or `text` input to process.'''     )

								if audio is not None:
												__magic_name__		:Optional[int]        =      self.feature_extractor(__lowerCAmelCase       ,					*__lowerCAmelCase       ,					sampling_rate=__lowerCAmelCase       ,					**__lowerCAmelCase     )
								if text is not None:
												__magic_name__		:Optional[int]        =      self.tokenizer(__lowerCAmelCase       ,					**__lowerCAmelCase     )

								if text is None:
												return inputs

								elif audio is None:
												return encodings
								else:
												__magic_name__		:str        =      encodings['''input_ids''']
												return inputs







				def 			A	(						self       ,					*__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								return self.tokenizer.batch_decode(*__lowerCAmelCase       ,					**__lowerCAmelCase     )







				def 			A	(						self       ,					*__lowerCAmelCase       ,					**__lowerCAmelCase     ):
								"""simple docstring"""
								return self.tokenizer.decode(*__lowerCAmelCase       ,					**__lowerCAmelCase     )







				def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase="np"     ):
								"""simple docstring"""
								return self.tokenizer.get_prompt_ids(__lowerCAmelCase       ,					return_tensors=__lowerCAmelCase     )






