





"""simple docstring"""
import json
import os
import tempfile

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


if is_torch_available():
  import numpy as np
  import torch

if is_vision_available():
  from PIL import Image



def   __lowerCamelCase     (							a_  :	Union[str, Any]				,     a_  :	Dict=False				,     a_  :	int=False				,     a_  :	str=False  )    ->   Tuple:
      assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

      __SCREAMING_SNAKE_CASE     :Optional[int]	       =						[]
      for i in range(image_processor_tester.batch_size  ):
            if equal_resolution:
                  __SCREAMING_SNAKE_CASE     :Optional[int]	       =						image_processor_tester.max_resolution
            else:
                  # To avoid getting image width/height 0
                  __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						image_processor_tester.min_resolution
                  if getattr(a_				,     '''size_divisor'''				,     a_  ):
                        # If `size_divisor` is defined, the image needs to have width/size >= `size_divisor`
                        __SCREAMING_SNAKE_CASE     :Optional[int]	       =						max(image_processor_tester.size_divisor				,     a_  )
                  __SCREAMING_SNAKE_CASE     :List[Any]	       =						np.random.choice(np.arange(a_				,     image_processor_tester.max_resolution  )				,     2  )
            image_inputs.append(
                np.random.randint(2_55				,     size=(image_processor_tester.num_channels, width, height)				,     dtype=np.uinta  )  )

      if not numpify and not torchify:
            # PIL expects the channel dimension as last dimension
            __SCREAMING_SNAKE_CASE     :Any	       =						[Image.fromarray(np.moveaxis(a_				,     0				,     -1  )  ) for image in image_inputs]

      if torchify:
            __SCREAMING_SNAKE_CASE     :Tuple	       =						[torch.from_numpy(a_  ) for image in image_inputs]

      return image_inputs



def   __lowerCamelCase     (							a_  :	Tuple				,     a_  :	Dict=10				,     a_  :	str=10				,     a_  :	Optional[int]=False				,     a_  :	Optional[int]=False  )    ->   Dict:
      __SCREAMING_SNAKE_CASE     :Tuple	       =						[]
      for i in range(image_processor_tester.num_frames  ):
            video.append(np.random.randint(2_55				,     size=(image_processor_tester.num_channels, width, height)				,     dtype=np.uinta  )  )

      if not numpify and not torchify:
            # PIL expects the channel dimension as last dimension
            __SCREAMING_SNAKE_CASE     :Tuple	       =						[Image.fromarray(np.moveaxis(a_				,     0				,     -1  )  ) for frame in video]

      if torchify:
            __SCREAMING_SNAKE_CASE     :int	       =						[torch.from_numpy(a_  ) for frame in video]

      return video



def   __lowerCamelCase     (							a_  :	Optional[Any]				,     a_  :	Dict=False				,     a_  :	int=False				,     a_  :	List[str]=False  )    ->   Any:
      assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

      __SCREAMING_SNAKE_CASE     :List[str]	       =						[]
      for i in range(image_processor_tester.batch_size  ):
            if equal_resolution:
                  __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						image_processor_tester.max_resolution
            else:
                  __SCREAMING_SNAKE_CASE     :Optional[int]	       =						np.random.choice(
                      np.arange(image_processor_tester.min_resolution				,     image_processor_tester.max_resolution  )				,     2  )
                  __SCREAMING_SNAKE_CASE     :Tuple	       =						prepare_video(
                      image_processor_tester=a_				,     width=a_				,     height=a_				,     numpify=a_				,     torchify=a_				,     )
            video_inputs.append(a_  )

      return video_inputs







