




class 			_UpperCamelCase      :
      def __init__(			self   :Optional[Any] ,      lowerCamelCase   :int      )     ->			Union[str, Any]:
       UpperCAmelCase__							 =						n
       UpperCAmelCase__							 =						[None] * self.n
       UpperCAmelCase__							 =						0  # index of the first element
       UpperCAmelCase__							 =						0
       UpperCAmelCase__							 =						0
      def __len__(			self   :Optional[Any]      )     ->			int:
       return self.size
      def 	UpperCAmelCase_						(			self   :Dict      )     ->			bool:
       return self.size == 0
      def 	UpperCAmelCase_						(			self   :Optional[Any]      )     ->			List[str]:
       return False if self.is_empty() else self.array[self.front]
      def 	UpperCAmelCase_						(			self   :Union[str, Any] ,      lowerCamelCase   :Tuple      )     ->			Optional[Any]:
       if self.size >= self.n:
        raise Exception("QUEUE IS FULL"      )

       UpperCAmelCase__							 =						data
       UpperCAmelCase__							 =						(self.rear + 1) % self.n
       self.size += 1
       return self







      def 	UpperCAmelCase_						(			self   :Dict      )     ->			Union[str, Any]:
       if self.size == 0:
        raise Exception("UNDERFLOW"      )

       UpperCAmelCase__							 =						self.array[self.front]
       UpperCAmelCase__							 =						None
       UpperCAmelCase__							 =						(self.front + 1) % self.n
       self.size -= 1
       return temp











import argparse

from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird
from transformers.utils import logging


logging.set_verbosity_info()



def 						lowerCAmelCase		(		_lowerCAmelCase							:   Any						,							_lowerCAmelCase							:   List[str]						,							_lowerCAmelCase							:   Optional[int]						,							_lowerCAmelCase							:   Union[str, Any]	):




 """simple docstring"""







 UpperCAmelCase__							 =						BigBirdConfig.from_json_file(_lowerCAmelCase	)
 print(F'''Building PyTorch model from configuration: {config}'''	)

 if is_trivia_qa:
  UpperCAmelCase__							 =						BigBirdForQuestionAnswering(_lowerCAmelCase	)
 else:
  UpperCAmelCase__							 =						BigBirdForPreTraining(_lowerCAmelCase	)

 # Load weights from tf checkpoint
 load_tf_weights_in_big_bird(_lowerCAmelCase						,							_lowerCAmelCase						,							is_trivia_qa=_lowerCAmelCase	)

 # Save pytorch-model
 print(F'''Save PyTorch model to {pytorch_dump_path}'''	)
 model.save_pretrained(_lowerCAmelCase	)


if __name__ == "__main__":
  _lowerCAmelCase						:   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(
      "--big_bird_config_file",
      default=None,
      type=str,
      required=True,
      help=(
          "The config json file corresponding to the pre-trained BERT model. \n"
          "This specifies the model architecture."
      ),
  )
  parser.add_argument(
      "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
  )
  parser.add_argument(
      "--is_trivia_qa", action="store_true", help="Whether to convert a model with a trivia_qa head."
  )
  _lowerCAmelCase						:   Dict		=   parser.parse_args()
  convert_tf_checkpoint_to_pytorch(
      args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa
  )





