




'''simple docstring'''


import unittest

import numpy as np
import requests

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

				from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
				_snake_case				:				Any       							=		False

if is_vision_available():
				from PIL import Image

				from transformers import PixaStructImageProcessor

class       A   (		unittest.TestCase   ):







							def __init__(  self	:  Dict							,      lowerCAmelCase_	:  List[str]							,      lowerCAmelCase_	:  Dict=7							,      lowerCAmelCase_	:  Union[str, Any]=3							,      lowerCAmelCase_	:  List[str]=18							,      lowerCAmelCase_	:  Any=30							,      lowerCAmelCase_	:  Tuple=4_00							,      lowerCAmelCase_	:  int=None							,      lowerCAmelCase_	:  Tuple=True							,      lowerCAmelCase_	:  int=True							,      lowerCAmelCase_	:  List[str]=None							,      )      ->							Dict:


														"""simple docstring"""


														_a     					=    size if size is not None else {'''height''': 20, '''width''': 20}
														_a     					=    parent
														_a     					=    batch_size
														_a     					=    num_channels
														_a     					=    image_size
														_a     					=    min_resolution
														_a     					=    max_resolution
														_a     					=    size
														_a     					=    do_normalize
														_a     					=    do_convert_rgb
														_a     					=    [5_12, 10_24, 20_48, 40_96]
														_a     					=    patch_size if patch_size is not None else {'''height''': 16, '''width''': 16}







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


														"""simple docstring"""


														return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb}







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Tuple:


														"""simple docstring"""


														_a     					=    '''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg'''
														_a     					=    Image.open(requests.get(lowerCAmelCase_							,      stream=lowerCAmelCase_ ).raw ).convert('''RGB''' )
														return raw_image



@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11					,reason='`Pix2StructImageProcessor` requires `torch>=1.11.0`.'					,)
@require_torch
@require_vision
class       A   (		_a					,unittest.TestCase   ):
							lowercase_          =    PixaStructImageProcessor if is_vision_available() else None







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


														"""simple docstring"""


														_a     					=    PixaStructImageProcessingTester(self )







							@property
							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							int:


														"""simple docstring"""


														return self.image_processor_tester.prepare_image_processor_dict()







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    self.image_processing_class(**self.image_processor_dict )
														self.assertTrue(hasattr(lowerCAmelCase_							,      '''do_normalize''' ) )
														self.assertTrue(hasattr(lowerCAmelCase_							,      '''do_convert_rgb''' ) )







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


														"""simple docstring"""


														_a     					=    self.image_processor_tester.prepare_dummy_image()

														_a     					=    self.image_processing_class(**self.image_processor_dict )
														_a     					=    20_48

														_a     					=    image_processor(lowerCAmelCase_							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ )
														self.assertTrue(torch.allclose(inputs.flattened_patches.mean()							,      torch.tensor(0.0_6_0_6 )							,      atol=1e-3							,      rtol=1e-3 ) )







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							Tuple:


														"""simple docstring"""


														_a     					=    self.image_processing_class(**self.image_processor_dict )
														# create random PIL images
														_a     					=    prepare_image_inputs(self.image_processor_tester							,      equal_resolution=lowerCAmelCase_ )
														for image in image_inputs:
																					self.assertIsInstance(lowerCAmelCase_							,      Image.Image )

														# Test not batched input
														_a     					=    (
														    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
														    * self.image_processor_tester.num_channels
														) + 2

														for max_patch in self.image_processor_tester.max_patches:
																					# Test not batched input
																					_a     					=    image_processor(
																					    image_inputs[0]							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (1, max_patch, expected_hidden_dim)							,      )

																					# Test batched
																					_a     					=    image_processor(
																					    lowerCAmelCase_							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)							,      )







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    self.image_processing_class(**self.image_processor_dict )
														# create random PIL images
														_a     					=    prepare_image_inputs(self.image_processor_tester							,      equal_resolution=lowerCAmelCase_ )
														for image in image_inputs:
																					self.assertIsInstance(lowerCAmelCase_							,      Image.Image )

														# Test not batched input
														_a     					=    (
														    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
														    * self.image_processor_tester.num_channels
														) + 2

														_a     					=    True

														for max_patch in self.image_processor_tester.max_patches:
																					# Test not batched input
																					with self.assertRaises(lowerCAmelCase_ ):
																												_a     					=    image_processor(
																												    image_inputs[0]							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches

																					_a     					=    '''Hello'''

																					_a     					=    image_processor(
																					    image_inputs[0]							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_							,      header_text=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (1, max_patch, expected_hidden_dim)							,      )

																					# Test batched
																					_a     					=    image_processor(
																					    lowerCAmelCase_							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_							,      header_text=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)							,      )







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


														"""simple docstring"""


														_a     					=    self.image_processing_class(**self.image_processor_dict )
														# create random numpy tensors
														_a     					=    prepare_image_inputs(self.image_processor_tester							,      equal_resolution=lowerCAmelCase_							,      numpify=lowerCAmelCase_ )
														for image in image_inputs:
																					self.assertIsInstance(lowerCAmelCase_							,      np.ndarray )

														_a     					=    (
														    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
														    * self.image_processor_tester.num_channels
														) + 2

														for max_patch in self.image_processor_tester.max_patches:
																					# Test not batched input
																					_a     					=    image_processor(
																					    image_inputs[0]							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (1, max_patch, expected_hidden_dim)							,      )

																					# Test batched
																					_a     					=    image_processor(
																					    lowerCAmelCase_							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)							,      )







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


														"""simple docstring"""


														_a     					=    self.image_processing_class(**self.image_processor_dict )
														# create random PyTorch tensors
														_a     					=    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
														_a     					=    (
														    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
														    * self.image_processor_tester.num_channels
														) + 2

														for max_patch in self.image_processor_tester.max_patches:
																					# Test not batched input
																					_a     					=    image_processor(
																					    image_inputs[0]							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (1, max_patch, expected_hidden_dim)							,      )

																					# Test batched
																					_a     					=    image_processor(
																					    lowerCAmelCase_							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)							,      )



