"""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


if is_torch_available():
 import torch

if is_vision_available():
 from PIL import Image

 from transformers import BlipImageProcessor




class   __snake_case			(	unittest.TestCase							):



      def __init__(		self       ,     lowercase       ,     lowercase=7       ,     lowercase=3       ,     lowercase=18       ,     lowercase=30       ,     lowercase=4_00       ,     lowercase=True       ,     lowercase=None       ,     lowercase=True       ,     lowercase=False       ,     lowercase=[0.48145466, 0.4578275, 0.40821073]       ,     lowercase=[0.26862954, 0.26130258, 0.27577711]       ,     lowercase=True       ,     )      ->     Optional[int]:





        '''simple docstring'''





        a__:	Dict     				=      size if size is not None else {'height': 20, 'width': 20}
        a__:	Dict     				=      parent
        a__:	Union[str, Any]     				=      batch_size
        a__:	Dict     				=      num_channels
        a__:	List[Any]     				=      image_size
        a__:	Optional[int]     				=      min_resolution
        a__:	List[str]     				=      max_resolution
        a__:	Optional[Any]     				=      do_resize
        a__:	Optional[Any]     				=      size
        a__:	Any     				=      do_normalize
        a__:	Union[str, Any]     				=      image_mean
        a__:	Dict     				=      image_std
        a__:	int     				=      do_pad
        a__:	int     				=      do_convert_rgb



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





        '''simple docstring'''





        return {
            "do_resize": self.do_resize,
            "size": self.size,
            "do_normalize": self.do_normalize,
            "image_mean": self.image_mean,
            "image_std": self.image_std,
            "do_convert_rgb": self.do_convert_rgb,
            "do_pad": self.do_pad,
        }



      def     lowerCamelCase_  (		self       ,     lowercase=False       ,     lowercase=False       ,     lowercase=False)      ->     str:





        '''simple docstring'''





        assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

        if equal_resolution:
          a__:	List[str]     				=      []
          for i in range(self.batch_size):
            image_inputs.append(
                np.random.randint(
                    2_55       ,     size=(self.num_channels, self.max_resolution, self.max_resolution)       ,     dtype=np.uinta))
        else:
          a__:	List[str]     				=      []
          for i in range(self.batch_size):
            a__				,       a__:	Tuple     				=      np.random.choice(np.arange(self.min_resolution       ,     self.max_resolution)       ,     2)
            image_inputs.append(np.random.randint(2_55       ,     size=(self.num_channels, width, height)       ,     dtype=np.uinta))

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

        if torchify:
          a__:	int     				=      [torch.from_numpy(lowercase) for x in image_inputs]

        return image_inputs







@require_torch
@require_vision
class   __snake_case			(	__lowerCAmelCase			, unittest.TestCase							):
      a__								=						BlipImageProcessor if is_vision_available() else None



      def     lowerCamelCase_  (		self)      ->     List[str]:





        '''simple docstring'''





        a__:	int     				=      BlipImageProcessingTester(self)



      @property
      def     lowerCamelCase_  (		self)      ->     Optional[Any]:





        '''simple docstring'''





        return self.image_processor_tester.prepare_image_processor_dict()



      def     lowerCamelCase_  (		self)      ->     Any:





        '''simple docstring'''





        a__:	Optional[int]     				=      self.image_processing_class(**self.image_processor_dict)
        self.assertTrue(hasattr(lowercase       ,     'do_resize'))
        self.assertTrue(hasattr(lowercase       ,     'size'))
        self.assertTrue(hasattr(lowercase       ,     'do_normalize'))
        self.assertTrue(hasattr(lowercase       ,     'image_mean'))
        self.assertTrue(hasattr(lowercase       ,     'image_std'))
        self.assertTrue(hasattr(lowercase       ,     'do_convert_rgb'))



      def     lowerCamelCase_  (		self)      ->     List[str]:





        '''simple docstring'''





        pass



      def     lowerCamelCase_  (		self)      ->     Optional[int]:





        '''simple docstring'''





        a__:	Dict     				=      self.image_processing_class(**self.image_processor_dict)
        # create random PIL images
        a__:	Any     				=      self.image_processor_tester.prepare_inputs(equal_resolution=lowercase)
        for image in image_inputs:
          self.assertIsInstance(lowercase       ,     Image.Image)

        # Test not batched input
        a__:	Tuple     				=      image_processor(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['height'],
                self.image_processor_tester.size['width'],
            )       ,     )

        # Test batched
        a__:	Tuple     				=      image_processor(lowercase       ,     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['height'],
                self.image_processor_tester.size['width'],
            )       ,     )



      def     lowerCamelCase_  (		self)      ->     str:





        '''simple docstring'''





        a__:	int     				=      self.image_processing_class(**self.image_processor_dict)
        # create random numpy tensors
        a__:	Optional[Any]     				=      self.image_processor_tester.prepare_inputs(equal_resolution=lowercase       ,     numpify=lowercase)
        for image in image_inputs:
          self.assertIsInstance(lowercase       ,     np.ndarray)

        # Test not batched input
        a__:	Dict     				=      image_processor(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['height'],
                self.image_processor_tester.size['width'],
            )       ,     )

        # Test batched
        a__:	int     				=      image_processor(lowercase       ,     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['height'],
                self.image_processor_tester.size['width'],
            )       ,     )



      def     lowerCamelCase_  (		self)      ->     str:





        '''simple docstring'''





        a__:	int     				=      self.image_processing_class(**self.image_processor_dict)
        # create random PyTorch tensors
        a__:	List[str]     				=      self.image_processor_tester.prepare_inputs(equal_resolution=lowercase       ,     torchify=lowercase)
        for image in image_inputs:
          self.assertIsInstance(lowercase       ,     torch.Tensor)

        # Test not batched input
        a__:	Optional[Any]     				=      image_processor(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['height'],
                self.image_processor_tester.size['width'],
            )       ,     )

        # Test batched
        a__:	Tuple     				=      image_processor(lowercase       ,     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['height'],
                self.image_processor_tester.size['width'],
            )       ,     )







@require_torch
@require_vision
class   __snake_case			(	__lowerCAmelCase			, unittest.TestCase							):
      a__								=						BlipImageProcessor if is_vision_available() else None



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





        '''simple docstring'''





        a__:	Optional[Any]     				=      BlipImageProcessingTester(self       ,     num_channels=4)
        a__:	Union[str, Any]     				=      3



      @property
      def     lowerCamelCase_  (		self)      ->     Dict:





        '''simple docstring'''





        return self.image_processor_tester.prepare_image_processor_dict()



      def     lowerCamelCase_  (		self)      ->     Dict:





        '''simple docstring'''





        a__:	Dict     				=      self.image_processing_class(**self.image_processor_dict)
        self.assertTrue(hasattr(lowercase       ,     'do_resize'))
        self.assertTrue(hasattr(lowercase       ,     'size'))
        self.assertTrue(hasattr(lowercase       ,     'do_normalize'))
        self.assertTrue(hasattr(lowercase       ,     'image_mean'))
        self.assertTrue(hasattr(lowercase       ,     'image_std'))
        self.assertTrue(hasattr(lowercase       ,     'do_convert_rgb'))



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





        '''simple docstring'''





        pass



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





        '''simple docstring'''





        a__:	Optional[int]     				=      self.image_processing_class(**self.image_processor_dict)
        # create random PIL images
        a__:	Dict     				=      self.image_processor_tester.prepare_inputs(equal_resolution=lowercase)
        for image in image_inputs:
          self.assertIsInstance(lowercase       ,     Image.Image)

        # Test not batched input
        a__:	Union[str, Any]     				=      image_processor(image_inputs[0]       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                1,
                self.expected_encoded_image_num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )

        # Test batched
        a__:	Dict     				=      image_processor(lowercase       ,     return_tensors='pt').pixel_values
        self.assertEqual(
            encoded_images.shape       ,     (
                self.image_processor_tester.batch_size,
                self.expected_encoded_image_num_channels,
                self.image_processor_tester.size['height'],
                self.image_processor_tester.size['width'],
            )       ,     )



import re
import tempfile
import unittest
from pathlib import Path

from datasets.utils.metadata import DatasetMetadata







def 						UpperCAmelCase							(		lowerCAmelCase_							)						->						str:
     a	:     Optional[Any]						      =    min(re.search('''^ +'''    ,   lowerCAmelCase_							).end() if t.startswith(''' '''							) else 0 for t in string.splitlines()							)
     return "\n".join([line[indent_level:] for line in string.splitlines() if indent_level < len(lowerCAmelCase_							)]							)


UpperCAmelCase				 =   """\
---
language:
- zh
- en
task_ids:
- sentiment-classification
---
# Begin of markdown

