'''simple docstring'''

import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


lowerCAmelCase_			:			Union[str, Any]    	=   "\nHugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.\n\nIn March 2021, Hugging Face raised $40 million in a Series B funding round.[3]\n\nOn April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]\n"





class 				lowercase    (    unittest.TestCase			,					__lowerCamelCase			):


   def __UpperCAmelCase							( self					:						Optional[int])   ->       int:
         lowercase_     			=   load_tool("summarization")
         self.tool.setup()
         lowercase_     			=   load_tool("summarization" ,		remote=__lowerCAmelCase)


   def __UpperCAmelCase							( self					:						Any)   ->       Tuple:
         lowercase_     			=   self.tool(__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase ,		"Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM." ,		)


   def __UpperCAmelCase							( self					:						List[str])   ->       Tuple:
         lowercase_     			=   self.remote_tool(__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase ,		"Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM." ,		)


   def __UpperCAmelCase							( self					:						List[str])   ->       Optional[Any]:
         lowercase_     			=   self.tool(text=__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase ,		"Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM." ,		)


   def __UpperCAmelCase							( self					:						str)   ->       str:
         lowercase_     			=   self.remote_tool(text=__lowerCAmelCase)
         self.assertEqual(
             __lowerCAmelCase ,		"Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM." ,		)







'''simple docstring'''

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 ConvNextImageProcessor





class 				lowercase    (    unittest.TestCase			):


   def __init__( self					:						str ,		__lowerCAmelCase					:						Union[str, Any] ,		__lowerCAmelCase					:						Optional[int]=7 ,		__lowerCAmelCase					:						Optional[Any]=3 ,		__lowerCAmelCase					:						Optional[Any]=18 ,		__lowerCAmelCase					:						List[str]=30 ,		__lowerCAmelCase					:						List[str]=400 ,		__lowerCAmelCase					:						Tuple=True ,		__lowerCAmelCase					:						Optional[int]=None ,		__lowerCAmelCase					:						List[str]=0.875 ,		__lowerCAmelCase					:						int=True ,		__lowerCAmelCase					:						Optional[int]=[0.5, 0.5, 0.5] ,		__lowerCAmelCase					:						List[str]=[0.5, 0.5, 0.5] ,		)   ->       Optional[Any]:
         lowercase_     			=   size if size is not None else {"shortest_edge": 20}
         lowercase_     			=   parent
         lowercase_     			=   batch_size
         lowercase_     			=   num_channels
         lowercase_     			=   image_size
         lowercase_     			=   min_resolution
         lowercase_     			=   max_resolution
         lowercase_     			=   do_resize
         lowercase_     			=   size
         lowercase_     			=   crop_pct
         lowercase_     			=   do_normalize
         lowercase_     			=   image_mean
         lowercase_     			=   image_std


   def __UpperCAmelCase							( self					:						List[str])   ->       int:
         return {
             "image_mean": self.image_mean,
             "image_std": self.image_std,
             "do_normalize": self.do_normalize,
             "do_resize": self.do_resize,
             "size": self.size,
             "crop_pct": self.crop_pct,
         }





@require_torch
@require_vision
class 				lowercase    (    __lowerCamelCase			,					unittest.TestCase			):
   lowerCamelCase_            =ConvNextImageProcessor if is_vision_available() else None


   def __UpperCAmelCase							( self					:						Optional[Any])   ->       Tuple:
         lowercase_     			=   ConvNextImageProcessingTester(self)


   @property
   def __UpperCAmelCase							( self					:						Optional[int])   ->       int:
         return self.image_processor_tester.prepare_image_processor_dict()


   def __UpperCAmelCase							( self					:						Optional[int])   ->       Any:
         lowercase_     			=   self.image_processing_class(**self.image_processor_dict)
         self.assertTrue(hasattr(__lowerCAmelCase ,		"do_resize"))
         self.assertTrue(hasattr(__lowerCAmelCase ,		"size"))
         self.assertTrue(hasattr(__lowerCAmelCase ,		"crop_pct"))
         self.assertTrue(hasattr(__lowerCAmelCase ,		"do_normalize"))
         self.assertTrue(hasattr(__lowerCAmelCase ,		"image_mean"))
         self.assertTrue(hasattr(__lowerCAmelCase ,		"image_std"))


   def __UpperCAmelCase							( self					:						List[str])   ->       Any:
         lowercase_     			=   self.image_processing_class.from_dict(self.image_processor_dict)
         self.assertEqual(image_processor.size ,		{"shortest_edge": 20})

         lowercase_     			=   self.image_processing_class.from_dict(self.image_processor_dict ,		size=42)
         self.assertEqual(image_processor.size ,		{"shortest_edge": 42})


   def __UpperCAmelCase							( self					:						Any)   ->       Optional[int]:
         pass


   def __UpperCAmelCase							( self					:						List[Any])   ->       Any:
         # Initialize image_processing
         lowercase_     			=   self.image_processing_class(**self.image_processor_dict)
         # create random PIL images
         lowercase_     			=   prepare_image_inputs(self.image_processor_tester ,		equal_resolution=__lowerCAmelCase)
         for image in image_inputs:
               self.assertIsInstance(__lowerCAmelCase ,		Image.Image)

         # Test not batched input
         lowercase_     			=   image_processing(image_inputs[0] ,		return_tensors="pt").pixel_values
         self.assertEqual(
             encoded_images.shape ,		(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["shortest_edge"],
                 self.image_processor_tester.size["shortest_edge"],
             ) ,		)

         # Test batched
         lowercase_     			=   image_processing(__lowerCAmelCase ,		return_tensors="pt").pixel_values
         self.assertEqual(
             encoded_images.shape ,		(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["shortest_edge"],
                 self.image_processor_tester.size["shortest_edge"],
             ) ,		)


   def __UpperCAmelCase							( self					:						Union[str, Any])   ->       str:
         # Initialize image_processing
         lowercase_     			=   self.image_processing_class(**self.image_processor_dict)
         # create random numpy tensors
         lowercase_     			=   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
         lowercase_     			=   image_processing(image_inputs[0] ,		return_tensors="pt").pixel_values
         self.assertEqual(
             encoded_images.shape ,		(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["shortest_edge"],
                 self.image_processor_tester.size["shortest_edge"],
             ) ,		)

         # Test batched
         lowercase_     			=   image_processing(__lowerCAmelCase ,		return_tensors="pt").pixel_values
         self.assertEqual(
             encoded_images.shape ,		(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["shortest_edge"],
                 self.image_processor_tester.size["shortest_edge"],
             ) ,		)


   def __UpperCAmelCase							( self					:						List[str])   ->       List[str]:
         # Initialize image_processing
         lowercase_     			=   self.image_processing_class(**self.image_processor_dict)
         # create random PyTorch tensors
         lowercase_     			=   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
         lowercase_     			=   image_processing(image_inputs[0] ,		return_tensors="pt").pixel_values
         self.assertEqual(
             encoded_images.shape ,		(
                 1,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["shortest_edge"],
                 self.image_processor_tester.size["shortest_edge"],
             ) ,		)

         # Test batched
         lowercase_     			=   image_processing(__lowerCAmelCase ,		return_tensors="pt").pixel_values
         self.assertEqual(
             encoded_images.shape ,		(
                 self.image_processor_tester.batch_size,
                 self.image_processor_tester.num_channels,
                 self.image_processor_tester.size["shortest_edge"],
                 self.image_processor_tester.size["shortest_edge"],
             ) ,		)






