

import unittest

from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
					from PIL import Image
else:





					class     snake_case_			:


												"""simple docstring"""





												@staticmethod
												def        A__  ( *_A					,						**_A							):
																	pass





@is_pipeline_test
@require_torch
@require_vision
class     snake_case_			(				unittest.TestCase							):


							"""simple docstring"""





							__UpperCAmelCase       =MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING




							def        A__  ( self					,						_A					,						_A					,						_A							):
												__lowerCAmelCase					=							pipeline('visual-question-answering'					,						model='hf-internal-testing/tiny-vilt-random-vqa'							)
												__lowerCAmelCase					=							[
												    {
												        'image': Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							),
												        'question': 'How many cats are there?',
												    },
												    {
												        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
												        'question': 'How many cats are there?',
												    },
												]
												return vqa_pipeline, examples




							def        A__  ( self					,						_A					,						_A							):
												__lowerCAmelCase					=							vqa_pipeline(_A					,						top_k=1							)
												self.assertEqual(
												    _A					,						[
												        [{'score': ANY(_A							), 'answer': ANY(_A							)}],
												        [{'score': ANY(_A							), 'answer': ANY(_A							)}],
												    ]					,						)




							@require_torch
							def        A__  ( self							):
												__lowerCAmelCase					=							pipeline('visual-question-answering'					,						model='hf-internal-testing/tiny-vilt-random-vqa'							)
												__lowerCAmelCase					=							'./tests/fixtures/tests_samples/COCO/000000039769.png'
												__lowerCAmelCase					=							'How many cats are there?'

												__lowerCAmelCase					=							vqa_pipeline(image=_A					,						question='How many cats are there?'					,						top_k=2							)
												self.assertEqual(
												    _A					,						[{'score': ANY(_A							), 'answer': ANY(_A							)}, {'score': ANY(_A							), 'answer': ANY(_A							)}]							)

												__lowerCAmelCase					=							vqa_pipeline({'image': image, 'question': question}					,						top_k=2							)
												self.assertEqual(
												    _A					,						[{'score': ANY(_A							), 'answer': ANY(_A							)}, {'score': ANY(_A							), 'answer': ANY(_A							)}]							)




							@slow
							@require_torch
							def        A__  ( self							):
												__lowerCAmelCase					=							pipeline('visual-question-answering'					,						model='dandelin/vilt-b32-finetuned-vqa'							)
												__lowerCAmelCase					=							'./tests/fixtures/tests_samples/COCO/000000039769.png'
												__lowerCAmelCase					=							'How many cats are there?'

												__lowerCAmelCase					=							vqa_pipeline(image=_A					,						question=_A					,						top_k=2							)
												self.assertEqual(
												    nested_simplify(_A					,						decimals=4							)					,						[{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]							)

												__lowerCAmelCase					=							vqa_pipeline({'image': image, 'question': question}					,						top_k=2							)
												self.assertEqual(
												    nested_simplify(_A					,						decimals=4							)					,						[{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]							)

												__lowerCAmelCase					=							vqa_pipeline(
												    [{'image': image, 'question': question}, {'image': image, 'question': question}]					,						top_k=2							)
												self.assertEqual(
												    nested_simplify(_A					,						decimals=4							)					,						[[{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]] * 2					,						)




							@require_tf
							@unittest.skip('Visual question answering not implemented in TF'							)
							def        A__  ( self							):
												pass









import hashlib
import unittest

from transformers import MODEL_FOR_DEPTH_ESTIMATION_MAPPING, is_torch_available, is_vision_available
from transformers.pipelines import DepthEstimationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_timm,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image
else:





		class     snake_case_			:


									"""simple docstring"""





									@staticmethod
									def        A__  ( *_A					,						**_A							):
														pass


def        __lowercase    (  UpperCAmelCase__      ):

					"""simple docstring"""






					__lowerCAmelCase					=							hashlib.mda(image.tobytes()      )
					return m.hexdigest()





@is_pipeline_test
@require_vision
@require_timm
@require_torch
class     snake_case_			(				unittest.TestCase							):


							"""simple docstring"""





							__UpperCAmelCase       =MODEL_FOR_DEPTH_ESTIMATION_MAPPING




							def        A__  ( self					,						_A					,						_A					,						_A							):
												__lowerCAmelCase					=							DepthEstimationPipeline(model=_A					,						image_processor=_A							)
												return depth_estimator, [
												    "./tests/fixtures/tests_samples/COCO/000000039769.png",
												    "./tests/fixtures/tests_samples/COCO/000000039769.png",
												]




							def        A__  ( self					,						_A					,						_A							):
												__lowerCAmelCase					=							depth_estimator('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
												self.assertEqual({'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)}					,						_A							)
												import datasets

												__lowerCAmelCase					=							datasets.load_dataset('hf-internal-testing/fixtures_image_utils'					,						'image'					,						split='test'							)
												__lowerCAmelCase					=							depth_estimator(
												    [
												        Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							),
												        'http://images.cocodataset.org/val2017/000000039769.jpg',
												        # RGBA
												        dataset[0]['file'],
												        # LA
												        dataset[1]['file'],
												        # L
												        dataset[2]['file'],
												    ]							)
												self.assertEqual(
												    [
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												        {'predicted_depth': ANY(torch.Tensor							), 'depth': ANY(Image.Image							)},
												    ]					,						_A					,						)




							@require_tf
							@unittest.skip('Depth estimation is not implemented in TF'							)
							def        A__  ( self							):
												pass




							@slow
							@require_torch
							def        A__  ( self							):
												__lowerCAmelCase					=							'Intel/dpt-large'
												__lowerCAmelCase					=							pipeline('depth-estimation'					,						model=_A							)
												__lowerCAmelCase					=							depth_estimator('http://images.cocodataset.org/val2017/000000039769.jpg'							)
												__lowerCAmelCase					=							hashimage(outputs['depth']							)

												# This seems flaky.
												# self.assertEqual(outputs["depth"], "1a39394e282e9f3b0741a90b9f108977")
												self.assertEqual(nested_simplify(outputs['predicted_depth'].max().item()							)					,						29.304							)
												self.assertEqual(nested_simplify(outputs['predicted_depth'].min().item()							)					,						2.662							)




							@require_torch
							def        A__  ( self							):
												# This is highly irregular to have no small tests.
												self.skipTest('There is not hf-internal-testing tiny model for either GLPN nor DPT'							)






