

"""simple docstring"""




import importlib
import inspect
from functools import wraps
from typing import TYPE_CHECKING, Optional, Union

from .download.streaming_download_manager import (
    xbasename,
    xdirname,
    xet_parse,
    xexists,
    xgetsize,
    xglob,
    xgzip_open,
    xisdir,
    xisfile,
    xjoin,
    xlistdir,
    xnumpy_load,
    xopen,
    xpandas_read_csv,
    xpandas_read_excel,
    xPath,
    xrelpath,
    xsio_loadmat,
    xsplit,
    xsplitext,
    xwalk,
    xxml_dom_minidom_parse,
)
from .utils.logging import get_logger
from .utils.patching import patch_submodule
from .utils.py_utils import get_imports


__A	:       Dict        =						get_logger(__name__)


if TYPE_CHECKING:
	from .builder import DatasetBuilder
def   __SCREAMING_SNAKE_CASE		(		lowercase__     ,				lowercase__ = None ):
					"""simple docstring"""
					A     =   importlib.import_module(lowercase__ )

					# TODO(QL): always update the module to add subsequent new authentication
					if hasattr(lowercase__     ,				"_patched_for_streaming" ) and module._patched_for_streaming:
										return

					def wrap_auth(lowercase__ ):
										@wraps(lowercase__ )
										def wrapper(*lowercase__     ,				**lowercase__ ):
															return function(*lowercase__     ,				use_auth_token=lowercase__     ,				**lowercase__ )

										A     =   "wrap_auth"
										return wrapper

					# open files in a streaming fashion
					patch_submodule(lowercase__     ,				"open"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"os.listdir"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"os.walk"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"glob.glob"     ,				wrap_auth(lowercase__ ) ).start()
					# allow to navigate in remote zip files
					patch_submodule(lowercase__     ,				"os.path.join"     ,				lowercase__ ).start()
					patch_submodule(lowercase__     ,				"os.path.dirname"     ,				lowercase__ ).start()
					patch_submodule(lowercase__     ,				"os.path.basename"     ,				lowercase__ ).start()
					patch_submodule(lowercase__     ,				"os.path.relpath"     ,				lowercase__ ).start()
					patch_submodule(lowercase__     ,				"os.path.split"     ,				lowercase__ ).start()
					patch_submodule(lowercase__     ,				"os.path.splitext"     ,				lowercase__ ).start()
					# allow checks on paths
					patch_submodule(lowercase__     ,				"os.path.exists"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"os.path.isdir"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"os.path.isfile"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"os.path.getsize"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"pathlib.Path"     ,				lowercase__ ).start()
					# file readers
					patch_submodule(lowercase__     ,				"gzip.open"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"numpy.load"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"pandas.read_csv"     ,				wrap_auth(lowercase__ )     ,				attrs=["__version__"] ).start()
					patch_submodule(lowercase__     ,				"pandas.read_excel"     ,				wrap_auth(lowercase__ )     ,				attrs=["__version__"] ).start()
					patch_submodule(lowercase__     ,				"scipy.io.loadmat"     ,				wrap_auth(lowercase__ )     ,				attrs=["__version__"] ).start()
					patch_submodule(lowercase__     ,				"xml.etree.ElementTree.parse"     ,				wrap_auth(lowercase__ ) ).start()
					patch_submodule(lowercase__     ,				"xml.dom.minidom.parse"     ,				wrap_auth(lowercase__ ) ).start()
					A     =   True
def   __SCREAMING_SNAKE_CASE		(		lowercase__ ):
					"""simple docstring"""
					extend_module_for_streaming(builder.__module__     ,				use_auth_token=builder.use_auth_token )
					# if needed, we also have to extend additional internal imports (like wmt14 -> wmt_utils)
					if not builder.__module__.startswith("datasets." ):  # check that it's not a packaged builder like csv
										for imports in get_imports(inspect.getfile(builder.__class__ ) ):
															if imports[0] == "internal":
																				A     =   imports[1]
																				A     =   ".".join(builder.__module__.split("." )[:-1] + [internal_import_name] )
																				extend_module_for_streaming(lowercase__     ,				use_auth_token=builder.use_auth_token )

    # builders can inherit from other builders that might use streaming functionality
    # (for example, ImageFolder and AudioFolder inherit from FolderBuilder which implements examples generation)
    # but these parents builders are not patched automatically as they are not instantiated, so we patch them here
					from .builder import DatasetBuilder

					A     =   [
					    cls.__module__
					    for cls in type(lowercase__ ).__mro__[1:]  # make sure it's not the same module we've already patched
					    if issubclass(cls     ,				lowercase__ ) and cls.__module__ != DatasetBuilder.__module__
					]  # check it's not a standard builder from datasets.builder
					for module in parent_builder_modules:
										extend_module_for_streaming(lowercase__     ,				use_auth_token=builder.use_auth_token )