class       _SCREAMING_SNAKE_CASE:
       SCREAMING_SNAKE_CASE_     :   Dict					=						None




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE     :Optional[int]	       =						self.image_processing_class(**self.image_processor_dict							)
             __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						json.loads(image_processor.to_json_string()							)
             for key, value in self.image_processor_dict.items():
                   self.assertEqual(obj[key]	,SCREAMING_SNAKE_CASE__							)




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





             """simple docstring"""






             __SCREAMING_SNAKE_CASE     :str	       =						self.image_processing_class(**self.image_processor_dict							)

             with tempfile.TemporaryDirectory() as tmpdirname:
                   __SCREAMING_SNAKE_CASE     :List[str]	       =						os.path.join(SCREAMING_SNAKE_CASE__	,'''image_processor.json'''							)
                   image_processor_first.to_json_file(SCREAMING_SNAKE_CASE__							)
                   __SCREAMING_SNAKE_CASE     :List[str]	       =						self.image_processing_class.from_json_file(SCREAMING_SNAKE_CASE__							)

             self.assertEqual(image_processor_second.to_dict()	,image_processor_first.to_dict()							)




       def 					_UpperCamelCase  (		self							)    ->   Union[str, Any]:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE     :Any	       =						self.image_processing_class(**self.image_processor_dict							)

             with tempfile.TemporaryDirectory() as tmpdirname:
                   __SCREAMING_SNAKE_CASE     :str	       =						image_processor_first.save_pretrained(SCREAMING_SNAKE_CASE__							)[0]
                   check_json_file_has_correct_format(SCREAMING_SNAKE_CASE__							)
                   __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						self.image_processing_class.from_pretrained(SCREAMING_SNAKE_CASE__							)

             self.assertEqual(image_processor_second.to_dict()	,image_processor_first.to_dict()							)




       def 					_UpperCamelCase  (		self							)    ->   Any:





             """simple docstring"""






             __SCREAMING_SNAKE_CASE     :Dict	       =						self.image_processing_class()
             self.assertIsNotNone(SCREAMING_SNAKE_CASE__							)




       @require_torch
       @require_vision
       def 					_UpperCamelCase  (		self							)    ->   Dict:





             """simple docstring"""






             if self.test_cast_dtype is not None:
                   # Initialize image_processor
                   __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						self.image_processing_class(**self.image_processor_dict							)

                   # create random PyTorch tensors
                   __SCREAMING_SNAKE_CASE     :List[Any]	       =						prepare_image_inputs(self.image_processor_tester	,equal_resolution=SCREAMING_SNAKE_CASE__	,torchify=SCREAMING_SNAKE_CASE__							)

                   __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						image_processor(SCREAMING_SNAKE_CASE__	,return_tensors='''pt'''							)
                   # for layoutLM compatiblity
                   self.assertEqual(encoding.pixel_values.device	,torch.device('''cpu'''							)							)
                   self.assertEqual(encoding.pixel_values.dtype	,torch.floataa							)

                   __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						image_processor(SCREAMING_SNAKE_CASE__	,return_tensors='''pt'''							).to(torch.floataa							)
                   self.assertEqual(encoding.pixel_values.device	,torch.device('''cpu'''							)							)
                   self.assertEqual(encoding.pixel_values.dtype	,torch.floataa							)

                   __SCREAMING_SNAKE_CASE     :str	       =						image_processor(SCREAMING_SNAKE_CASE__	,return_tensors='''pt'''							).to('''cpu'''	,torch.bfloataa							)
                   self.assertEqual(encoding.pixel_values.device	,torch.device('''cpu'''							)							)
                   self.assertEqual(encoding.pixel_values.dtype	,torch.bfloataa							)

                   with self.assertRaises(SCREAMING_SNAKE_CASE__							):
                         __SCREAMING_SNAKE_CASE     :Optional[int]	       =						image_processor(SCREAMING_SNAKE_CASE__	,return_tensors='''pt'''							).to(torch.bfloataa	,'''cpu'''							)

                   # Try with text + image feature
                   __SCREAMING_SNAKE_CASE     :Tuple	       =						image_processor(SCREAMING_SNAKE_CASE__	,return_tensors='''pt'''							)
                   encoding.update({'''input_ids''': torch.LongTensor([[1, 2, 3], [4, 5, 6]]							)}							)
                   __SCREAMING_SNAKE_CASE     :List[Any]	       =						encoding.to(torch.floataa							)

                   self.assertEqual(encoding.pixel_values.device	,torch.device('''cpu'''							)							)
                   self.assertEqual(encoding.pixel_values.dtype	,torch.floataa							)
                   self.assertEqual(encoding.input_ids.dtype	,torch.long							)






