



"""simple docstring"""
import contextlib
import importlib
import io
import unittest

import transformers

# Try to import everything from transformers to ensure every object can be loaded.
from transformers import *  # noqa F406
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, require_flax, require_tf, require_torch
from transformers.utils import ContextManagers, find_labels, is_flax_available, is_tf_available, is_torch_available


if is_torch_available():
   from transformers import BertForPreTraining, BertForQuestionAnswering, BertForSequenceClassification

if is_tf_available():
   from transformers import TFBertForPreTraining, TFBertForQuestionAnswering, TFBertForSequenceClassification

if is_flax_available():
   from transformers import FlaxBertForPreTraining, FlaxBertForQuestionAnswering, FlaxBertForSequenceClassification


_UpperCAmelCase  =      DUMMY_UNKNOWN_IDENTIFIER
# An actual model hosted on huggingface.co

_UpperCAmelCase  =      """main"""
# Default branch name
_UpperCAmelCase  =      """f2c752cfc5c0ab6f4bdec59acea69eefbee381c2"""
# One particular commit (not the top of `main`)
_UpperCAmelCase  =      """aaaaaaa"""
# This commit does not exist, so we should 404.

_UpperCAmelCase  =      """d9e9f15bc825e4b2c9249e9578f884bbcb5e3684"""
# Sha-1 of config.json on the top of `main`, for checking purposes
_UpperCAmelCase  =      """4b243c475af8d0a7754e87d7d096c92e5199ec2fe168a2ee7998e3b8e9bcb1d3"""





@contextlib.contextmanager
def   __magic_name__					(				):
   print("""Welcome!"""			)
   yield
   print("""Bye!"""			)





@contextlib.contextmanager
def   __magic_name__					(				):
   print("""Bonjour!"""			)
   yield
   print("""Au revoir!"""			)
class        a						(	unittest.TestCase							):



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


     '''simple docstring'''




     assert transformers.__spec__ is not None
     assert importlib.util.find_spec("""transformers"""		) is not None







class        a						(	unittest.TestCase							):



  @unittest.mock.patch("""sys.stdout"""							,		new_callable=io.StringIO		)
  def 						lowerCamelCase__							(    self			:       Union[str, Any]							,		lowerCAmelCase			:       Tuple		)  ->       Tuple:


     '''simple docstring'''




     with ContextManagers([]		):
        print("""Transformers are awesome!"""		)
     # The print statement adds a new line at the end of the output
     self.assertEqual(mock_stdout.getvalue()							,		"""Transformers are awesome!\n"""		)



  @unittest.mock.patch("""sys.stdout"""							,		new_callable=io.StringIO		)
  def 						lowerCamelCase__							(    self			:       List[Any]							,		lowerCAmelCase			:       Optional[int]		)  ->       str:


     '''simple docstring'''




     with ContextManagers([context_en()]		):
        print("""Transformers are awesome!"""		)
     # The output should be wrapped with an English welcome and goodbye
     self.assertEqual(mock_stdout.getvalue()							,		"""Welcome!\nTransformers are awesome!\nBye!\n"""		)



  @unittest.mock.patch("""sys.stdout"""							,		new_callable=io.StringIO		)
  def 						lowerCamelCase__							(    self			:       List[Any]							,		lowerCAmelCase			:       List[Any]		)  ->       str:


     '''simple docstring'''




     with ContextManagers([context_fr(), context_en()]		):
        print("""Transformers are awesome!"""		)
     # The output should be wrapped with an English and French welcome and goodbye
     self.assertEqual(mock_stdout.getvalue()							,		"""Bonjour!\nWelcome!\nTransformers are awesome!\nBye!\nAu revoir!\n"""		)



  @require_torch
  def 						lowerCamelCase__							(    self			:       Union[str, Any]		)  ->       List[str]:


     '''simple docstring'''




     self.assertEqual(find_labels(lowerCAmelCase		)							,		["""labels"""]		)
     self.assertEqual(find_labels(lowerCAmelCase		)							,		["""labels""", """next_sentence_label"""]		)
     self.assertEqual(find_labels(lowerCAmelCase		)							,		["""start_positions""", """end_positions"""]		)
     class        a						(	UpperCAmelCase__							):
       pass







     self.assertEqual(find_labels(lowerCAmelCase		)							,		["""labels"""]		)



  @require_tf
  def 						lowerCamelCase__							(    self			:       Union[str, Any]		)  ->       Union[str, Any]:


     '''simple docstring'''




     self.assertEqual(find_labels(lowerCAmelCase		)							,		["""labels"""]		)
     self.assertEqual(find_labels(lowerCAmelCase		)							,		["""labels""", """next_sentence_label"""]		)
     self.assertEqual(find_labels(lowerCAmelCase		)							,		["""start_positions""", """end_positions"""]		)
     class        a						(	UpperCAmelCase__							):
       pass







     self.assertEqual(find_labels(lowerCAmelCase		)							,		["""labels"""]		)





  @require_flax
  def 						lowerCamelCase__							(    self			:       List[Any]		)  ->       List[Any]:


     '''simple docstring'''




     self.assertEqual(find_labels(lowerCAmelCase		)							,		[]		)
     self.assertEqual(find_labels(lowerCAmelCase		)							,		[]		)
     self.assertEqual(find_labels(lowerCAmelCase		)							,		[]		)
     class        a						(	UpperCAmelCase__							):
       pass







     self.assertEqual(find_labels(lowerCAmelCase		)							,		[]		)







'''simple docstring'''


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 rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
      import PIL