"""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    _UpperCAmelCase  (      unittest.TestCase					):


					def __init__(   self     :Optional[Any]	,			__UpperCamelCase     :Optional[int]	,			__UpperCamelCase     :Dict=7	,			__UpperCamelCase     :Optional[Any]=3	,			__UpperCamelCase     :Tuple=18	,			__UpperCamelCase     :List[Any]=30	,			__UpperCamelCase     :Optional[Any]=4_00	,			__UpperCamelCase     :Union[str, Any]=True	,			__UpperCamelCase     :Tuple=None	,			__UpperCamelCase     :List[str]=True	,			__UpperCamelCase     :Any=False	,			__UpperCamelCase     :str=[0.48_145_466, 0.4_578_275, 0.40_821_073]	,			__UpperCamelCase     :Optional[Any]=[0.26_862_954, 0.26_130_258, 0.27_577_711]	,			__UpperCamelCase     :Optional[Any]=True	,			):
												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						=    do_resize
												A						=    size
												A						=    do_normalize
												A						=    image_mean
												A						=    image_std
												A						=    do_pad
												A						=    do_convert_rgb


					def       lowerCamelCase			(   self     :List[str]						):
												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     :Optional[Any]	,			__UpperCamelCase     :Optional[int]=False	,			__UpperCamelCase     :Dict=False	,			__UpperCamelCase     :Dict=False						):
												assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

												if equal_resolution:
																			A						=    []
																			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						=    []
																			for i in range(self.batch_size						):
																										A,      A						=    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						=    [Image.fromarray(np.moveaxis(__UpperCamelCase	,			0	,			-1						)						) for x in image_inputs]

												if torchify:
																			A						=    [torch.from_numpy(__UpperCamelCase						) for x in image_inputs]

												return image_inputs







@require_torch
@require_vision
class    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				BlipImageProcessor if is_vision_available() else None


					def       lowerCamelCase			(   self     :Optional[Any]						):
												A						=    BlipImageProcessingTester(self						)


					@property
					def       lowerCamelCase			(   self     :List[str]						):
												return self.image_processor_tester.prepare_image_processor_dict()


					def       lowerCamelCase			(   self     :Any						):
												A						=    self.image_processing_class(**self.image_processor_dict						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_resize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"size"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_normalize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_mean"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_std"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_convert_rgb"						)						)


					def       lowerCamelCase			(   self     :List[Any]						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PIL images
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			Image.Image						)

												# Test not batched input
												A						=    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						=    image_processor(__UpperCamelCase	,			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     :Union[str, Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random numpy tensors
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase	,			numpify=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			np.ndarray						)

												# Test not batched input
												A						=    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						=    image_processor(__UpperCamelCase	,			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     :Tuple						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PyTorch tensors
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase	,			torchify=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			torch.Tensor						)

												# Test not batched input
												A						=    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						=    image_processor(__UpperCamelCase	,			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    _UpperCAmelCase  (      lowercase_	,				unittest.TestCase					):
					UpperCamelCase						=				BlipImageProcessor if is_vision_available() else None


					def       lowerCamelCase			(   self     :int						):
												A						=    BlipImageProcessingTester(self	,			num_channels=4						)
												A						=    3


					@property
					def       lowerCamelCase			(   self     :Optional[Any]						):
												return self.image_processor_tester.prepare_image_processor_dict()


					def       lowerCamelCase			(   self     :int						):
												A						=    self.image_processing_class(**self.image_processor_dict						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_resize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"size"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_normalize"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_mean"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"image_std"						)						)
												self.assertTrue(hasattr(__UpperCamelCase	,			"do_convert_rgb"						)						)


					def       lowerCamelCase			(   self     :Any						):
												pass


					def       lowerCamelCase			(   self     :Optional[Any]						):
												# Initialize image_processor
												A						=    self.image_processing_class(**self.image_processor_dict						)
												# create random PIL images
												A						=    self.image_processor_tester.prepare_inputs(equal_resolution=__UpperCamelCase						)
												for image in image_inputs:
																			self.assertIsInstance(__UpperCamelCase	,			Image.Image						)

												# Test not batched input
												A						=    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						=    image_processor(__UpperCamelCase	,			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"],
												    )	,			)


