
'''simple docstring'''

import argparse

import torch

from transformers import FunnelBaseModel, FunnelConfig, FunnelModel, load_tf_weights_in_funnel
from transformers.utils import logging


logging.set_verbosity_info()







def     snake_case__						(   UpperCamelCase      ,UpperCamelCase      ,UpperCamelCase      ,UpperCamelCase						)			->   List[str]:
		_UpperCamelCase							:			Dict     =   FunnelConfig.from_json_file(snake_case__						)
		print(f'''Building PyTorch model from configuration: {config}'''						)
		_UpperCamelCase							:			Optional[Any]     =   FunnelBaseModel(snake_case__						) if base_model else FunnelModel(snake_case__						)

		# Load weights from tf checkpoint
		load_tf_weights_in_funnel(snake_case__      ,snake_case__      ,snake_case__						)

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


if __name__ == "__main__":
	_UpperCAmelCase :   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."""
	)
	parser.add_argument(
	    """--base_model""", action="""store_true""", help="""Whether you want just the base model (no decoder) or not."""
	)
	_UpperCAmelCase :   str			    =	parser.parse_args()
	convert_tf_checkpoint_to_pytorch(
	    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
	)













from collections.abc import Callable




class       snake_case__ :

       '''simple docstring'''



       def __init__(				self      ,    a__ = None     )			->   None:






            '''simple docstring'''





            __snake_case      :list 							=    []
            # Stores indexes of each item for supporting updates and deletion.
            __snake_case      :dict 							=    {}
            # Stores current size of heap.
            __snake_case      :List[Any] 							=    0
            # Stores function used to evaluate the score of an item on which basis ordering
            # will be done.
            __snake_case      :Optional[Any] 							=    key or (lambda a__     : x)



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            return int((i - 1) / 2     ) if i > 0 else None



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            __snake_case      :int 							=    int(2 * i + 1     )
            return left if 0 < left < self.size else None



       def        __lowercase    (				self      ,    a__     )			->   int | None:






            '''simple docstring'''





            __snake_case      :Optional[int] 							=    int(2 * i + 2     )
            return right if 0 < right < self.size else None



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case							,			__snake_case      :Dict 							=    (
                self.pos_map[self.arr[j][0]],
                self.pos_map[self.arr[i][0]],
            )
            # Then swap the items in the list.
            __snake_case							,			__snake_case      :Tuple 							=    self.arr[j], self.arr[i]



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   bool:






            '''simple docstring'''





            return self.arr[i][1] < self.arr[j][1]



       def        __lowercase    (				self      ,    a__     )			->   int:






            '''simple docstring'''





            __snake_case      :int 							=    self._left(a__     )
            __snake_case      :Optional[int] 							=    self._right(a__     )
            __snake_case      :List[Any] 							=    i

            if left is not None and not self._cmp(a__      ,    a__     ):
                 __snake_case      :int 							=    left
            if right is not None and not self._cmp(a__      ,    a__     ):
                 __snake_case      :Tuple 							=    right

            return valid_parent



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :int 							=    self._parent(a__     )
            while parent is not None and not self._cmp(a__      ,    a__     ):
                 self._swap(a__      ,    a__     )
                 __snake_case							,			__snake_case      :str 							=    parent, self._parent(a__     )



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :List[Any] 							=    self._get_valid_parent(a__     )
            while valid_parent != index:
                 self._swap(a__      ,    a__     )
                 __snake_case							,			__snake_case      :Optional[int] 							=    valid_parent, self._get_valid_parent(a__     )



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            if item not in self.pos_map:
                 return
            __snake_case      :List[Any] 							=    self.pos_map[item]
            __snake_case      :Optional[Any] 							=    [item, self.key(a__     )]
            # Make sure heap is right in both up and down direction.
            # Ideally only one of them will make any change.
            self._heapify_up(a__     )
            self._heapify_down(a__     )



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            if item not in self.pos_map:
                 return
            __snake_case      :Dict 							=    self.pos_map[item]
            del self.pos_map[item]
            __snake_case      :Dict 							=    self.arr[self.size - 1]
            __snake_case      :List[str] 							=    index
            self.size -= 1
            # Make sure heap is right in both up and down direction. Ideally only one
            # of them will make any change- so no performance loss in calling both.
            if self.size > index:
                 self._heapify_up(a__     )
                 self._heapify_down(a__     )



       def        __lowercase    (				self      ,    a__      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :Optional[int] 							=    len(self.arr     )
            if arr_len == self.size:
                 self.arr.append([item, self.key(a__     )]     )
            else:
                 __snake_case      :Optional[Any] 							=    [item, self.key(a__     )]
            __snake_case      :str 							=    self.size
            self.size += 1
            self._heapify_up(self.size - 1     )



       def        __lowercase    (				self     )			->   tuple | None:






            '''simple docstring'''





            return self.arr[0] if self.size else None



       def        __lowercase    (				self     )			->   tuple | None:






            '''simple docstring'''





            __snake_case      :Optional[Any] 							=    self.get_top()
            if top_item_tuple:
                 self.delete_item(top_item_tuple[0]     )
            return top_item_tuple






def 	UpperCamelCase	(							):




     '''simple docstring'''








if __name__ == "__main__":
     import doctest

     doctest.testmod()


