





import os
import shutil
import unittest
from unittest.mock import patch

from transformers.testing_utils import CaptureStd, is_pt_tf_cross_test, require_torch


class 					__magic_name__  (							unittest.TestCase							):





     """simple docstring"""



     @patch("sys.argv"			,      ["fakeprogrampath", "env"]  )
     def 						SCREAMING_SNAKE_CASE		(							self       :str  ):





        '''simple docstring'''




        import transformers.commands.transformers_cli

        with CaptureStd() as cs:
           transformers.commands.transformers_cli.main()
        self.assertIn("Python version"			,      cs.out  )
        self.assertIn("Platform"			,      cs.out  )
        self.assertIn("Using distributed or parallel set-up in script?"			,      cs.out  )



     @is_pt_tf_cross_test
     @patch(
         "sys.argv"			,      ["fakeprogrampath", "pt-to-tf", "--model-name", "hf-internal-testing/tiny-random-gptj", "--no-pr"]  )
     def 						SCREAMING_SNAKE_CASE		(							self       :Union[str, Any]  ):





        '''simple docstring'''




        import transformers.commands.transformers_cli

        shutil.rmtree("/tmp/hf-internal-testing/tiny-random-gptj"			,      ignore_errors=snake_case  )  # cleans potential past runs
        transformers.commands.transformers_cli.main()

        # The original repo has no TF weights -- if they exist, they were created by the CLI
        self.assertTrue(os.path.exists("/tmp/hf-internal-testing/tiny-random-gptj/tf_model.h5"  )  )



     @require_torch
     @patch("sys.argv"			,      ["fakeprogrampath", "download", "hf-internal-testing/tiny-random-gptj", "--cache-dir", "/tmp"]  )
     def 						SCREAMING_SNAKE_CASE		(							self       :List[Any]  ):





        '''simple docstring'''




        import transformers.commands.transformers_cli

        # # remove any previously downloaded model to start clean
        shutil.rmtree("/tmp/models--hf-internal-testing--tiny-random-gptj"			,      ignore_errors=snake_case  )

        # run the command
        transformers.commands.transformers_cli.main()

        # check if the model files are downloaded correctly on /tmp/models--hf-internal-testing--tiny-random-gptj
        self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/blobs"  )  )
        self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/refs"  )  )
        self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--tiny-random-gptj/snapshots"  )  )





     @require_torch
     @patch(
         "sys.argv"			,      [
             "fakeprogrampath",
             "download",
             "hf-internal-testing/test_dynamic_model_with_tokenizer",
             "--trust-remote-code",
             "--cache-dir",
             "/tmp",
         ]			,      )
     def 						SCREAMING_SNAKE_CASE		(							self       :Union[str, Any]  ):





        '''simple docstring'''




        import transformers.commands.transformers_cli

        # # remove any previously downloaded model to start clean
        shutil.rmtree("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer"			,      ignore_errors=snake_case  )

        # run the command
        transformers.commands.transformers_cli.main()

        # check if the model files are downloaded correctly on /tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer
        self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/blobs"  )  )
        self.assertTrue(os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/refs"  )  )
        self.assertTrue(
            os.path.exists("/tmp/models--hf-internal-testing--test_dynamic_model_with_tokenizer/snapshots"  )  )






def      __snake_case						(					_lowerCAmelCase : int				,				_lowerCAmelCase : int = 1000	) ->						str:
   if (not isinstance(_lowerCAmelCase				,				_lowerCAmelCase	)) or (digit_position <= 0):
      raise ValueError("Digit position must be a positive integer"	)
   elif (not isinstance(_lowerCAmelCase				,				_lowerCAmelCase	)) or (precision < 0):
      raise ValueError("Precision must be a nonnegative integer"	)

   # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
   # accurate
   A_					:				List[str]          =			(
       4 * _subsum(_lowerCAmelCase				,				1				,				_lowerCAmelCase	)
       - 2 * _subsum(_lowerCAmelCase				,				4				,				_lowerCAmelCase	)
       - _subsum(_lowerCAmelCase				,				5				,				_lowerCAmelCase	)
       - _subsum(_lowerCAmelCase				,				6				,				_lowerCAmelCase	)
   )

   # return the first hex digit of the fractional part of the result
   return hex(int((sum_result % 1) * 16	)	)[2:]

def      __snake_case						(					_lowerCAmelCase : int				,				_lowerCAmelCase : int				,				_lowerCAmelCase : int	) ->						float:
   A_					:				int          =			0.0
   for sum_index in range(digit_pos_to_extract + precision	):
      A_					:				Optional[int]          =			8 * sum_index + denominator_addend
      if sum_index < digit_pos_to_extract:
         # if the exponential term is an integer and we mod it by the denominator
         # before dividing, only the integer part of the sum will change;
         # the fractional part will not
         A_					:				Optional[Any]          =			pow(
             16				,				digit_pos_to_extract - 1 - sum_index				,				_lowerCAmelCase	)
      else:
         A_					:				Tuple          =			pow(16				,				digit_pos_to_extract - 1 - sum_index	)
      total += exponential_term / denominator
   return total


if __name__ == "__main__":
 import doctest

 doctest.testmod()
