

'''simple docstring'''





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 				__lowerCAmelCase  :




    @staticmethod
    def 						A__  (       *lowerCAmelCase							,     **lowerCAmelCase      )						->				List[str]:
          '''simple docstring'''






          pass
def   a   (    A__			:     Image  )					->   str:





      """simple docstring"""



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







@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 				__lowerCAmelCase  (      unittest.TestCase							):
  _a		    =						MODEL_FOR_DEPTH_ESTIMATION_MAPPING




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )						->				Union[str, Any]:
        '''simple docstring'''






        _lowercase			 =DepthEstimationPipeline(model=lowerCAmelCase							,     image_processor=lowerCAmelCase      )
        return depth_estimator, [
            "./tests/fixtures/tests_samples/COCO/000000039769.png",
            "./tests/fixtures/tests_samples/COCO/000000039769.png",
        ]




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase      )						->				str:
        '''simple docstring'''






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

        _lowercase			 =datasets.load_dataset('hf-internal-testing/fixtures_image_utils'							,     'image'							,     split='test'      )
        _lowercase			 =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      )},
            ]							,     lowerCAmelCase							,     )




  @require_tf
  @unittest.skip('Depth estimation is not implemented in TF'      )
  def 						A__  (       self      )						->				Tuple:
        '''simple docstring'''






        pass




  @slow
  @require_torch
  def 						A__  (       self      )						->				Dict:
        '''simple docstring'''






        _lowercase			 ='Intel/dpt-large'
        _lowercase			 =pipeline('depth-estimation'							,     model=lowerCAmelCase      )
        _lowercase			 =depth_estimator('http://images.cocodataset.org/val2017/000000039769.jpg'      )
        _lowercase			 =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      )						->				Optional[Any]:
        '''simple docstring'''






        self.skipTest('There is not hf-internal-testing tiny model for either GLPN nor DPT'      )





import os
def   a   (    )					->   Optional[int]:





      """simple docstring"""



      with open(os.path.dirname(A__  ) + '/grid.txt'  ) as f:
            _lowercase			 =[]  # noqa: E741
            for _ in range(20  ):
                  l.append([int(A__  ) for x in f.readline().split()]  )

            _lowercase			 =0

            # right
            for i in range(20  ):
                  for j in range(17  ):
                        _lowercase			 =l[i][j] * l[i][j + 1] * l[i][j + 2] * l[i][j + 3]
                        if temp > maximum:
                              _lowercase			 =temp

        # down
            for i in range(17  ):
                  for j in range(20  ):
                        _lowercase			 =l[i][j] * l[i + 1][j] * l[i + 2][j] * l[i + 3][j]
                        if temp > maximum:
                              _lowercase			 =temp

        # diagonal 1
            for i in range(17  ):
                  for j in range(17  ):
                        _lowercase			 =l[i][j] * l[i + 1][j + 1] * l[i + 2][j + 2] * l[i + 3][j + 3]
                        if temp > maximum:
                              _lowercase			 =temp

        # diagonal 2
            for i in range(17  ):
                  for j in range(3   ,     20  ):
                        _lowercase			 =l[i][j] * l[i + 1][j - 1] * l[i + 2][j - 2] * l[i + 3][j - 3]
                        if temp > maximum:
                              _lowercase			 =temp
            return maximum


if __name__ == "__main__":
  print(solution())


