





import csv
import json
import logging
import os
import re
import subprocess
import tempfile
import unittest
import zipfile
from pathlib import Path
from typing import Optional
from unittest import mock

import torch

# We use TF to parse the logs
from accelerate import Accelerator
from accelerate.test_utils.testing import (
    MockingTestCase,
    TempDirTestCase,
    require_comet_ml,
    require_tensorboard,
    require_wandb,
    skip,
)
from accelerate.tracking import CometMLTracker, GeneralTracker
from accelerate.utils import ProjectConfiguration, is_comet_ml_available, is_tensorboard_available


if is_comet_ml_available():
			from comet_ml import OfflineExperiment

if is_tensorboard_available():
			import struct

			import tensorboard.compat.proto.event_pba as event_pba

_a									=				logging.getLogger(__name__)






@require_tensorboard
class  __A   (   unittest.TestCase			):

			'''simple docstring'''







			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		'''test_project_with_config'''
				with tempfile.TemporaryDirectory() as dirpath:
					lowerCamelCase__        =		Accelerator(log_with='''tensorboard'''	,  project_dir=SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		{'''num_iterations''': 1_2, '''learning_rate''': 1E-2, '''some_boolean''': False, '''some_string''': '''some_value'''}
					accelerator.init_trackers(SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_							)
					accelerator.end_training()
					for child in Path(F'{dirpath}/{project_name}'							).glob('''*/**'''							):
						lowerCamelCase__        =		list(filter(lambda __lowerCAmelCase							: x.is_file()	,  child.iterdir()							)							)[0]
					self.assertNotEqual(str(SCREAMING_SNAKE_CASE_							)	,  ''''''							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		'''test_project_with_log'''
				with tempfile.TemporaryDirectory() as dirpath:
					lowerCamelCase__        =		Accelerator(log_with='''tensorboard'''	,  project_dir=SCREAMING_SNAKE_CASE_							)
					accelerator.init_trackers(SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		{'''total_loss''': 0.1, '''iteration''': 1, '''my_text''': '''some_value'''}
					accelerator.log(SCREAMING_SNAKE_CASE_	,  step=0							)
					accelerator.end_training()
					# Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord
					# Names are randomly generated each time
					lowerCamelCase__        =		list(filter(lambda __lowerCAmelCase							: x.is_file()	,  Path(F'{dirpath}/{project_name}'							).iterdir()							)							)[0]
					self.assertNotEqual(str(SCREAMING_SNAKE_CASE_							)	,  ''''''							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		'''test_project_with_log'''
				with tempfile.TemporaryDirectory() as dirpath:
					lowerCamelCase__        =		Accelerator(log_with='''tensorboard'''	,  project_dir=SCREAMING_SNAKE_CASE_							)
					accelerator.init_trackers(SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		{'''tensor''': torch.tensor(1							)}
					accelerator.log(SCREAMING_SNAKE_CASE_	,  step=0							)
					accelerator.end_training()
					# Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord
					# Names are randomly generated each time
					lowerCamelCase__        =		list(filter(lambda __lowerCAmelCase							: x.is_file()	,  Path(F'{dirpath}/{project_name}'							).iterdir()							)							)[0]
					# Reading implementation based on https://github.com/pytorch/pytorch/issues/45327#issuecomment-703757685
					with open(SCREAMING_SNAKE_CASE_	,  '''rb'''							) as f:
						lowerCamelCase__        =		f.read()
					lowerCamelCase__        =		False
					while data:
						lowerCamelCase__        =		struct.unpack('''Q'''	,  data[:8]							)

						lowerCamelCase__        =		data[1_2 : 1_2 + int(header[0]							)]  # 8+4
						lowerCamelCase__        =		data[1_2 + int(header[0]							) + 4 :]
						lowerCamelCase__        =		event_pba.Event()

						event.ParseFromString(SCREAMING_SNAKE_CASE_							)
						if event.HasField('''summary'''							):
							for value in event.summary.value:
								if value.simple_value == 1.0 and value.tag == "tensor":
									lowerCamelCase__        =		True
					self.assertTrue(SCREAMING_SNAKE_CASE_	,  '''Converted tensor was not found in the log file!'''							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				with self.assertRaisesRegex(SCREAMING_SNAKE_CASE_	,  '''Logging with `tensorboard` requires a `logging_dir`'''							):
					lowerCamelCase__        =		Accelerator(log_with='''tensorboard'''							)
				with tempfile.TemporaryDirectory() as dirpath:
					lowerCamelCase__        =		Accelerator(log_with='''tensorboard'''	,  project_dir=SCREAMING_SNAKE_CASE_							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		ProjectConfiguration(total_limit=3_0							)
				with tempfile.TemporaryDirectory() as dirpath:
					lowerCamelCase__        =		Accelerator(log_with='''tensorboard'''	,  project_dir=SCREAMING_SNAKE_CASE_	,  project_config=SCREAMING_SNAKE_CASE_							)






@require_wandb
@mock.patch.dict(os.environ      ,    {"""WANDB_MODE""": """offline"""}			)
class  __A   (   SCREAMING_SNAKE_CASE_      ,    SCREAMING_SNAKE_CASE_			):

			'''simple docstring'''







			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				super().setUp()
				# wandb let's us override where logs are stored to via the WANDB_DIR env var
				self.add_mocks(mock.patch.dict(os.environ	,  {'''WANDB_DIR''': self.tmpdir}							)							)





			@staticmethod
			def 		__lowerCamelCase    (   __lowerCAmelCase	,  __lowerCAmelCase	,  __lowerCAmelCase = True							):



				'''simple docstring'''







				lowerCamelCase__        =		rF'{section} ([\S\s]*?)\n\n'
				if record:
					lowerCamelCase__        =		rF'Record: {pattern}'
				lowerCamelCase__        =		re.findall(SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_							)[0]
				# A config
				if section == "config" or section == "history":
					lowerCamelCase__        =		re.findall(r'''"([a-zA-Z0-9_.,]+)'''	,  SCREAMING_SNAKE_CASE_							)
					return {key: val for key, val in zip(cleaned_record[0::2]	,  cleaned_record[1::2]							)}
				# Everything else
				else:
					return dict(re.findall(r'''(\w+): "([^\s]+)"'''	,  SCREAMING_SNAKE_CASE_							)							)





			@skip
			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		'''test_project_with_config'''
				lowerCamelCase__        =		Accelerator(log_with='''wandb'''							)
				lowerCamelCase__        =		{'''num_iterations''': 1_2, '''learning_rate''': 1E-2, '''some_boolean''': False, '''some_string''': '''some_value'''}
				lowerCamelCase__        =		{'''wandb''': {'''tags''': ['''my_tag''']}}
				accelerator.init_trackers(SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_							)
				lowerCamelCase__        =		{'''total_loss''': 0.1, '''iteration''': 1, '''my_text''': '''some_value'''}
				accelerator.log(SCREAMING_SNAKE_CASE_	,  step=0							)
				accelerator.end_training()
				# The latest offline log is stored at wandb/latest-run/*.wandb
				for child in Path(F'{self.tmpdir}/wandb/latest-run'							).glob('''*'''							):
					if child.is_file() and child.suffix == ".wandb":
						lowerCamelCase__        =		subprocess.check_output(
						    ['''wandb''', '''sync''', '''--view''', '''--verbose''', str(SCREAMING_SNAKE_CASE_							)]	,  env=os.environ.copy()							).decode('''utf8'''	,  '''ignore'''							)
						break

        # Check HPS through careful parsing and cleaning
				lowerCamelCase__        =		self.parse_log(SCREAMING_SNAKE_CASE_	,  '''config'''							)
				self.assertEqual(logged_items['''num_iterations''']	,  '''12'''							)
				self.assertEqual(logged_items['''learning_rate''']	,  '''0.01'''							)
				self.assertEqual(logged_items['''some_boolean''']	,  '''false'''							)
				self.assertEqual(logged_items['''some_string''']	,  '''some_value'''							)
				self.assertEqual(logged_items['''some_string''']	,  '''some_value'''							)

				# Run tags
				lowerCamelCase__        =		self.parse_log(SCREAMING_SNAKE_CASE_	,  '''run'''	,  SCREAMING_SNAKE_CASE_							)
				self.assertEqual(logged_items['''tags''']	,  '''my_tag'''							)

				# Actual logging
				lowerCamelCase__        =		self.parse_log(SCREAMING_SNAKE_CASE_	,  '''history'''							)
				self.assertEqual(logged_items['''total_loss''']	,  '''0.1'''							)
				self.assertEqual(logged_items['''iteration''']	,  '''1'''							)
				self.assertEqual(logged_items['''my_text''']	,  '''some_value'''							)
				self.assertEqual(logged_items['''_step''']	,  '''0'''							)





def lowerCAmelCase__(    self	,__snake_case	,__snake_case							)    ->				Any:







	'''simple docstring'''







	lowerCamelCase__        =		run_name
	lowerCamelCase__        =		OfflineExperiment(project_name=__snake_case	,offline_directory=__snake_case							)
	logger.info(F'Initialized offline CometML project {self.run_name}'							)
	logger.info('''Make sure to log any initial configurations with `self.store_init_configuration` before training!'''							)






@require_comet_ml
@mock.patch.object(SCREAMING_SNAKE_CASE_      ,    """__init__"""      ,    SCREAMING_SNAKE_CASE_			)
class  __A   (   unittest.TestCase			):

			'''simple docstring'''







			@staticmethod
			def 		__lowerCamelCase    (   __lowerCAmelCase	,  __lowerCAmelCase	,  __lowerCAmelCase = False							):



				'''simple docstring'''







				for log in log_list:
					lowerCamelCase__        =		json.loads(SCREAMING_SNAKE_CASE_							)['''payload''']
					if is_param and "param" in j.keys():
						if j["param"]["paramName"] == key:
							return j["param"]["paramValue"]
					if "log_other" in j.keys():
						if j["log_other"]["key"] == key:
							return j["log_other"]["val"]
					if "metric" in j.keys():
						if j["metric"]["metricName"] == key:
							return j["metric"]["metricValue"]





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				with tempfile.TemporaryDirectory() as d:
					lowerCamelCase__        =		CometMLTracker('''test_project_with_config'''	,  SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		Accelerator(log_with=SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		{'''num_iterations''': 1_2, '''learning_rate''': 1E-2, '''some_boolean''': False, '''some_string''': '''some_value'''}
					accelerator.init_trackers(SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_							)
					accelerator.end_training()
					lowerCamelCase__        =		os.listdir(SCREAMING_SNAKE_CASE_							)[0]  # Comet is nice, it's just a zip file here
					# We parse the raw logs
					lowerCamelCase__        =		os.path.join(SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		zipfile.ZipFile(SCREAMING_SNAKE_CASE_	,  '''r'''							)
					lowerCamelCase__        =		archive.open('''messages.json'''							).read().decode('''utf-8'''							)
				lowerCamelCase__        =		log.split('''\n'''							)[:-1]
				self.assertEqual(self.get_value_from_key(SCREAMING_SNAKE_CASE_	,  '''num_iterations'''	,  SCREAMING_SNAKE_CASE_							)	,  1_2							)
				self.assertEqual(self.get_value_from_key(SCREAMING_SNAKE_CASE_	,  '''learning_rate'''	,  SCREAMING_SNAKE_CASE_							)	,  0.01							)
				self.assertEqual(self.get_value_from_key(SCREAMING_SNAKE_CASE_	,  '''some_boolean'''	,  SCREAMING_SNAKE_CASE_							)	,  SCREAMING_SNAKE_CASE_							)
				self.assertEqual(self.get_value_from_key(SCREAMING_SNAKE_CASE_	,  '''some_string'''	,  SCREAMING_SNAKE_CASE_							)	,  '''some_value'''							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				with tempfile.TemporaryDirectory() as d:
					lowerCamelCase__        =		CometMLTracker('''test_project_with_config'''	,  SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		Accelerator(log_with=SCREAMING_SNAKE_CASE_							)
					accelerator.init_trackers(SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		{'''total_loss''': 0.1, '''iteration''': 1, '''my_text''': '''some_value'''}
					accelerator.log(SCREAMING_SNAKE_CASE_	,  step=0							)
					accelerator.end_training()
					lowerCamelCase__        =		os.listdir(SCREAMING_SNAKE_CASE_							)[0]  # Comet is nice, it's just a zip file here
					# We parse the raw logs
					lowerCamelCase__        =		os.path.join(SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		zipfile.ZipFile(SCREAMING_SNAKE_CASE_	,  '''r'''							)
					lowerCamelCase__        =		archive.open('''messages.json'''							).read().decode('''utf-8'''							)
				lowerCamelCase__        =		log.split('''\n'''							)[:-1]
				self.assertEqual(self.get_value_from_key(SCREAMING_SNAKE_CASE_	,  '''curr_step'''	,  SCREAMING_SNAKE_CASE_							)	,  0							)
				self.assertEqual(self.get_value_from_key(SCREAMING_SNAKE_CASE_	,  '''total_loss'''							)	,  0.1							)
				self.assertEqual(self.get_value_from_key(SCREAMING_SNAKE_CASE_	,  '''iteration'''							)	,  1							)
				self.assertEqual(self.get_value_from_key(SCREAMING_SNAKE_CASE_	,  '''my_text'''							)	,  '''some_value'''							)






class  __A   (   SCREAMING_SNAKE_CASE_			):

			'''simple docstring'''







			lowerCAmelCase_												=						[
			    """total_loss""",
			    """iteration""",
			    """my_text""",
			    """learning_rate""",
			    """num_iterations""",
			    """some_boolean""",
			    """some_string""",
			]

			lowerCAmelCase_												=						"""my_custom_tracker"""
			lowerCAmelCase_												=						False





			def __init__(   self	,  __lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__        =		open(F'{dir}/log.csv'	,  '''w+'''							)
				lowerCamelCase__        =		csv.DictWriter(self.f	,  fieldnames=self._col_names							)
				self.writer.writeheader()





			@property
			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				return self.writer





			def 		__lowerCamelCase    (   self	,  __lowerCAmelCase							):



				'''simple docstring'''







				logger.info('''Call init'''							)
				self.writer.writerow(SCREAMING_SNAKE_CASE_							)





			def 		__lowerCamelCase    (   self	,  __lowerCAmelCase	,  __lowerCAmelCase							):



				'''simple docstring'''







				logger.info('''Call log'''							)
				self.writer.writerow(SCREAMING_SNAKE_CASE_							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				self.f.close()






class  __A   (   unittest.TestCase			):

			'''simple docstring'''







			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				with tempfile.TemporaryDirectory() as d:
					lowerCamelCase__        =		MyCustomTracker(SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		Accelerator(log_with=SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		{'''num_iterations''': 1_2, '''learning_rate''': 1E-2, '''some_boolean''': False, '''some_string''': '''some_value'''}
					accelerator.init_trackers('''Some name'''	,  SCREAMING_SNAKE_CASE_							)
					accelerator.end_training()
					with open(F'{d}/log.csv'	,  '''r'''							) as f:
						lowerCamelCase__        =		csv.DictReader(SCREAMING_SNAKE_CASE_							)
						lowerCamelCase__        =		next(SCREAMING_SNAKE_CASE_							)
						lowerCamelCase__        =		{
						    '''total_loss''': '''''',
						    '''iteration''': '''''',
						    '''my_text''': '''''',
						    '''learning_rate''': '''0.01''',
						    '''num_iterations''': '''12''',
						    '''some_boolean''': '''False''',
						    '''some_string''': '''some_value''',
						}
						self.assertDictEqual(SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				with tempfile.TemporaryDirectory() as d:
					lowerCamelCase__        =		MyCustomTracker(SCREAMING_SNAKE_CASE_							)
					lowerCamelCase__        =		Accelerator(log_with=SCREAMING_SNAKE_CASE_							)
					accelerator.init_trackers('''Some name'''							)
					lowerCamelCase__        =		{'''total_loss''': 0.1, '''iteration''': 1, '''my_text''': '''some_value'''}
					accelerator.log(SCREAMING_SNAKE_CASE_	,  step=0							)
					accelerator.end_training()
					with open(F'{d}/log.csv'	,  '''r'''							) as f:
						lowerCamelCase__        =		csv.DictReader(SCREAMING_SNAKE_CASE_							)
						lowerCamelCase__        =		next(SCREAMING_SNAKE_CASE_							)
						lowerCamelCase__        =		{
						    '''total_loss''': '''0.1''',
						    '''iteration''': '''1''',
						    '''my_text''': '''some_value''',
						    '''learning_rate''': '''''',
						    '''num_iterations''': '''''',
						    '''some_boolean''': '''''',
						    '''some_string''': '''''',
						}
						self.assertDictEqual(SCREAMING_SNAKE_CASE_	,  SCREAMING_SNAKE_CASE_							)










import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
			import torch

if is_vision_available():
			from PIL import Image

			from transformers import ViltImageProcessor






class  __A   (   unittest.TestCase			):

			'''simple docstring'''







			def __init__(   self	,  __lowerCAmelCase	,  __lowerCAmelCase=7	,  __lowerCAmelCase=3	,  __lowerCAmelCase=1_8	,  __lowerCAmelCase=3_0	,  __lowerCAmelCase=4_0_0	,  __lowerCAmelCase=True	,  __lowerCAmelCase=None	,  __lowerCAmelCase=2	,  __lowerCAmelCase=True	,  __lowerCAmelCase=[0.5, 0.5, 0.5]	,  __lowerCAmelCase=[0.5, 0.5, 0.5]	,  ):



				'''simple docstring'''







				lowerCamelCase__        =		size if size is not None else {'''shortest_edge''': 3_0}
				lowerCamelCase__        =		parent
				lowerCamelCase__        =		batch_size
				lowerCamelCase__        =		num_channels
				lowerCamelCase__        =		image_size
				lowerCamelCase__        =		min_resolution
				lowerCamelCase__        =		max_resolution
				lowerCamelCase__        =		do_resize
				lowerCamelCase__        =		size
				lowerCamelCase__        =		size_divisor
				lowerCamelCase__        =		do_normalize
				lowerCamelCase__        =		image_mean
				lowerCamelCase__        =		image_std





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				return {
				    "image_mean": self.image_mean,
				    "image_std": self.image_std,
				    "do_normalize": self.do_normalize,
				    "do_resize": self.do_resize,
				    "size": self.size,
				    "size_divisor": self.size_divisor,
				}





			def 		__lowerCamelCase    (   self	,  __lowerCAmelCase	,  __lowerCAmelCase=False							):



				'''simple docstring'''







				if not batched:
					lowerCamelCase__        =		self.size['''shortest_edge''']
					lowerCamelCase__        =		image_inputs[0]
					if isinstance(__lowerCAmelCase	,  Image.Image							):
						lowerCamelCase__    ,     lowerCamelCase__        =		image.size
					else:
						lowerCamelCase__    ,     lowerCamelCase__        =		image.shape[1], image.shape[2]
					lowerCamelCase__        =		size / min(__lowerCAmelCase	,  __lowerCAmelCase							)
					if h < w:
						lowerCamelCase__    ,     lowerCamelCase__        =		size, scale * w
					else:
						lowerCamelCase__    ,     lowerCamelCase__        =		scale * h, size

					lowerCamelCase__        =		int((1_3_3_3 / 8_0_0) * size							)
					if max(__lowerCAmelCase	,  __lowerCAmelCase							) > max_size:
						lowerCamelCase__        =		max_size / max(__lowerCAmelCase	,  __lowerCAmelCase							)
						lowerCamelCase__        =		newh * scale
						lowerCamelCase__        =		neww * scale

					lowerCamelCase__    ,     lowerCamelCase__        =		int(newh + 0.5							), int(neww + 0.5							)
					lowerCamelCase__    ,     lowerCamelCase__        =		(
					    newh // self.size_divisor * self.size_divisor,
					    neww // self.size_divisor * self.size_divisor,
					)

				else:
					lowerCamelCase__        =		[]
					for image in image_inputs:
						lowerCamelCase__    ,     lowerCamelCase__        =		self.get_expected_values([image]							)
						expected_values.append((expected_height, expected_width)							)
					lowerCamelCase__        =		max(__lowerCAmelCase	,  key=lambda __lowerCAmelCase							: item[0]							)[0]
					lowerCamelCase__        =		max(__lowerCAmelCase	,  key=lambda __lowerCAmelCase							: item[1]							)[1]

				return expected_height, expected_width






@require_torch
@require_vision
class  __A   (   lowerCAmelCase      ,    unittest.TestCase			):

			'''simple docstring'''







			lowerCAmelCase_												=						ViltImageProcessor if is_vision_available() else None





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		ViltImageProcessingTester(self							)





			@property
			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				return self.image_processor_tester.prepare_image_processor_dict()





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		self.image_processing_class(**self.image_processor_dict							)
				self.assertTrue(hasattr(__lowerCAmelCase	,  '''image_mean'''							)							)
				self.assertTrue(hasattr(__lowerCAmelCase	,  '''image_std'''							)							)
				self.assertTrue(hasattr(__lowerCAmelCase	,  '''do_normalize'''							)							)
				self.assertTrue(hasattr(__lowerCAmelCase	,  '''do_resize'''							)							)
				self.assertTrue(hasattr(__lowerCAmelCase	,  '''size'''							)							)
				self.assertTrue(hasattr(__lowerCAmelCase	,  '''size_divisor'''							)							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		self.image_processing_class.from_dict(self.image_processor_dict							)
				self.assertEqual(image_processor.size	,  {'''shortest_edge''': 3_0}							)

				lowerCamelCase__        =		self.image_processing_class.from_dict(self.image_processor_dict	,  size=4_2							)
				self.assertEqual(image_processor.size	,  {'''shortest_edge''': 4_2}							)





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				pass





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		self.image_processing_class(**self.image_processor_dict							)
				# create random PIL images
				lowerCamelCase__        =		prepare_image_inputs(self.image_processor_tester	,  equal_resolution=__lowerCAmelCase							)
				for image in image_inputs:
					self.assertIsInstance(__lowerCAmelCase	,  Image.Image							)

				# Test not batched input
				lowerCamelCase__        =		image_processing(image_inputs[0]	,  return_tensors='''pt'''							).pixel_values

				lowerCamelCase__    ,     lowerCamelCase__        =		self.image_processor_tester.get_expected_values(__lowerCAmelCase							)
				self.assertEqual(
				    encoded_images.shape	,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)	,  )

				# Test batched
				lowerCamelCase__        =		image_processing(__lowerCAmelCase	,  return_tensors='''pt'''							).pixel_values

				lowerCamelCase__    ,     lowerCamelCase__        =		self.image_processor_tester.get_expected_values(__lowerCAmelCase	,  batched=__lowerCAmelCase							)
				self.assertEqual(
				    encoded_images.shape	,  (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        expected_height,
				        expected_width,
				    )	,  )





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		self.image_processing_class(**self.image_processor_dict							)
				# create random numpy tensors
				lowerCamelCase__        =		prepare_image_inputs(self.image_processor_tester	,  equal_resolution=__lowerCAmelCase	,  numpify=__lowerCAmelCase							)
				for image in image_inputs:
					self.assertIsInstance(__lowerCAmelCase	,  np.ndarray							)

				# Test not batched input
				lowerCamelCase__        =		image_processing(image_inputs[0]	,  return_tensors='''pt'''							).pixel_values

				lowerCamelCase__    ,     lowerCamelCase__        =		self.image_processor_tester.get_expected_values(__lowerCAmelCase							)
				self.assertEqual(
				    encoded_images.shape	,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)	,  )

				# Test batched
				lowerCamelCase__        =		image_processing(__lowerCAmelCase	,  return_tensors='''pt'''							).pixel_values

				lowerCamelCase__    ,     lowerCamelCase__        =		self.image_processor_tester.get_expected_values(__lowerCAmelCase	,  batched=__lowerCAmelCase							)
				self.assertEqual(
				    encoded_images.shape	,  (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        expected_height,
				        expected_width,
				    )	,  )





			def 		__lowerCamelCase    (   self							):



				'''simple docstring'''







				lowerCamelCase__        =		self.image_processing_class(**self.image_processor_dict							)
				# create random PyTorch tensors
				lowerCamelCase__        =		prepare_image_inputs(self.image_processor_tester	,  equal_resolution=__lowerCAmelCase	,  torchify=__lowerCAmelCase							)
				for image in image_inputs:
					self.assertIsInstance(__lowerCAmelCase	,  torch.Tensor							)

				# Test not batched input
				lowerCamelCase__        =		image_processing(image_inputs[0]	,  return_tensors='''pt'''							).pixel_values

				lowerCamelCase__    ,     lowerCamelCase__        =		self.image_processor_tester.get_expected_values(__lowerCAmelCase							)
				self.assertEqual(
				    encoded_images.shape	,  (1, self.image_processor_tester.num_channels, expected_height, expected_width)	,  )

				# Test batched
				lowerCamelCase__        =		image_processing(__lowerCAmelCase	,  return_tensors='''pt'''							).pixel_values

				lowerCamelCase__    ,     lowerCamelCase__        =		self.image_processor_tester.get_expected_values(__lowerCAmelCase	,  batched=__lowerCAmelCase							)
				self.assertEqual(
				    encoded_images.shape	,  (
				        self.image_processor_tester.batch_size,
				        self.image_processor_tester.num_channels,
				        expected_height,
				        expected_width,
				    )	,  )