@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11					,reason='`Pix2StructImageProcessor` requires `torch>=1.11.0`.'					,)
@require_torch
@require_vision
class       A   (		_a					,unittest.TestCase   ):
							lowercase_          =    PixaStructImageProcessor if is_vision_available() else None







							def        __lowerCAmelCase      (  self	:  List[Any] )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    PixaStructImageProcessingTester(self							,      num_channels=4 )
														_a     					=    3







							@property
							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Optional[Any]:


														"""simple docstring"""


														return self.image_processor_tester.prepare_image_processor_dict()







							def        __lowerCAmelCase      (  self	:  List[Any] )      ->							int:


														"""simple docstring"""


														_a     					=    self.image_processing_class(**self.image_processor_dict )
														self.assertTrue(hasattr(lowerCAmelCase_							,      '''do_normalize''' ) )
														self.assertTrue(hasattr(lowerCAmelCase_							,      '''do_convert_rgb''' ) )







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


														"""simple docstring"""


														_a     					=    self.image_processing_class(**self.image_processor_dict )
														# create random PIL images
														_a     					=    prepare_image_inputs(self.image_processor_tester							,      equal_resolution=lowerCAmelCase_ )
														for image in image_inputs:
																					self.assertIsInstance(lowerCAmelCase_							,      Image.Image )

														# Test not batched input
														_a     					=    (
														    (self.image_processor_tester.patch_size['''height'''] * self.image_processor_tester.patch_size['''width'''])
														    * (self.image_processor_tester.num_channels - 1)
														) + 2

														for max_patch in self.image_processor_tester.max_patches:
																					# Test not batched input
																					_a     					=    image_processor(
																					    image_inputs[0]							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (1, max_patch, expected_hidden_dim)							,      )

																					# Test batched
																					_a     					=    image_processor(
																					    lowerCAmelCase_							,      return_tensors='''pt'''							,      max_patches=lowerCAmelCase_ ).flattened_patches
																					self.assertEqual(
																					    encoded_images.shape							,      (self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)							,      )







'''simple docstring'''


import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


_snake_case				:				int       							=		get_tests_dir('fixtures')
_snake_case				:				Tuple       							=		get_tests_dir('fixtures/dummy_feature_extractor_config.json')
_snake_case				:				Optional[int]       							=		get_tests_dir('fixtures/dummy-config.json')

