


'''simple docstring'''
def 				lowerCamelCase_   (   __UpperCamelCase				:					int		)				->  int:







     """simple docstring"""
     if number != int(__UpperCamelCase		):
          raise ValueError('factorial() only accepts integral values'		)
     if number < 0:
          raise ValueError('factorial() not defined for negative values'		)
     _A				=       1
     for i in range(1       ,						number + 1		):
          value *= i
     return value

def 				lowerCamelCase_   (   __UpperCamelCase				:					int		)				->  int:







     """simple docstring"""
     if not isinstance(__UpperCamelCase       ,						__UpperCamelCase		):
          raise ValueError('factorial() only accepts integral values'		)
     if n < 0:
          raise ValueError('factorial() not defined for negative values'		)
     return 1 if n == 0 or n == 1 else n * factorial(n - 1		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    lowerCAmelCase  =				int(input("""Enter a positive integer: """).strip() or 0)
    print(F'factorial{n} is {factorial(n)}')









'''simple docstring'''
import argparse

from . import (
    BertConfig,
    BertGenerationConfig,
    BertGenerationDecoder,
    BertGenerationEncoder,
    load_tf_weights_in_bert_generation,
    logging,
)


logging.set_verbosity_info()

def 				lowerCamelCase_   (   __UpperCamelCase				:					Tuple       ,						__UpperCamelCase				:					Any       ,						__UpperCamelCase				:					Dict       ,						__UpperCamelCase				:					List[str]       ,						__UpperCamelCase				:					str		)				->  List[str]:







     """simple docstring"""
     # Initialise PyTorch model
     _A				=       BertConfig.from_pretrained(
         'bert-large-cased'       ,						vocab_size=__UpperCamelCase       ,						max_position_embeddings=5_1_2       ,						is_decoder=__UpperCamelCase       ,						add_cross_attention=__UpperCamelCase       ,						)
     _A				=       bert_config.to_dict()
     del bert_config_dict["type_vocab_size"]
     _A				=       BertGenerationConfig(**__UpperCamelCase		)
     if is_encoder:
          _A				=       BertGenerationEncoder(__UpperCamelCase		)
     else:
          _A				=       BertGenerationDecoder(__UpperCamelCase		)
     print(F'Building PyTorch model from configuration: {config}'		)

     # Load weights from tf checkpoint
     load_tf_weights_in_bert_generation(
         __UpperCamelCase       ,						__UpperCamelCase       ,						model_class='bert'       ,						is_encoder_named_decoder=__UpperCamelCase       ,						is_encoder=__UpperCamelCase       ,						)

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


if __name__ == "__main__":
    lowerCAmelCase  =				argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--tf_hub_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
    )
    parser.add_argument(
        """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
    )
    parser.add_argument(
        """--is_encoder_named_decoder""",
        action="""store_true""",
        help="""If decoder has to be renamed to encoder in PyTorch model.""",
    )
    parser.add_argument("""--is_encoder""", action="""store_true""", help="""If model is an encoder.""")
    parser.add_argument("""--vocab_size""", default=50_358, type=int, help="""Vocab size of model""")
    lowerCAmelCase  =				parser.parse_args()
    convert_tf_checkpoint_to_pytorch(
        args.tf_hub_path,
        args.pytorch_dump_path,
        args.is_encoder_named_decoder,
        args.vocab_size,
        is_encoder=args.is_encoder,
    )





