





import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
  import tensorflow as tf

  tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
  import torch

if is_datasets_available():
  from datasets import load_dataset


__UpperCAmelCase				=      5e-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors
def 			__UpperCamelCase				(			lowercase__	:       Namespace		)	->      Optional[int]:
    '''simple docstring'''





    return PTtoTFCommand(
        args.model_name		,    args.local_dir		,    args.max_error		,    args.new_weights		,    args.no_pr		,    args.push		,    args.extra_commit_description		,    args.override_model_class		,    )

class 		__a							(	__UpperCamelCase      ):



       @staticmethod
       def  A							(     UpperCAmelCase	:   ArgumentParser			):
           lowerCAmelCase_					:	List[Any]						=   parser.add_parser(
               """pt-to-tf"""					,			help=(
                   """CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint."""
                   """ Can also be used to validate existing weights without opening PRs, with --no-pr."""
               )					,			)
           train_parser.add_argument(
               """--model-name"""					,			type=UpperCAmelCase					,			required=UpperCAmelCase					,			help="""The model name, including owner/organization, as seen on the hub."""					,			)
           train_parser.add_argument(
               """--local-dir"""					,			type=UpperCAmelCase					,			default=""""""					,			help="""Optional local directory of the model repository. Defaults to /tmp/{model_name}"""					,			)
           train_parser.add_argument(
               """--max-error"""					,			type=UpperCAmelCase					,			default=UpperCAmelCase					,			help=(
                   F'Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk.'
               )					,			)
           train_parser.add_argument(
               """--new-weights"""					,			action="""store_true"""					,			help="""Optional flag to create new TensorFlow weights, even if they already exist."""					,			)
           train_parser.add_argument(
               """--no-pr"""					,			action="""store_true"""					,			help="""Optional flag to NOT open a PR with converted weights."""			)
           train_parser.add_argument(
               """--push"""					,			action="""store_true"""					,			help="""Optional flag to push the weights directly to `main` (requires permissions)"""					,			)
           train_parser.add_argument(
               """--extra-commit-description"""					,			type=UpperCAmelCase					,			default=""""""					,			help="""Optional additional commit description to use when opening a PR (e.g. to tag the owner)."""					,			)
           train_parser.add_argument(
               """--override-model-class"""					,			type=UpperCAmelCase					,			default=UpperCAmelCase					,			help="""If you think you know better than the auto-detector, you can specify the model class here. """
               """Can be either an AutoModel class or a specific model class like BertForSequenceClassification."""					,			)
           train_parser.set_defaults(func=UpperCAmelCase			)



       @staticmethod
       def  A							(     UpperCAmelCase	:   Dict					,			UpperCAmelCase	:   Dict			):
           lowerCAmelCase_					:	Any						=   set(pt_outputs.keys()			)
           lowerCAmelCase_					:	Tuple						=   set(tf_outputs.keys()			)
           if pt_out_attrs != tf_out_attrs:
               raise ValueError(
                   F'The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:'
                   F' {tf_out_attrs})'			)

           # 2. For each output attribute, computes the difference
           def _find_pt_tf_differences(UpperCAmelCase	:   int					,			UpperCAmelCase	:   str					,			UpperCAmelCase	:   List[str]					,			UpperCAmelCase	:   int=""			):
               # If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
               # recursivelly, keeping the name of the attribute.
               if isinstance(UpperCAmelCase					,			torch.Tensor			):
                   lowerCAmelCase_					:	int						=   np.max(np.abs(pt_out.numpy() - tf_out.numpy()			)			)
                   lowerCAmelCase_					:	Tuple						=   tensor_difference
               else:
                   lowerCAmelCase_					:	Any						=   attr_name
                   for i, pt_item in enumerate(UpperCAmelCase			):
                       # If it is a named attribute, we keep the name. Otherwise, just its index.
                       if isinstance(UpperCAmelCase					,			UpperCAmelCase			):
                           lowerCAmelCase_					:	str						=   root_name + pt_item
                           lowerCAmelCase_					:	Dict						=   tf_out[pt_item]
                           lowerCAmelCase_					:	List[str]						=   pt_out[pt_item]
                       else:
                           lowerCAmelCase_					:	Union[str, Any]						=   root_name + F'[{i}]'
                           lowerCAmelCase_					:	List[Any]						=   tf_out[i]
                       lowerCAmelCase_					:	Optional[int]						=   _find_pt_tf_differences(UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase			)

               return differences

           return _find_pt_tf_differences(UpperCAmelCase					,			UpperCAmelCase					,			{}			)



       def __init__(     self	:   str					,			UpperCAmelCase	:   str					,			UpperCAmelCase	:   str					,			UpperCAmelCase	:   float					,			UpperCAmelCase	:   bool					,			UpperCAmelCase	:   bool					,			UpperCAmelCase	:   bool					,			UpperCAmelCase	:   str					,			UpperCAmelCase	:   str					,			*UpperCAmelCase	:   Any					,			):
           lowerCAmelCase_					:	Dict						=   logging.get_logger("""transformers-cli/pt_to_tf"""			)
           lowerCAmelCase_					:	Optional[int]						=   model_name
           lowerCAmelCase_					:	str						=   local_dir if local_dir else os.path.join("""/tmp"""					,			UpperCAmelCase			)
           lowerCAmelCase_					:	Optional[int]						=   max_error
           lowerCAmelCase_					:	int						=   new_weights
           lowerCAmelCase_					:	int						=   no_pr
           lowerCAmelCase_					:	int						=   push
           lowerCAmelCase_					:	Optional[Any]						=   extra_commit_description
           lowerCAmelCase_					:	str						=   override_model_class



       def  A							(     self	:   Optional[int]					,			UpperCAmelCase	:   List[Any]					,			UpperCAmelCase	:   str					,			UpperCAmelCase	:   int			):

           def _get_audio_input():
               lowerCAmelCase_					:	Optional[Any]						=   load_dataset("""hf-internal-testing/librispeech_asr_dummy"""					,			"""clean"""					,			split="""validation"""			)
               lowerCAmelCase_					:	Tuple						=   ds.sort("""id"""			).select(range(2			)			)[:2]["""audio"""]
               lowerCAmelCase_					:	Tuple						=   [x["""array"""] for x in speech_samples]
               return raw_samples

           lowerCAmelCase_					:	Dict						=   type(pt_model.config			)
           if model_config_class in PROCESSOR_MAPPING:
               lowerCAmelCase_					:	Tuple						=   AutoProcessor.from_pretrained(self._local_dir			)
               if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
                   lowerCAmelCase_					:	Tuple						=   processor.tokenizer.eos_token
           elif model_config_class in IMAGE_PROCESSOR_MAPPING:
               lowerCAmelCase_					:	Optional[Any]						=   AutoImageProcessor.from_pretrained(self._local_dir			)
           elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
               lowerCAmelCase_					:	List[Any]						=   AutoFeatureExtractor.from_pretrained(self._local_dir			)
           elif model_config_class in TOKENIZER_MAPPING:
               lowerCAmelCase_					:	int						=   AutoTokenizer.from_pretrained(self._local_dir			)
               if processor.pad_token is None:
                   lowerCAmelCase_					:	Optional[int]						=   processor.eos_token
           else:
               raise ValueError(F'Unknown data processing type (model config type: {model_config_class})'			)

           lowerCAmelCase_					:	Union[str, Any]						=   set(inspect.signature(pt_model.forward			).parameters.keys()			)
           lowerCAmelCase_					:	Tuple						=   {}
           if "input_ids" in model_forward_signature:
               processor_inputs.update(
                   {
                       """text""": ["""Hi there!""", """I am a batch with more than one row and different input lengths."""],
                       """padding""": True,
                       """truncation""": True,
                   }			)
           if "pixel_values" in model_forward_signature:
               lowerCAmelCase_					:	str						=   load_dataset("""cifar10"""					,			"""plain_text"""					,			split="""test"""			)[:2]["""img"""]
               processor_inputs.update({"""images""": sample_images}			)
           if "input_features" in model_forward_signature:
               lowerCAmelCase_					:	Any						=   inspect.signature(processor.feature_extractor			).parameters
               # Pad to the largest input length by default but take feature extractor default
               # padding value if it exists e.g. "max_length" and is not False or None
               if "padding" in feature_extractor_signature:
                   lowerCAmelCase_					:	Dict						=   feature_extractor_signature["""padding"""].default
                   if default_strategy is not False and default_strategy is not None:
                       lowerCAmelCase_					:	Optional[Any]						=   default_strategy
                   else:
                       lowerCAmelCase_					:	int						=   True
               else:
                   lowerCAmelCase_					:	Optional[int]						=   True
               processor_inputs.update({"""audio""": _get_audio_input(), """padding""": padding_strategy}			)
           if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
               processor_inputs.update({"""audio""": _get_audio_input(), """padding""": True}			)
           lowerCAmelCase_					:	Dict						=   processor(**UpperCAmelCase					,			return_tensors="""pt"""			)
           lowerCAmelCase_					:	Any						=   processor(**UpperCAmelCase					,			return_tensors="""tf"""			)

           # Extra input requirements, in addition to the input modality
           if (
               config.is_encoder_decoder
               or (hasattr(UpperCAmelCase					,			"""encoder"""			) and hasattr(UpperCAmelCase					,			"""decoder"""			))
               or "decoder_input_ids" in tf_dummy_inputs
           ):
               lowerCAmelCase_					:	List[Any]						=   np.asarray([[1], [1]]					,			dtype=UpperCAmelCase			) * (pt_model.config.decoder_start_token_id or 0)
               pt_input.update({"""decoder_input_ids""": torch.tensor(UpperCAmelCase			)}			)
               tf_input.update({"""decoder_input_ids""": tf.convert_to_tensor(UpperCAmelCase			)}			)

           return pt_input, tf_input



       def  A							(     self	:   str			):
           # hub version 0.9.0 introduced the possibility of programmatically opening PRs with normal write tokens.
           if version.parse(huggingface_hub.__version__			) < version.parse("""0.9.0"""			):
               raise ImportError(
                   """The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub"""
                   """ installation."""			)
           else:
               from huggingface_hub import Repository, create_commit
               from huggingface_hub._commit_api import CommitOperationAdd

           # Fetch remote data
           lowerCAmelCase_					:	Dict						=   Repository(local_dir=self._local_dir					,			clone_from=self._model_name			)

           # Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
           lowerCAmelCase_					:	Optional[int]						=   AutoConfig.from_pretrained(self._local_dir			)
           lowerCAmelCase_					:	Union[str, Any]						=   config.architectures
           if self._override_model_class is not None:
               if self._override_model_class.startswith("""TF"""			):
                   lowerCAmelCase_					:	str						=   [self._override_model_class[2:]]
               else:
                   lowerCAmelCase_					:	Any						=   [self._override_model_class]
               try:
                   lowerCAmelCase_					:	Optional[int]						=   getattr(import_module("""transformers"""			)					,			architectures[0]			)
               except AttributeError:
                   raise ValueError(F'Model class {self._override_model_class} not found in transformers.'			)
               try:
                   lowerCAmelCase_					:	Optional[int]						=   getattr(import_module("""transformers"""			)					,			"""TF""" + architectures[0]			)
               except AttributeError:
                   raise ValueError(F'TF model class TF{self._override_model_class} not found in transformers.'			)
           elif architectures is None:  # No architecture defined -- use auto classes
               lowerCAmelCase_					:	Tuple						=   getattr(import_module("""transformers"""			)					,			"""AutoModel"""			)
               lowerCAmelCase_					:	int						=   getattr(import_module("""transformers"""			)					,			"""TFAutoModel"""			)
               self._logger.warning("""No detected architecture, using AutoModel/TFAutoModel"""			)
           else:  # Architecture defined -- use it
               if len(UpperCAmelCase			) > 1:
                   raise ValueError(F'More than one architecture was found, aborting. (architectures = {architectures})'			)
               self._logger.warning(F'Detected architecture: {architectures[0]}'			)
               lowerCAmelCase_					:	Union[str, Any]						=   getattr(import_module("""transformers"""			)					,			architectures[0]			)
               try:
                   lowerCAmelCase_					:	Union[str, Any]						=   getattr(import_module("""transformers"""			)					,			"""TF""" + architectures[0]			)
               except AttributeError:
                   raise AttributeError(F'The TensorFlow equivalent of {architectures[0]} doesn\'t exist in transformers.'			)

        # Check the TF dummy inputs to see what keys we need in the forward pass
           lowerCAmelCase_					:	str						=   tf_class.from_config(UpperCAmelCase			)
           lowerCAmelCase_					:	Dict						=   tf_from_pt_model.dummy_inputs

           del tf_from_pt_model  # Try to keep only one model in memory at a time

           # Load the model and get some basic inputs
           lowerCAmelCase_					:	Union[str, Any]						=   pt_class.from_pretrained(self._local_dir			)
           pt_model.eval()

           lowerCAmelCase_					:	Tuple						=   self.get_inputs(UpperCAmelCase					,			UpperCAmelCase					,			UpperCAmelCase			)

           with torch.no_grad():
               lowerCAmelCase_					:	Union[str, Any]						=   pt_model(**UpperCAmelCase					,			output_hidden_states=UpperCAmelCase			)
           del pt_model  # will no longer be used, and may have a large memory footprint

           lowerCAmelCase_					:	Tuple						=   tf_class.from_pretrained(self._local_dir					,			from_pt=UpperCAmelCase			)
           lowerCAmelCase_					:	str						=   tf_from_pt_model(**UpperCAmelCase					,			output_hidden_states=UpperCAmelCase					,			training=UpperCAmelCase			)

           # Confirms that cross loading PT weights into TF worked.
           lowerCAmelCase_					:	Dict						=   self.find_pt_tf_differences(UpperCAmelCase					,			UpperCAmelCase			)
           lowerCAmelCase_					:	str						=   {k: v for k, v in crossload_differences.items() if """hidden""" not in k}
           lowerCAmelCase_					:	Tuple						=   {k: v for k, v in crossload_differences.items() if """hidden""" in k}
           if len(UpperCAmelCase			) == 0 and architectures is not None:
               raise ValueError(
                   F'Something went wrong -- the config file has architectures ({architectures}), but no model head'
                   """ output was found. All outputs start with 'hidden'"""			)
           lowerCAmelCase_					:	List[Any]						=   max(output_differences.values()			) if output_differences else 0.0
           lowerCAmelCase_					:	Any						=   max(hidden_differences.values()			)
           if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
               raise ValueError(
                   """The cross-loaded TensorFlow model has different outputs, something went wrong!\n"""
                   + F'\nList of maximum output differences above the threshold ({self._max_error}):\n'
                   + """\n""".join([F'{k}: {v:.3e}' for k, v in output_differences.items() if v > self._max_error]			)
                   + F'\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'
                   + """\n""".join([F'{k}: {v:.3e}' for k, v in hidden_differences.items() if v > self._max_error]			)			)

           # Save the weights in a TF format (if needed) and confirms that the results are still good
           lowerCAmelCase_					:	str						=   os.path.join(self._local_dir					,			UpperCAmelCase			)
           lowerCAmelCase_					:	Optional[Any]						=   os.path.join(self._local_dir					,			UpperCAmelCase			)
           if (not os.path.exists(UpperCAmelCase			) and not os.path.exists(UpperCAmelCase			)) or self._new_weights:
               tf_from_pt_model.save_pretrained(self._local_dir			)
           del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

           lowerCAmelCase_					:	Optional[int]						=   tf_class.from_pretrained(self._local_dir			)
           lowerCAmelCase_					:	Dict						=   tf_model(**UpperCAmelCase					,			output_hidden_states=UpperCAmelCase			)

           lowerCAmelCase_					:	str						=   self.find_pt_tf_differences(UpperCAmelCase					,			UpperCAmelCase			)
           lowerCAmelCase_					:	Optional[int]						=   {k: v for k, v in conversion_differences.items() if """hidden""" not in k}
           lowerCAmelCase_					:	Optional[int]						=   {k: v for k, v in conversion_differences.items() if """hidden""" in k}
           if len(UpperCAmelCase			) == 0 and architectures is not None:
               raise ValueError(
                   F'Something went wrong -- the config file has architectures ({architectures}), but no model head'
                   """ output was found. All outputs start with 'hidden'"""			)
           lowerCAmelCase_					:	Optional[int]						=   max(output_differences.values()			) if output_differences else 0.0
           lowerCAmelCase_					:	List[Any]						=   max(hidden_differences.values()			)
           if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
               raise ValueError(
                   """The converted TensorFlow model has different outputs, something went wrong!\n"""
                   + F'\nList of maximum output differences above the threshold ({self._max_error}):\n'
                   + """\n""".join([F'{k}: {v:.3e}' for k, v in output_differences.items() if v > self._max_error]			)
                   + F'\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'
                   + """\n""".join([F'{k}: {v:.3e}' for k, v in hidden_differences.items() if v > self._max_error]			)			)

           lowerCAmelCase_					:	Dict						=   """Update TF weights""" if self._new_weights else """Add TF weights"""
           if self._push:
               repo.git_add(auto_lfs_track=UpperCAmelCase			)
               repo.git_commit(UpperCAmelCase			)
               repo.git_push(blocking=UpperCAmelCase			)  # this prints a progress bar with the upload
               self._logger.warning(F'TF weights pushed into {self._model_name}'			)
           elif not self._no_pr:
               self._logger.warning("""Uploading the weights into a new PR..."""			)
               lowerCAmelCase_					:	Dict						=   (
                   """Model converted by the [`transformers`' `pt_to_tf`"""
                   """ CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). """
                   """All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n"""
                   F'Maximum crossload output difference={max_crossload_output_diff:.3e}; '
                   F'Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n'
                   F'Maximum conversion output difference={max_conversion_output_diff:.3e}; '
                   F'Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n'
               )
               if self._max_error > MAX_ERROR:
                   commit_descrition += (
                       F'\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!'
                   )
               if self._extra_commit_description:
                   commit_descrition += "\n\n" + self._extra_commit_description

               # sharded model -> adds all related files (index and .h5 shards)
               if os.path.exists(UpperCAmelCase			):
                   lowerCAmelCase_					:	Optional[Any]						=   [
                       CommitOperationAdd(path_in_repo=UpperCAmelCase					,			path_or_fileobj=UpperCAmelCase			)
                   ]
                   for shard_path in tf.io.gfile.glob(self._local_dir + """/tf_model-*.h5"""			):
                       operations += [
                           CommitOperationAdd(path_in_repo=os.path.basename(UpperCAmelCase			)					,			path_or_fileobj=UpperCAmelCase			)
                       ]
               else:
                   lowerCAmelCase_					:	Optional[Any]						=   [CommitOperationAdd(path_in_repo=UpperCAmelCase					,			path_or_fileobj=UpperCAmelCase			)]

               lowerCAmelCase_					:	int						=   create_commit(
                   repo_id=self._model_name					,			operations=UpperCAmelCase					,			commit_message=UpperCAmelCase					,			commit_description=UpperCAmelCase					,			repo_type="""model"""					,			create_pr=UpperCAmelCase					,			).pr_url
               self._logger.warning(F'PR open in {hub_pr_url}'			)









from __future__ import annotations

import math
from itertools import permutations
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      bool:
    '''simple docstring'''





    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5		,    int(math.sqrt(lowercase__		) + 1		)		,    6		):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True
def 			__UpperCamelCase				(			lowercase__	:       int = 7		)	->      int:
    '''simple docstring'''





    lowerCAmelCase_					:	str						=   """""".join(str(lowercase__		) for i in range(1		,    n + 1		)		)
    lowerCAmelCase_					:	Any						=   [int("""""".join(lowercase__		)		) for i in permutations(lowercase__		,    lowercase__		)]
    lowerCAmelCase_					:	List[Any]						=   [num for num in perm_list if is_prime(lowercase__		)]
    return max(lowercase__		) if pandigitals else 0


if __name__ == "__main__":
  print(f"""{solution() = }""")