"""simple docstring"""
import json
import os
import tempfile

import datasets
from datasets.arrow_writer import ArrowWriter
from datasets.features import ArrayaD
from utils import generate_examples, get_duration


lowerCamelCase_          =	(3_0, 4_8_7)
lowerCamelCase_          =	(3_6, 1_0_2_4)
lowerCamelCase_          =	(1_0_0, 1_0_0)
lowerCamelCase_          =	1_0_0

lowerCamelCase_          =	datasets.Features(
    {"text": ArrayaD(SHAPE_TEST_1, dtype="float32"), "image": ArrayaD(SHAPE_TEST_2, dtype="float32")}
)

lowerCamelCase_    ,  lowerCamelCase_          =	os.path.split(__file__)
lowerCamelCase_          =	os.path.join(RESULTS_BASEPATH, "results", RESULTS_FILENAME.replace(".py", ".json"))



@get_duration
def   __lowerCamelCase     (							a_  :	Optional[Any]				,     a_  :	List[str]				,     a_  :	List[str]							)    ->   List[str]:
      with ArrowWriter(features=a_				,     path=os.path.join(a_				,     '''beta.arrow'''							)							) as writer:
            for key, record in dummy_data:
                  __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						my_features.encode_example(a_							)
                  writer.write(a_							)
            __SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE     :Optional[Any]	       =						writer.finalize()



@get_duration
def   __lowerCamelCase     (							a_  :	Tuple				,     a_  :	Optional[Any]							)    ->   Dict:
      __SCREAMING_SNAKE_CASE     :Tuple	       =						datasets.Dataset.from_file(
          filename=os.path.join(a_				,     '''beta.arrow'''							)				,     info=datasets.DatasetInfo(features=a_							)							)
      for _ in dataset:
            pass



@get_duration
def   __lowerCamelCase     (							a_  :	List[str]				,     a_  :	List[str]							)    ->   List[Any]:
      __SCREAMING_SNAKE_CASE     :Optional[int]	       =						datasets.Dataset.from_file(
          filename=os.path.join(a_				,     '''beta.arrow'''							)				,     info=datasets.DatasetInfo(features=a_							)							)
      dataset.set_format('''numpy'''							)
      for _ in dataset:
            pass



@get_duration
def   __lowerCamelCase     (							a_  :	Tuple				,     a_  :	Optional[int]							)    ->   Optional[int]:
      __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						10
      __SCREAMING_SNAKE_CASE     :Dict	       =						datasets.Dataset.from_file(
          filename=os.path.join(a_				,     '''beta.arrow'''							)				,     info=datasets.DatasetInfo(features=a_							)							)
      for i in range(0				,     len(a_							)				,     a_							):
            __SCREAMING_SNAKE_CASE     :Dict	       =						dataset[i : i + batch_size]



@get_duration
def   __lowerCamelCase     (							a_  :	Any				,     a_  :	Optional[Any]							)    ->   Optional[Any]:
      __SCREAMING_SNAKE_CASE     :List[Any]	       =						10
      __SCREAMING_SNAKE_CASE     :List[str]	       =						datasets.Dataset.from_file(
          filename=os.path.join(a_				,     '''beta.arrow'''							)				,     info=datasets.DatasetInfo(features=a_							)							)
      dataset.set_format('''numpy'''							)
      for i in range(0				,     len(a_							)				,     a_							):
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						dataset[i : i + batch_size]