_UpperCamelCase 							=  logging.get_logger(__name__)


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     __A	:       int      =							b.T
     __A	:       Optional[Any]      =							np.sum(np.square(SCREAMING_SNAKE_CASE							)       ,					axis=1							)
     __A	:       List[Any]      =							np.sum(np.square(SCREAMING_SNAKE_CASE							)       ,					axis=0							)
     __A	:       List[Any]      =							np.matmul(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)
     __A	:       str      =							aa[:, None] - 2 * ab + ba[None, :]
     return d


def 		_lowercase (SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							):




     '''simple docstring'''





     __A	:       Union[str, Any]      =							x.reshape(-1       ,					3							)
     __A	:       Any      =							squared_euclidean_distance(SCREAMING_SNAKE_CASE       ,					SCREAMING_SNAKE_CASE							)
     return np.argmin(SCREAMING_SNAKE_CASE       ,					axis=1							)







class 							__magic_name__	(       lowerCAmelCase ):

     """simple docstring"""






     lowerCamelCase__       						=				['pixel_values']


     def __init__(   self			,     lowerCamelCase = None			,     lowerCamelCase = True			,     lowerCamelCase = None			,     lowerCamelCase = PILImageResampling.BILINEAR			,     lowerCamelCase = True			,     lowerCamelCase = True			,     **lowerCamelCase			,     ):


          '''simple docstring'''





          super().__init__(**lowerCamelCase		)
          __A	:       Optional[int]      =							size if size is not None else {"height": 256, "width": 256}
          __A	:       int      =							get_size_dict(lowerCamelCase		)
          __A	:       str      =							np.array(lowerCamelCase		) if clusters is not None else None
          __A	:       List[Any]      =							do_resize
          __A	:       Dict      =							size
          __A	:       str      =							resample
          __A	:       Optional[Any]      =							do_normalize
          __A	:       Dict      =							do_color_quantize


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase			,     lowerCamelCase = PILImageResampling.BILINEAR			,     lowerCamelCase = None			,     **lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       Optional[Any]      =							get_size_dict(lowerCamelCase		)
          if "height" not in size or "width" not in size:
               raise ValueError(f"Size dictionary must contain both height and width keys. Got {size.keys()}"		)
          return resize(
              lowerCamelCase			,     size=(size["height"], size["width"])			,     resample=lowerCamelCase			,     data_format=lowerCamelCase			,     **lowerCamelCase		)


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase = None			,     ):


          '''simple docstring'''





          __A	:       List[str]      =							rescale(image=lowerCamelCase			,     scale=1 / 127.5			,     data_format=lowerCamelCase		)
          __A	:       List[Any]      =							image - 1
          return image


     def lowerCAmelCase__  (   self			,     lowerCamelCase			,     lowerCamelCase = None			,     lowerCamelCase = None			,     lowerCamelCase = None			,     lowerCamelCase = None			,     lowerCamelCase = None			,     lowerCamelCase = None			,     lowerCamelCase = None			,     lowerCamelCase = ChannelDimension.FIRST			,     **lowerCamelCase			,     ):


          '''simple docstring'''





          __A	:       List[Any]      =							do_resize if do_resize is not None else self.do_resize
          __A	:       int      =							size if size is not None else self.size
          __A	:       Tuple      =							get_size_dict(lowerCamelCase		)
          __A	:       Tuple      =							resample if resample is not None else self.resample
          __A	:       Union[str, Any]      =							do_normalize if do_normalize is not None else self.do_normalize
          __A	:       Tuple      =							do_color_quantize if do_color_quantize is not None else self.do_color_quantize
          __A	:       Any      =							clusters if clusters is not None else self.clusters
          __A	:       Dict      =							np.array(lowerCamelCase		)

          __A	:       Optional[int]      =							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 or resample is None:
               raise ValueError("Size and resample must be specified if do_resize is True."		)

          if do_color_quantize and clusters is None:
               raise ValueError("Clusters must be specified if do_color_quantize is True."		)

          # All transformations expect numpy arrays.
          __A	:       Optional[Any]      =							[to_numpy_array(lowerCamelCase		) for image in images]

          if do_resize:
               __A	:       Dict      =							[self.resize(image=lowerCamelCase			,     size=lowerCamelCase			,     resample=lowerCamelCase		) for image in images]

          if do_normalize:
               __A	:       List[Any]      =							[self.normalize(image=lowerCamelCase		) for image in images]

          if do_color_quantize:
               __A	:       Union[str, Any]      =							[to_channel_dimension_format(lowerCamelCase			,     ChannelDimension.LAST		) for image in images]
               # color quantize from (batch_size, height, width, 3) to (batch_size, height, width)
               __A	:       int      =							np.array(lowerCamelCase		)
               __A	:       Any      =							color_quantize(lowerCamelCase			,     lowerCamelCase		).reshape(images.shape[:-1]		)

               # flatten to (batch_size, height*width)
               __A	:       Tuple      =							images.shape[0]
               __A	:       List[Any]      =							images.reshape(lowerCamelCase			,     -1		)

               # We need to convert back to a list of images to keep consistent behaviour across processors.
               __A	:       Optional[int]      =							list(lowerCamelCase		)
          else:
               __A	:       Tuple      =							[to_channel_dimension_format(lowerCamelCase			,     lowerCamelCase		) for image in images]

          __A	:       Optional[int]      =							{"input_ids": images}
          return BatchFeature(data=lowerCamelCase			,     tensor_type=lowerCamelCase		)