class       A   (		unittest.TestCase   ):







							def        __lowerCAmelCase      (  self	:  int )      ->							List[Any]:


														"""simple docstring"""


														_a     					=    0







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							int:


														"""simple docstring"""


														_a     					=    AutoFeatureExtractor.from_pretrained('''facebook/wav2vec2-base-960h''' )
														self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  str )      ->							Tuple:


														"""simple docstring"""


														_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ )
														self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							Any:


														"""simple docstring"""


														with tempfile.TemporaryDirectory() as tmpdirname:
																					_a     					=    WavaVecaConfig()

																					# remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
																					_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ ).to_dict()

																					config_dict.pop('''feature_extractor_type''' )
																					_a     					=    WavaVecaFeatureExtractor(**lowerCAmelCase_ )

																					# save in new folder
																					model_config.save_pretrained(lowerCAmelCase_ )
																					config.save_pretrained(lowerCAmelCase_ )

																					_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ )

																					# make sure private variable is not incorrectly saved
																					_a     					=    json.loads(config.to_json_string() )
																					self.assertTrue('''_processor_class''' not in dict_as_saved )

														self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )







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


														"""simple docstring"""


														_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ )
														self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							str:


														"""simple docstring"""


														with self.assertRaisesRegex(
														    lowerCAmelCase_							,      '''bert-base is not a local folder and is not a valid model identifier''' ):
																					_a     					=    AutoFeatureExtractor.from_pretrained('''bert-base''' )







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


														"""simple docstring"""


														with self.assertRaisesRegex(
														    lowerCAmelCase_							,      R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)''' ):
																					_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_							,      revision='''aaaaaa''' )







							def        __lowerCAmelCase      (  self	:  Any )      ->							Dict:


														"""simple docstring"""


														with self.assertRaisesRegex(
														    lowerCAmelCase_							,      '''hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'''							,      ):
																					_a     					=    AutoFeatureExtractor.from_pretrained('''hf-internal-testing/config-no-model''' )







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


														"""simple docstring"""


														with self.assertRaises(lowerCAmelCase_ ):
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor''' )
														# If remote code is disabled, we can't load this config.
														with self.assertRaises(lowerCAmelCase_ ):
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor'''							,      trust_remote_code=lowerCAmelCase_ )

														_a     					=    AutoFeatureExtractor.from_pretrained(
														    '''hf-internal-testing/test_dynamic_feature_extractor'''							,      trust_remote_code=lowerCAmelCase_ )
														self.assertEqual(feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )

														# Test feature extractor can be reloaded.
														with tempfile.TemporaryDirectory() as tmp_dir:
																					feature_extractor.save_pretrained(lowerCAmelCase_ )
																					_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_							,      trust_remote_code=lowerCAmelCase_ )
														self.assertEqual(reloaded_feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )







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


														"""simple docstring"""


														try:
																					AutoConfig.register('''custom'''							,      lowerCAmelCase_ )
																					AutoFeatureExtractor.register(lowerCAmelCase_							,      lowerCAmelCase_ )
																					# Trying to register something existing in the Transformers library will raise an error
																					with self.assertRaises(lowerCAmelCase_ ):
																												AutoFeatureExtractor.register(lowerCAmelCase_							,      lowerCAmelCase_ )

																					# Now that the config is registered, it can be used as any other config with the auto-API
																					_a     					=    CustomFeatureExtractor.from_pretrained(lowerCAmelCase_ )
																					with tempfile.TemporaryDirectory() as tmp_dir:
																												feature_extractor.save_pretrained(lowerCAmelCase_ )
																												_a     					=    AutoFeatureExtractor.from_pretrained(lowerCAmelCase_ )
																												self.assertIsInstance(lowerCAmelCase_							,      lowerCAmelCase_ )

														finally:
																					if "custom" in CONFIG_MAPPING._extra_content:
																												del CONFIG_MAPPING._extra_content["custom"]
																					if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
																												del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]







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


														"""simple docstring"""


														class       A   (		_a   ):
																					lowercase_          =    True

														try:
																					AutoConfig.register('''custom'''							,      lowerCAmelCase_ )
																					AutoFeatureExtractor.register(lowerCAmelCase_							,      lowerCAmelCase_ )
																					# If remote code is not set, the default is to use local
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor''' )
																					self.assertEqual(feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )
																					self.assertTrue(feature_extractor.is_local )

																					# If remote code is disabled, we load the local one.
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor'''							,      trust_remote_code=lowerCAmelCase_ )
																					self.assertEqual(feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )
																					self.assertTrue(feature_extractor.is_local )

																					# If remote is enabled, we load from the Hub
																					_a     					=    AutoFeatureExtractor.from_pretrained(
																					    '''hf-internal-testing/test_dynamic_feature_extractor'''							,      trust_remote_code=lowerCAmelCase_ )
																					self.assertEqual(feature_extractor.__class__.__name__							,      '''NewFeatureExtractor''' )
																					self.assertTrue(not hasattr(lowerCAmelCase_							,      '''is_local''' ) )

														finally:
																					if "custom" in CONFIG_MAPPING._extra_content:
																												del CONFIG_MAPPING._extra_content["custom"]
																					if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
																												del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]

