





"""simple docstring"""





from typing import List, Optional, Union

import numpy as np

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


lowerCAmelCase__   	=	logging.get_logger(__name__)





class 				_lowerCamelCase					(				__UpperCAmelCase       ):
						UpperCAmelCase_       =	['''input_values''', '''padding_mask''']


						def __init__(self      ,							__a = 1      ,							__a = 2_40_00      ,							__a = 0.0      ,							__a = None      ,							__a = None      ,							**__a      ,							)       ->      List[Any]:
								super().__init__(feature_size=__SCREAMING_SNAKE_CASE      ,							sampling_rate=__SCREAMING_SNAKE_CASE      ,							padding_value=__SCREAMING_SNAKE_CASE      ,							**__SCREAMING_SNAKE_CASE						)
								UpperCamelCase      =		chunk_length_s
								UpperCamelCase      =		overlap


						@property
						def 			snake_case_      (self						)       ->      Any:

								if self.chunk_length_s is None:
										return None
								else:
										return int(self.chunk_length_s * self.sampling_rate						)


						@property
						def 			snake_case_      (self						)       ->      int:

								if self.chunk_length_s is None or self.overlap is None:
										return None
								else:
										return max(1      ,							int((1.0 - self.overlap) * self.chunk_length						)						)




						def __call__(self      ,							__a      ,							__a = None      ,							__a = False      ,							__a = None      ,							__a = None      ,							__a = None      ,							)       ->      List[Any]:

								if sampling_rate is not None:
										if sampling_rate != self.sampling_rate:
												raise ValueError(
												    F"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
												    F" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"
												    F" {self.sampling_rate} and not {sampling_rate}."						)
								else:
										logger.warning(
										    "It is strongly recommended to pass the `sampling_rate` argument to this function. "
										    "Failing to do so can result in silent errors that might be hard to debug."						)

								if padding and truncation:
										raise ValueError("Both padding and truncation were set. Make sure you only set one."						)
								elif padding is None:
										# by default let's pad the inputs
										UpperCamelCase      =		True

								UpperCamelCase      =		bool(
								    isinstance(__SCREAMING_SNAKE_CASE      ,							(list, tuple)						) and (isinstance(raw_audio[0]      ,							(np.ndarray, tuple, list)						))						)

								if is_batched:
										UpperCamelCase      =		[np.asarray(__SCREAMING_SNAKE_CASE      ,							dtype=np.floataa						).T for audio in raw_audio]
								elif not is_batched and not isinstance(__SCREAMING_SNAKE_CASE      ,							np.ndarray						):
										UpperCamelCase      =		np.asarray(__SCREAMING_SNAKE_CASE      ,							dtype=np.floataa						)
								elif isinstance(__SCREAMING_SNAKE_CASE      ,							np.ndarray						) and raw_audio.dtype is np.dtype(np.floataa						):
										UpperCamelCase      =		raw_audio.astype(np.floataa						)

								# always return batch
								if not is_batched:
										UpperCamelCase      =		[np.asarray(__SCREAMING_SNAKE_CASE						).T]

								# verify inputs are valid
								for idx, example in enumerate(__SCREAMING_SNAKE_CASE						):
										if example.ndim > 2:
												raise ValueError(F"Expected input shape (channels, length) but got shape {example.shape}"						)
										if self.feature_size == 1 and example.ndim != 1:
												raise ValueError(F"Expected mono audio but example has {example.shape[-1]} channels"						)
										if self.feature_size == 2 and example.shape[-1] != 2:
												raise ValueError(F"Expected stereo audio but example has {example.shape[-1]} channels"						)

								UpperCamelCase      =		None
								UpperCamelCase      =		BatchFeature({"input_values": raw_audio}						)
								if self.chunk_stride is not None and self.chunk_length is not None and max_length is None:
										if truncation:
												UpperCamelCase      =		min(array.shape[0] for array in raw_audio						)
												UpperCamelCase      =		int(np.floor(max_length / self.chunk_stride						)						)
												UpperCamelCase      =		(nb_step - 1) * self.chunk_stride + self.chunk_length
										elif padding:
												UpperCamelCase      =		max(array.shape[0] for array in raw_audio						)
												UpperCamelCase      =		int(np.ceil(max_length / self.chunk_stride						)						)
												UpperCamelCase      =		(nb_step - 1) * self.chunk_stride + self.chunk_length
												UpperCamelCase      =		"max_length"
										else:
												UpperCamelCase      =		input_values

        # normal padding on batch
								if padded_inputs is None:
										UpperCamelCase      =		self.pad(
										    __SCREAMING_SNAKE_CASE      ,							max_length=__SCREAMING_SNAKE_CASE      ,							truncation=__SCREAMING_SNAKE_CASE      ,							padding=__SCREAMING_SNAKE_CASE      ,							return_attention_mask=__SCREAMING_SNAKE_CASE      ,							)
										if padding:
												UpperCamelCase      =		padded_inputs.pop("attention_mask"						)

								UpperCamelCase      =		[]
								for example in padded_inputs.pop("input_values"						):
										if self.feature_size == 1:
												UpperCamelCase      =		example[..., None]
										input_values.append(example.T						)

								UpperCamelCase      =		input_values
								if return_tensors is not None:
										UpperCamelCase      =		padded_inputs.convert_to_tensors(__SCREAMING_SNAKE_CASE						)

								return padded_inputs











import argparse

import torch

from transformers import LxmertConfig, LxmertForPreTraining, load_tf_weights_in_lxmert
from transformers.utils import logging


logging.set_verbosity_info()





def      __snake_case	(			_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase				):
    # Initialise PyTorch model
    __a						       =				LxmertConfig.from_json_file(_UpperCAmelCase				)
    print(f'Building PyTorch model from configuration: {config}'				)
    __a						       =				LxmertForPreTraining(_UpperCAmelCase				)

    # Load weights from tf checkpoint
    load_tf_weights_in_lxmert(_UpperCAmelCase   , _UpperCAmelCase   , _UpperCAmelCase				)

    # Save pytorch-model
    print(f'Save PyTorch model to {pytorch_dump_path}'				)
    torch.save(model.state_dict()   , _UpperCAmelCase				)


if __name__ == "__main__":
 __snake_case						:List[Any]      		=     argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
 )
 parser.add_argument(
     '''--config_file''',
     default=None,
     type=str,
     required=True,
     help='''The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.''',
 )
 parser.add_argument(
     '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
 )
 __snake_case						:Optional[Any]      		=     parser.parse_args()
 convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)





