code: 
  
  
  
  
  
  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   _UpperCAmelCase	(   unittest.TestCase					):
  
  
  
  
  					@patch("""sys.argv"""    ,      ["""fakeprogrampath""", """env"""]       )
  					def 	snake_case_		(						self       )						->  Dict:
  							# 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       )						->  Union[str, Any]:
  							import transformers.commands.transformers_cli
  
  							shutil.rmtree("""/tmp/hf-internal-testing/tiny-random-gptj"""    ,      ignore_errors=__lowerCAmelCase       )  # 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       )						->  List[str]:
  							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=__lowerCAmelCase       )
  
  							# 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       )						->  Tuple:
  							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=__lowerCAmelCase       )
  
  							# 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"""       )       )
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  from typing import Dict, List, Optional, Union
  
  import numpy as np
  
  from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
  from ...image_transforms import (
      get_resize_output_image_size,
      normalize,
      pad,
      rescale,
      resize,
      to_channel_dimension_format,
  )
  from ...image_utils import (
      IMAGENET_STANDARD_MEAN,
      IMAGENET_STANDARD_STD,
      ChannelDimension,
      ImageInput,
      PILImageResampling,
      get_image_size,
      make_list_of_images,
      to_numpy_array,
      valid_images,
  )
  from ...utils import TensorType, logging
  from ...utils.import_utils import is_vision_available
  
  
  __lowerCAmelCase     =			logging.get_logger(__name__)
  
  
  if is_vision_available():
  				import PIL
  
  
  
  
  class   _UpperCAmelCase	(   _lowercase					):
  					__A          =   ["pixel_values"]
  
  
  
  
  					def __init__(						self    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = PILImageResampling.BILINEAR    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = False    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = 1 / 255    ,      __lowerCAmelCase = True    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  None:
  							super().__init__(**__lowerCAmelCase       )
  
  							UpperCamelCase__         =	size if size is not None else {"""height""": 2_560, """width""": 1_920}
  							if isinstance(__lowerCAmelCase    ,      (tuple, list)       ):
  									# The previous feature extractor size parameter was in (width, height) format
  									UpperCamelCase__         =	size[::-1]
  							UpperCamelCase__         =	get_size_dict(__lowerCAmelCase       )
  
  							UpperCamelCase__         =	do_resize
  							UpperCamelCase__         =	size
  							UpperCamelCase__         =	resample
  							UpperCamelCase__         =	do_thumbnail
  							UpperCamelCase__         =	do_align_long_axis
  							UpperCamelCase__         =	do_pad
  							UpperCamelCase__         =	do_rescale
  							UpperCamelCase__         =	rescale_factor
  							UpperCamelCase__         =	do_normalize
  							UpperCamelCase__         =	image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
  							UpperCamelCase__         =	image_std if image_std is not None else IMAGENET_STANDARD_STD
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None       )						->  np.ndarray:
  							UpperCamelCase__  ,			UpperCamelCase__         =	get_image_size(__lowerCAmelCase       )
  							UpperCamelCase__  ,			UpperCamelCase__         =	size["""height"""], size["""width"""]
  
  							if (output_width < output_height and input_width > input_height) or (
  							    output_width > output_height and input_width < input_height
  							):
  									UpperCamelCase__         =	np.rotaa(__lowerCAmelCase    ,      3       )
  
  							if data_format is not None:
  									UpperCamelCase__         =	to_channel_dimension_format(__lowerCAmelCase    ,      __lowerCAmelCase       )
  
  							return image
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = False    ,      __lowerCAmelCase = None    ,      )						->  np.ndarray:
  							UpperCamelCase__  ,			UpperCamelCase__         =	size["""height"""], size["""width"""]
  							UpperCamelCase__  ,			UpperCamelCase__         =	get_image_size(__lowerCAmelCase       )
  
  							UpperCamelCase__         =	output_width - input_width
  							UpperCamelCase__         =	output_height - input_height
  
  							if random_padding:
  									UpperCamelCase__         =	np.random.randint(low=0    ,      high=delta_height + 1       )
  									UpperCamelCase__         =	np.random.randint(low=0    ,      high=delta_width + 1       )
  							else:
  									UpperCamelCase__         =	delta_height // 2
  									UpperCamelCase__         =	delta_width // 2
  
  							UpperCamelCase__         =	delta_height - pad_top
  							UpperCamelCase__         =	delta_width - pad_left
  
  							UpperCamelCase__         =	((pad_top, pad_bottom), (pad_left, pad_right))
  							return pad(__lowerCAmelCase    ,      __lowerCAmelCase    ,      data_format=__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      *__lowerCAmelCase    ,      **__lowerCAmelCase       )						->  List[Any]:
  							logger.info("""pad is deprecated and will be removed in version 4.27. Please use pad_image instead."""       )
  							return self.pad_image(*__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = PILImageResampling.BICUBIC    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  np.ndarray:
  							UpperCamelCase__  ,			UpperCamelCase__         =	get_image_size(__lowerCAmelCase       )
  							UpperCamelCase__  ,			UpperCamelCase__         =	size["""height"""], size["""width"""]
  
  							# We always resize to the smallest of either the input or output size.
  							UpperCamelCase__         =	min(__lowerCAmelCase    ,      __lowerCAmelCase       )
  							UpperCamelCase__         =	min(__lowerCAmelCase    ,      __lowerCAmelCase       )
  
  							if height == input_height and width == input_width:
  									return image
  
  							if input_height > input_width:
  									UpperCamelCase__         =	int(input_width * height / input_height       )
  							elif input_width > input_height:
  									UpperCamelCase__         =	int(input_height * width / input_width       )
  
  							return resize(
  							    __lowerCAmelCase    ,      size=(height, width)    ,      resample=__lowerCAmelCase    ,      reducing_gap=2.0    ,      data_format=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = PILImageResampling.BICUBIC    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  np.ndarray:
  							UpperCamelCase__         =	get_size_dict(__lowerCAmelCase       )
  							UpperCamelCase__         =	min(size["""height"""]    ,      size["""width"""]       )
  							UpperCamelCase__         =	get_resize_output_image_size(__lowerCAmelCase    ,      size=__lowerCAmelCase    ,      default_to_square=__lowerCAmelCase       )
  							UpperCamelCase__         =	resize(__lowerCAmelCase    ,      size=__lowerCAmelCase    ,      resample=__lowerCAmelCase    ,      data_format=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  							return resized_image
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  List[str]:
  							return rescale(__lowerCAmelCase    ,      scale=__lowerCAmelCase    ,      data_format=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None    ,      **__lowerCAmelCase    ,      )						->  np.ndarray:
  							return normalize(__lowerCAmelCase    ,      mean=__lowerCAmelCase    ,      std=__lowerCAmelCase    ,      data_format=__lowerCAmelCase    ,      **__lowerCAmelCase       )
  
  
  
  
  					def 	snake_case_		(						self    ,      __lowerCAmelCase    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = False    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = None    ,      __lowerCAmelCase = ChannelDimension.FIRST    ,      **__lowerCAmelCase    ,      )						->  PIL.Image.Image:
  							UpperCamelCase__         =	do_resize if do_resize is not None else self.do_resize
  							UpperCamelCase__         =	size if size is not None else self.size
  							if isinstance(__lowerCAmelCase    ,      (tuple, list)       ):
  									# Previous feature extractor had size in (width, height) format
  									UpperCamelCase__         =	size[::-1]
  							UpperCamelCase__         =	get_size_dict(__lowerCAmelCase       )
  							UpperCamelCase__         =	resample if resample is not None else self.resample
  							UpperCamelCase__         =	do_thumbnail if do_thumbnail is not None else self.do_thumbnail
  							UpperCamelCase__         =	do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
  							UpperCamelCase__         =	do_pad if do_pad is not None else self.do_pad
  							UpperCamelCase__         =	do_rescale if do_rescale is not None else self.do_rescale
  							UpperCamelCase__         =	rescale_factor if rescale_factor is not None else self.rescale_factor
  							UpperCamelCase__         =	do_normalize if do_normalize is not None else self.do_normalize
  							UpperCamelCase__         =	image_mean if image_mean is not None else self.image_mean
  							UpperCamelCase__         =	image_std if image_std is not None else self.image_std
  
  							UpperCamelCase__         =	make_list_of_images(__lowerCAmelCase       )
  
  							if not valid_images(__lowerCAmelCase       ):
  									raise ValueError(
  									    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
  									    """torch.Tensor, tf.Tensor or jax.ndarray."""       )
  
  							if do_resize and size is None:
  									raise ValueError("""Size must be specified if do_resize is True."""       )
  
  							if do_rescale and rescale_factor is None:
  									raise ValueError("""Rescale factor must be specified if do_rescale is True."""       )
  
  							if do_pad and size is None:
  									raise ValueError("""Size must be specified if do_pad is True."""       )
  
  							if do_normalize and (image_mean is None or image_std is None):
  									raise ValueError("""Image mean and std must be specified if do_normalize is True."""       )
  
  							# All transformations expect numpy arrays.
  							UpperCamelCase__         =	[to_numpy_array(__lowerCAmelCase       ) for image in images]
  
  							if do_align_long_axis:
  									UpperCamelCase__         =	[self.align_long_axis(__lowerCAmelCase    ,      size=__lowerCAmelCase       ) for image in images]
  
  							if do_resize:
  									UpperCamelCase__         =	[self.resize(image=__lowerCAmelCase    ,      size=__lowerCAmelCase    ,      resample=__lowerCAmelCase       ) for image in images]
  
  							if do_thumbnail:
  									UpperCamelCase__         =	[self.thumbnail(image=__lowerCAmelCase    ,      size=__lowerCAmelCase       ) for image in images]
  
  							if do_pad:
  									UpperCamelCase__         =	[self.pad_image(image=__lowerCAmelCase    ,      size=__lowerCAmelCase    ,      random_padding=__lowerCAmelCase       ) for image in images]
  
  							if do_rescale:
  									UpperCamelCase__         =	[self.rescale(image=__lowerCAmelCase    ,      scale=__lowerCAmelCase       ) for image in images]
  
  							if do_normalize:
  									UpperCamelCase__         =	[self.normalize(image=__lowerCAmelCase    ,      mean=__lowerCAmelCase    ,      std=__lowerCAmelCase       ) for image in images]
  
  							UpperCamelCase__         =	[to_channel_dimension_format(__lowerCAmelCase    ,      __lowerCAmelCase       ) for image in images]
  
  							UpperCamelCase__         =	{"""pixel_values""": images}
  							return BatchFeature(data=__lowerCAmelCase    ,      tensor_type=__lowerCAmelCase       )
  
  
  
  
  
  