


'''simple docstring'''

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 					snake_case   (   unittest.TestCase      ):





  """simple docstring"""




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







   """simple docstring"""
   # test transformers-cli env
   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   snake_case		(   self					):







   """simple docstring"""
   import transformers.commands.transformers_cli

   shutil.rmtree("/tmp/hf-internal-testing/tiny-random-gptj"      ,  ignore_errors=UpperCamelCase					)  # 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   snake_case		(   self					):







   """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=UpperCamelCase					)

   # 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   snake_case		(   self					):







   """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=UpperCamelCase					)

   # 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"					)					)







'''simple docstring'''

def __snake_case (				UpperCAmelCase_						:						float		):
 return -num if num < 0 else num





def __snake_case (				UpperCAmelCase_						:						list[int]		):
 if len(UpperCAmelCase_		) == 0:
  raise ValueError("abs_min() arg is an empty sequence"		)
 lowerCamelCase_								=  x[0]
 for i in x:
  if abs_val(UpperCAmelCase_		) < abs_val(UpperCAmelCase_		):
   lowerCamelCase_								=  i
 return j





def __snake_case (				UpperCAmelCase_						:						list[int]		):
 if len(UpperCAmelCase_		) == 0:
  raise ValueError("abs_max() arg is an empty sequence"		)
 lowerCamelCase_								=  x[0]
 for i in x:
  if abs(UpperCAmelCase_		) > abs(UpperCAmelCase_		):
   lowerCamelCase_								=  i
 return j





def __snake_case (				UpperCAmelCase_						:						list[int]		):
 if len(UpperCAmelCase_		) == 0:
  raise ValueError("abs_max_sort() arg is an empty sequence"		)
 return sorted(UpperCAmelCase_ ,    key=UpperCAmelCase_		)[-1]





def __snake_case (				):
 assert abs_val(0		) == 0
 assert abs_val(34		) == 34
 assert abs_val(-100000000000		) == 100000000000

 lowerCamelCase_								=  [-3, -1, 2, -11]
 assert abs_max(UpperCAmelCase_		) == -11
 assert abs_max_sort(UpperCAmelCase_		) == -11
 assert abs_min(UpperCAmelCase_		) == -1


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     test_abs_val()
     print(abs_val(-34))  # --> 34



