


import json
import os
import shutil
import warnings
from argparse import ArgumentParser, Namespace
from pathlib import Path
from typing import List

from ..utils import logging
from . import BaseTransformersCLICommand


try:
    from cookiecutter.main import cookiecutter

    __UpperCamelCase    :						int     =							True
except ImportError:
    __UpperCamelCase    :						Tuple     =							False

__UpperCamelCase    :						Optional[int]     =							logging.get_logger(__name__)  # pylint: disable=invalid-name





def   _UpperCAmelCase       (     UpperCAmelCase      :			Namespace      ):
      """simple docstring"""




      return AddNewModelCommand(args.testing						,	args.testing_file						,	path=args.path      )




class 							_UpperCamelCase (						__lowercase						):

   '''simple docstring'''







   @staticmethod
   def   _snake_case    (  _lowerCamelCase  : ArgumentParser							):






         '''simple docstring'''



         __lowerCamelCase     :      int       						=						parser.add_parser("""add-new-model"""							)
         add_new_model_parser.add_argument("""--testing"""       ,  action="""store_true"""       ,  help="""If in testing mode."""							)
         add_new_model_parser.add_argument("""--testing_file"""       ,  type=__a       ,  help="""Configuration file on which to run."""							)
         add_new_model_parser.add_argument(
             """--path"""       ,  type=__a       ,  help="""Path to cookiecutter. Should only be used for testing purposes."""							)
         add_new_model_parser.set_defaults(func=__a							)

   def __init__(  self  : List[Any]       ,  _lowerCamelCase  : bool       ,  _lowerCamelCase  : str       ,  _lowerCamelCase  : Dict=None       ,  *_lowerCamelCase  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Any       						=						testing
         __lowerCamelCase     :      Any       						=						testing_file
         __lowerCamelCase     :      Optional[Any]       						=						path


   def   _snake_case    (  self  : int							):






         '''simple docstring'''



         warnings.warn(
             """The command `transformers-cli add-new-model` is deprecated and will be removed in v5 of Transformers. """
             """It is not actively maintained anymore, so might give a result that won't pass all tests and quality """
             """checks, you should use `transformers-cli add-new-model-like` instead."""							)
         if not _has_cookiecutter:
               raise ImportError(
                   """Model creation dependencies are required to use the `add_new_model` command. Install them by running """
                   """the following at the root of your `transformers` clone:\n\n\t$ pip install -e .[modelcreation]\n"""							)
         # Ensure that there is no other `cookiecutter-template-xxx` directory in the current working directory
         __lowerCamelCase     :      Optional[Any]       						=						[directory for directory in os.listdir() if """cookiecutter-template-""" == directory[:2_2]]
         if len(__a							) > 0:
               raise ValueError(
                   """Several directories starting with `cookiecutter-template-` in current working directory. """
                   """Please clean your directory by removing all folders starting with `cookiecutter-template-` or """
                   """change your working directory."""							)

         __lowerCamelCase     :      List[Any]       						=						(
             Path(__a							).parent.parent.parent.parent if self._path is None else Path(self._path							).parent.parent
         )
         __lowerCamelCase     :      Optional[int]       						=						path_to_transformer_root / """templates""" / """adding_a_new_model"""

         # Execute cookiecutter
         if not self._testing:
               cookiecutter(str(__a							)							)
         else:
               with open(self._testing_file       ,  """r"""							) as configuration_file:
                     __lowerCamelCase     :      Union[str, Any]       						=						json.load(__a							)

               cookiecutter(
                   str(path_to_cookiecutter if self._path is None else self._path							)       ,  no_input=__a       ,  extra_context=__a       ,  )

         __lowerCamelCase     :      Dict       						=						[directory for directory in os.listdir() if """cookiecutter-template-""" in directory[:2_2]][0]

         # Retrieve configuration
         with open(directory + """/configuration.json"""       ,  """r"""							) as configuration_file:
               __lowerCamelCase     :      List[str]       						=						json.load(__a							)

         __lowerCamelCase     :      Union[str, Any]       						=						configuration["""lowercase_modelname"""]
         __lowerCamelCase     :      List[str]       						=						configuration["""generate_tensorflow_pytorch_and_flax"""]
         os.remove(F"""{directory}/configuration.json"""							)

         __lowerCamelCase     :      Optional[int]       						=						"""PyTorch""" in generate_tensorflow_pytorch_and_flax
         __lowerCamelCase     :      List[str]       						=						"""TensorFlow""" in generate_tensorflow_pytorch_and_flax
         __lowerCamelCase     :      Union[str, Any]       						=						"""Flax""" in generate_tensorflow_pytorch_and_flax

         __lowerCamelCase     :      List[Any]       						=						F"""{path_to_transformer_root}/src/transformers/models/{lowercase_model_name}"""
         os.makedirs(__a       ,  exist_ok=__a							)
         os.makedirs(F"""{path_to_transformer_root}/tests/models/{lowercase_model_name}"""       ,  exist_ok=__a							)

         # Tests require submodules as they have parent imports
         with open(F"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/__init__.py"""       ,  """w"""							):
               pass

         shutil.move(
             F"""{directory}/__init__.py"""       ,  F"""{model_dir}/__init__.py"""       ,  )
         shutil.move(
             F"""{directory}/configuration_{lowercase_model_name}.py"""       ,  F"""{model_dir}/configuration_{lowercase_model_name}.py"""       ,  )

         def remove_copy_lines(_lowerCamelCase  : int							):
               with open(__a       ,  """r"""							) as f:
                     __lowerCamelCase     :      List[str]       						=						f.readlines()
               with open(__a       ,  """w"""							) as f:
                     for line in lines:
                           if "# Copied from transformers." not in line:
                                 f.write(__a							)

         if output_pytorch:
               if not self._testing:
                     remove_copy_lines(F"""{directory}/modeling_{lowercase_model_name}.py"""							)

               shutil.move(
                   F"""{directory}/modeling_{lowercase_model_name}.py"""       ,  F"""{model_dir}/modeling_{lowercase_model_name}.py"""       ,  )

               shutil.move(
                   F"""{directory}/test_modeling_{lowercase_model_name}.py"""       ,  F"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_{lowercase_model_name}.py"""       ,  )
         else:
               os.remove(F"""{directory}/modeling_{lowercase_model_name}.py"""							)
               os.remove(F"""{directory}/test_modeling_{lowercase_model_name}.py"""							)

         if output_tensorflow:
               if not self._testing:
                     remove_copy_lines(F"""{directory}/modeling_tf_{lowercase_model_name}.py"""							)

               shutil.move(
                   F"""{directory}/modeling_tf_{lowercase_model_name}.py"""       ,  F"""{model_dir}/modeling_tf_{lowercase_model_name}.py"""       ,  )

               shutil.move(
                   F"""{directory}/test_modeling_tf_{lowercase_model_name}.py"""       ,  F"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_tf_{lowercase_model_name}.py"""       ,  )
         else:
               os.remove(F"""{directory}/modeling_tf_{lowercase_model_name}.py"""							)
               os.remove(F"""{directory}/test_modeling_tf_{lowercase_model_name}.py"""							)

         if output_flax:
               if not self._testing:
                     remove_copy_lines(F"""{directory}/modeling_flax_{lowercase_model_name}.py"""							)

               shutil.move(
                   F"""{directory}/modeling_flax_{lowercase_model_name}.py"""       ,  F"""{model_dir}/modeling_flax_{lowercase_model_name}.py"""       ,  )

               shutil.move(
                   F"""{directory}/test_modeling_flax_{lowercase_model_name}.py"""       ,  F"""{path_to_transformer_root}/tests/models/{lowercase_model_name}/test_modeling_flax_{lowercase_model_name}.py"""       ,  )
         else:
               os.remove(F"""{directory}/modeling_flax_{lowercase_model_name}.py"""							)
               os.remove(F"""{directory}/test_modeling_flax_{lowercase_model_name}.py"""							)

         shutil.move(
             F"""{directory}/{lowercase_model_name}.md"""       ,  F"""{path_to_transformer_root}/docs/source/en/model_doc/{lowercase_model_name}.md"""       ,  )

         shutil.move(
             F"""{directory}/tokenization_{lowercase_model_name}.py"""       ,  F"""{model_dir}/tokenization_{lowercase_model_name}.py"""       ,  )

         shutil.move(
             F"""{directory}/tokenization_fast_{lowercase_model_name}.py"""       ,  F"""{model_dir}/tokenization_{lowercase_model_name}_fast.py"""       ,  )

         from os import fdopen, remove
         from shutil import copymode, move
         from tempfile import mkstemp

         def replace(_lowerCamelCase  : str       ,  _lowerCamelCase  : str       ,  _lowerCamelCase  : List[str]							):
               # Create temp file
               __lowerCamelCase     :      List[Any]       						=						mkstemp()
               __lowerCamelCase     :      Dict       						=						False
               with fdopen(__a       ,  """w"""							) as new_file:
                     with open(__a							) as old_file:
                           for line in old_file:
                                 new_file.write(__a							)
                                 if line_to_copy_below in line:
                                       __lowerCamelCase     :      List[str]       						=						True
                                       for line_to_copy in lines_to_copy:
                                             new_file.write(__a							)

               if not line_found:
                     raise ValueError(F"""Line {line_to_copy_below} was not found in file."""							)

               # Copy the file permissions from the old file to the new file
               copymode(__a       ,  __a							)
               # Remove original file
               remove(__a							)
               # Move new file
               move(__a       ,  __a							)

         def skip_units(_lowerCamelCase  : Union[str, Any]							):
               return (
                   ("generating PyTorch" in line and not output_pytorch)
                   or ("generating TensorFlow" in line and not output_tensorflow)
                   or ("generating Flax" in line and not output_flax)
               )

         def replace_in_files(_lowerCamelCase  : Union[str, Any]							):
               with open(__a							) as datafile:
                     __lowerCamelCase     :      Tuple       						=						[]
                     __lowerCamelCase     :      Dict       						=						False
                     __lowerCamelCase     :      Optional[int]       						=						False
                     for line in datafile:
                           if "# To replace in: " in line and "##" not in line:
                                 __lowerCamelCase     :      Union[str, Any]       						=						line.split("""\""""							)[1]
                                 __lowerCamelCase     :      Any       						=						skip_units(__a							)
                           elif "# Below: " in line and "##" not in line:
                                 __lowerCamelCase     :      List[str]       						=						line.split("""\""""							)[1]
                                 __lowerCamelCase     :      List[str]       						=						skip_units(__a							)
                           elif "# End." in line and "##" not in line:
                                 if not skip_file and not skip_snippet:
                                       replace(__a       ,  __a       ,  __a							)

                                 __lowerCamelCase     :      str       						=						[]
                           elif "# Replace with" in line and "##" not in line:
                                 __lowerCamelCase     :      Dict       						=						[]
                           elif "##" not in line:
                                 lines_to_copy.append(__a							)

               remove(__a							)

         replace_in_files(F"""{directory}/to_replace_{lowercase_model_name}.py"""							)
         os.rmdir(__a							)






import qiskit





def   _UpperCAmelCase       (     UpperCAmelCase      :			int						,	UpperCAmelCase      :			int      ):
      """simple docstring"""




      __lowerCamelCase     :      Dict       						=						qiskit.Aer.get_backend("""aer_simulator"""      )

      __lowerCamelCase     :      Dict       						=						qiskit.QuantumCircuit(4						,	2      )
      # encode inputs in qubits 0 and 1
      if bita == 1:
            qc_ha.x(0      )
      if bita == 1:
            qc_ha.x(1      )
      qc_ha.barrier()

      # use cnots to write XOR of the inputs on qubit2
      qc_ha.cx(0						,	2      )
      qc_ha.cx(1						,	2      )

      # use ccx / toffoli gate to write AND of the inputs on qubit3
      qc_ha.ccx(0						,	1						,	3      )
      qc_ha.barrier()

      # extract outputs
      qc_ha.measure(2						,	0      )  # extract XOR value
      qc_ha.measure(3						,	1      )  # extract AND value

      # Execute the circuit on the qasm simulator
      __lowerCamelCase     :      str       						=						qiskit.execute(UpperCAmelCase						,	UpperCAmelCase						,	shots=1_000      )

      # Return the histogram data of the results of the experiment
      return job.result().get_counts(UpperCAmelCase      )


if __name__ == "__main__":
    __UpperCamelCase    :						List[str]     =							half_adder(1, 1)
    print(F'''Half Adder Output Qubit Counts: {counts}''')