@get_duration
def   __lowerCamelCase     (							a_  :	List[Any]				,     a_  :	Optional[Any]							)    ->   List[Any]:
      __SCREAMING_SNAKE_CASE     :Optional[int]	       =						datasets.Dataset.from_file(
          filename=os.path.join(a_				,     '''beta.arrow'''							)				,     info=datasets.DatasetInfo(features=a_							)							)
      for col in feats:
            __SCREAMING_SNAKE_CASE     :Tuple	       =						dataset[col]



@get_duration
def   __lowerCamelCase     (							a_  :	int				,     a_  :	List[str]							)    ->   str:
      __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						datasets.Dataset.from_file(
          filename=os.path.join(a_				,     '''beta.arrow'''							)				,     info=datasets.DatasetInfo(features=a_							)							)
      dataset.set_format('''numpy'''							)
      for col in feats:
            __SCREAMING_SNAKE_CASE     :List[Any]	       =						dataset[col]



def   __lowerCamelCase     (							)    ->   Union[str, Any]:
      __SCREAMING_SNAKE_CASE     :Tuple	       =						{}
      __SCREAMING_SNAKE_CASE     :int	       =						(
          read_unformated,
          read_formatted_as_numpy,
          read_batch_unformated,
          read_batch_formatted_as_numpy,
          read_col_unformated,
          read_col_formatted_as_numpy,
      )
      with tempfile.TemporaryDirectory() as tmp_dir:
            __SCREAMING_SNAKE_CASE     :Dict	       =						datasets.Features({'''image''': ArrayaD(a_				,     dtype='''float32'''							)}							)
            __SCREAMING_SNAKE_CASE     :Any	       =						generate_examples(features=a_				,     num_examples=a_							)
            __SCREAMING_SNAKE_CASE     :Dict	       =						write(a_				,     a_				,     a_							)
            for read_func in read_functions:
                  __SCREAMING_SNAKE_CASE     :str	       =						read_func(a_				,     a_							)

      with tempfile.TemporaryDirectory() as tmp_dir:
            # don't use fixed length for fair comparison
            # feats = datasets.Features(
            #     {"image": datasets.Sequence(datasets.Sequence(datasets.Value("float32"), SPEED_TEST_SHAPE[1]), SPEED_TEST_SHAPE[0])}
            # )
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						datasets.Features({'''image''': datasets.Sequence(datasets.Sequence(datasets.Value('''float32'''							)							)							)}							)
            __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						generate_examples(
                features=a_				,     num_examples=a_				,     seq_shapes={'''image''': SPEED_TEST_SHAPE}							)
            __SCREAMING_SNAKE_CASE     :Tuple	       =						write(a_				,     a_				,     a_							)
            for read_func in read_functions:
                  __SCREAMING_SNAKE_CASE     :Tuple	       =						read_func(a_				,     a_							)

      with tempfile.TemporaryDirectory() as tmp_dir:
            # don't use fixed length for fair comparison
            # feats = datasets.Features(
            #     {"image": datasets.Sequence(datasets.Value("float32"), SPEED_TEST_SHAPE[0] * SPEED_TEST_SHAPE[1])}
            # )
            __SCREAMING_SNAKE_CASE     :Dict	       =						datasets.Features({'''image''': datasets.Sequence(datasets.Value('''float32'''							)							)}							)
            __SCREAMING_SNAKE_CASE     :Dict	       =						generate_examples(
                features=a_				,     num_examples=a_				,     seq_shapes={'''image''': [SPEED_TEST_SHAPE[0] * SPEED_TEST_SHAPE[1]]}				,     )
            __SCREAMING_SNAKE_CASE     :Any	       =						write(a_				,     a_				,     a_							)
            for read_func in read_functions:
                  __SCREAMING_SNAKE_CASE     :str	       =						read_func(a_				,     a_							)

      with open(a_				,     '''wb'''							) as f:
            f.write(json.dumps(a_							).encode('''utf-8'''							)							)


if __name__ == "__main__":  # useful to run the profiler
  benchmark_array_xd()