Some cool dataset card
"""

UpperCAmelCase				 =   """\
---
---
# Begin of markdown

Some cool dataset card
"""


UpperCAmelCase				 =   """\
# Begin of markdown

Some cool dataset card
"""






class 				_SCREAMING_SNAKE_CASE( unittest.TestCase						):
   def _lowercase(     self     )						->List[str]:
        with tempfile.TemporaryDirectory() as tmp_dir:
             a	:     List[str]						      =    Path(lowerCAmelCase_     ) / '''README.md'''
             with open(lowerCAmelCase_				,  '''w+'''     ) as readme_file:
                  readme_file.write(lowerCAmelCase_     )
             a	:     Dict						      =    DatasetMetadata.from_readme(lowerCAmelCase_     )
             self.assertDictEqual(lowerCAmelCase_				,  {'''language''': ['''zh''', '''en'''], '''task_ids''': ['''sentiment-classification''']}     )

             with open(lowerCAmelCase_				,  '''w+'''     ) as readme_file:
                  readme_file.write(lowerCAmelCase_     )
             a	:     List[str]						      =    DatasetMetadata.from_readme(lowerCAmelCase_     )
             self.assertDictEqual(lowerCAmelCase_				,  {}     )

             with open(lowerCAmelCase_				,  '''w+'''     ) as readme_file:
                  readme_file.write(lowerCAmelCase_     )
             a	:     List[Any]						      =    DatasetMetadata.from_readme(lowerCAmelCase_     )
             self.assertEqual(lowerCAmelCase_				,  {}     )


   def _lowercase(     self     )						->Optional[Any]:
        a	:     Tuple						      =    _dedent(
            '''\
            annotations_creators:
            - found
            language_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - question-answering
            task_ids:
            - open-domain-qa
            '''     )
        assert DatasetMetadata.from_yaml_string(lowerCAmelCase_     )

        a	:     Dict						      =    _dedent(
            '''\
            annotations_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - question-answering
            task_ids:
            - open-domain-qa
            task_ids:
            - open-domain-qa
            '''     )
        with self.assertRaises(lowerCAmelCase_     ):
             DatasetMetadata.from_yaml_string(lowerCAmelCase_     )

        a	:     Optional[int]						      =    _dedent(
            '''\
            annotations_creators:
            - found
            language_creators:
            - found
            language:
            - en
            license:
            - unknown
            multilinguality:
            - monolingual
            pretty_name: Test Dataset
            size_categories:
            - 10K<n<100K
            source_datasets:
            - extended|other-yahoo-webscope-l6
            task_categories:
            - text-classification
            task_ids:
            - multi-class-classification
            paperswithcode_id:
            - squad
            configs:
            - en
            train-eval-index:
            - config: en
              task: text-classification
              task_id: multi_class_classification
              splits:
                train_split: train
                eval_split: test
              col_mapping:
                text: text
                label: target
              metrics:
                - type: accuracy
                  name: Accuracy
            extra_gated_prompt: |
              By clicking on “Access repository” below, you also agree to ImageNet Terms of Access:
              [RESEARCHER_FULLNAME] (the "Researcher") has requested permission to use the ImageNet database (the "Database") at Princeton University and Stanford University. In exchange for such permission, Researcher hereby agrees to the following terms and conditions:
              1. Researcher shall use the Database only for non-commercial research and educational purposes.
            extra_gated_fields:
              Company: text
              Country: text
              I agree to use this model for non-commerical use ONLY: checkbox
            '''     )
        assert DatasetMetadata.from_yaml_string(lowerCAmelCase_     )