






'''simple docstring'''

import json
import os
import unittest

from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class        a_		(    lowerCamelCase			, unittest.TestCase       ):
  lowercase  	=   MgpstrTokenizer
  lowercase  	=   False
  lowercase  	=   {}
  lowercase  	=   False

  def 						A__		(   self   )						->   List[Any]:



        """simple docstring"""






        super().setUp()

        # fmt: off
        UpperCamelCase       						=      ["""[GO]""", """[s]""", """0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9""", """a""", """b""", """c""", """d""", """e""", """f""", """g""", """h""", """i""", """j""", """k""", """l""", """m""", """n""", """o""", """p""", """q""", """r""", """s""", """t""", """u""", """v""", """w""", """x""", """y""", """z"""]
        # fmt: on
        UpperCamelCase       						=      dict(zip(_SCREAMING_SNAKE_CASE    ,	range(len(_SCREAMING_SNAKE_CASE   )   )   )   )

        UpperCamelCase       						=      os.path.join(self.tmpdirname    ,	VOCAB_FILES_NAMES["""vocab_file"""]   )
        with open(self.vocab_file    ,	"""w"""    ,	encoding="""utf-8"""   ) as fp:
              fp.write(json.dumps(_SCREAMING_SNAKE_CASE   ) + """\n"""   )

  def 						A__		(   self    ,	**_SCREAMING_SNAKE_CASE   )						->   Optional[Any]:



        """simple docstring"""






        return MgpstrTokenizer.from_pretrained(self.tmpdirname    ,	**_SCREAMING_SNAKE_CASE   )

  def 						A__		(   self    ,	_SCREAMING_SNAKE_CASE   )						->   List[Any]:



        """simple docstring"""






        UpperCamelCase       						=      """tester"""
        UpperCamelCase       						=      """tester"""
        return input_text, output_text

  @unittest.skip("""MGP-STR always lower cases letters."""   )
  def 						A__		(   self   )						->   int:



        """simple docstring"""






        pass

  def 						A__		(   self   )						->   str:



        """simple docstring"""






        UpperCamelCase       						=      self.get_tokenizers(do_lower_case=_SCREAMING_SNAKE_CASE   )
        for tokenizer in tokenizers:
              with self.subTest(F"{tokenizer.__class__.__name__}"   ):
                    UpperCamelCase       						=      """[SPECIAL_TOKEN]"""

                    tokenizer.add_special_tokens({"""cls_token""": special_token}   )
                    UpperCamelCase       						=      tokenizer.encode([special_token]    ,	add_special_tokens=_SCREAMING_SNAKE_CASE   )
                    self.assertEqual(len(_SCREAMING_SNAKE_CASE   )    ,	1   )

                    UpperCamelCase       						=      tokenizer.decode(_SCREAMING_SNAKE_CASE    ,	skip_special_tokens=_SCREAMING_SNAKE_CASE   )
                    self.assertTrue(special_token not in decoded   )

  def 						A__		(   self   )						->   Optional[Any]:



        """simple docstring"""






        UpperCamelCase       						=      self.get_tokenizers()
        for tokenizer in tokenizers:
              with self.subTest(F"{tokenizer.__class__.__name__}"   ):
                    UpperCamelCase						,UpperCamelCase       						=      self.get_input_output_texts(_SCREAMING_SNAKE_CASE   )

                    UpperCamelCase       						=      tokenizer.tokenize(_SCREAMING_SNAKE_CASE   )
                    UpperCamelCase       						=      tokenizer.convert_tokens_to_ids(_SCREAMING_SNAKE_CASE   )
                    UpperCamelCase       						=      tokenizer.encode(_SCREAMING_SNAKE_CASE    ,	add_special_tokens=_SCREAMING_SNAKE_CASE   )
                    self.assertListEqual(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

                    UpperCamelCase       						=      tokenizer.convert_ids_to_tokens(_SCREAMING_SNAKE_CASE   )
                    self.assertNotEqual(len(_SCREAMING_SNAKE_CASE   )    ,	0   )
                    UpperCamelCase       						=      tokenizer.decode(_SCREAMING_SNAKE_CASE   )
                    self.assertIsInstance(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )

                    self.assertEqual(text_a.replace(""" """    ,	""""""   )    ,	_SCREAMING_SNAKE_CASE   )

  @unittest.skip("""MGP-STR tokenizer only handles one sequence."""   )
  def 						A__		(   self   )						->   Any:



        """simple docstring"""






        pass


  @unittest.skip("""inputs cannot be pretokenized in MgpstrTokenizer"""   )
  def 						A__		(   self   )						->   Dict:



        """simple docstring"""






        pass








'''simple docstring'''

import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand







def 					lowercase__				(   __UpperCamelCase					)->				str:
      return EnvironmentCommand()







def 					lowercase__				(   __UpperCamelCase					)->				str:
      return EnvironmentCommand(args.accelerate_config_file					)






class        a_		(    lowerCamelCase       ):

  @staticmethod
  def 						A__		(   _SCREAMING_SNAKE_CASE   )						->   Optional[Any]:



        """simple docstring"""






        UpperCamelCase       						=      parser.add_parser("""env"""   )
        download_parser.set_defaults(func=_SCREAMING_SNAKE_CASE   )
        download_parser.add_argument(
            """--accelerate-config_file"""    ,	default=_SCREAMING_SNAKE_CASE    ,	help="""The accelerate config file to use for the default values in the launching script."""    ,	)
        download_parser.set_defaults(func=_SCREAMING_SNAKE_CASE   )

  def __init__(   self    ,	_SCREAMING_SNAKE_CASE    ,	*_SCREAMING_SNAKE_CASE   )						->   None:



        """simple docstring"""






        UpperCamelCase       						=      accelerate_config_file

  def 						A__		(   self   )						->   List[Any]:



        """simple docstring"""






        UpperCamelCase       						=      """not installed"""
        if is_safetensors_available():
              import safetensors

              UpperCamelCase       						=      safetensors.__version__
        elif importlib.util.find_spec("""safetensors"""   ) is not None:
              import safetensors

              UpperCamelCase       						=      F"{safetensors.__version__} but is ignored because of PyTorch version too old."

        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      UpperCamelCase       						=      """not found"""
        if is_accelerate_available():
              import accelerate
              from accelerate.commands.config import default_config_file, load_config_from_file

              UpperCamelCase       						=      accelerate.__version__
              # Get the default from the config file.
              if self._accelerate_config_file is not None or os.path.isfile(_SCREAMING_SNAKE_CASE   ):
                    UpperCamelCase       						=      load_config_from_file(self._accelerate_config_file   ).to_dict()

              UpperCamelCase       						=      (
                  """\n""".join([F"\t- {prop}: {val}" for prop, val in accelerate_config.items()]   )
                  if isinstance(_SCREAMING_SNAKE_CASE    ,	_SCREAMING_SNAKE_CASE   )
                  else F"\t{accelerate_config}"
              )

        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """NA"""
        if is_torch_available():
              import torch

              UpperCamelCase       						=      torch.__version__
              UpperCamelCase       						=      torch.cuda.is_available()

        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """NA"""
        if is_tf_available():
              import tensorflow as tf

              UpperCamelCase       						=      tf.__version__
              try:
                    # deprecated in v2.1
                    UpperCamelCase       						=      tf.test.is_gpu_available()
              except AttributeError:
                    # returns list of devices, convert to bool
                    UpperCamelCase       						=      bool(tf.config.list_physical_devices("""GPU"""   )   )

        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """not installed"""
        UpperCamelCase       						=      """NA"""
        if is_flax_available():
              import flax
              import jax
              import jaxlib

              UpperCamelCase       						=      flax.__version__
              UpperCamelCase       						=      jax.__version__
              UpperCamelCase       						=      jaxlib.__version__
              UpperCamelCase       						=      jax.lib.xla_bridge.get_backend().platform

        UpperCamelCase       						=      {
            """`transformers` version""": version,
            """Platform""": platform.platform(),
            """Python version""": platform.python_version(),
            """Huggingface_hub version""": huggingface_hub.__version__,
            """Safetensors version""": F"{safetensors_version}",
            """Accelerate version""": F"{accelerate_version}",
            """Accelerate config""": F"{accelerate_config_str}",
            """PyTorch version (GPU?)""": F"{pt_version} ({pt_cuda_available})",
            """Tensorflow version (GPU?)""": F"{tf_version} ({tf_cuda_available})",
            """Flax version (CPU?/GPU?/TPU?)""": F"{flax_version} ({jax_backend})",
            """Jax version""": F"{jax_version}",
            """JaxLib version""": F"{jaxlib_version}",
            """Using GPU in script?""": """<fill in>""",
            """Using distributed or parallel set-up in script?""": """<fill in>""",
        }

        print("""\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n"""   )
        print(self.format_dict(_SCREAMING_SNAKE_CASE   )   )

        return info


  @staticmethod
  def 						A__		(   _SCREAMING_SNAKE_CASE   )						->   Dict:



        """simple docstring"""






        return "\n".join([F"- {prop}: {val}" for prop, val in d.items()]   ) + "\n"
