
'''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:
      lowercase			:				str    		=			False

if is_vision_available():
      from PIL import Image

      from transformers import PixaStructImageProcessor





class  A				(							unittest.TestCase						):





     def __init__(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE=7						,			SCREAMING_SNAKE_CASE=3						,			SCREAMING_SNAKE_CASE=18						,			SCREAMING_SNAKE_CASE=30						,			SCREAMING_SNAKE_CASE=400						,			SCREAMING_SNAKE_CASE=None						,			SCREAMING_SNAKE_CASE=True						,			SCREAMING_SNAKE_CASE=True						,			SCREAMING_SNAKE_CASE=None						,			) ->				List[str]:






         """simple docstring"""






         A       :   Any					=						size if size is not None else {'''height''': 20, '''width''': 20}
         A       :   List[Any]					=						parent
         A       :   Dict					=						batch_size
         A       :   Optional[Any]					=						num_channels
         A       :   str					=						image_size
         A       :   List[Any]					=						min_resolution
         A       :   Optional[int]					=						max_resolution
         A       :   Union[str, Any]					=						size
         A       :   Tuple					=						do_normalize
         A       :   Tuple					=						do_convert_rgb
         A       :   Union[str, Any]					=						[512, 1024, 2048, 4096]
         A       :   Optional[int]					=						patch_size if patch_size is not None else {'''height''': 16, '''width''': 16}





     def 				__lowerCAmelCase							(							self	) ->				str:






         """simple docstring"""






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





     def 				__lowerCAmelCase							(							self	) ->				int:






         """simple docstring"""






         A       :   str					=						'''https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg'''
         A       :   List[str]					=						Image.open(requests.get(SCREAMING_SNAKE_CASE						,			stream=SCREAMING_SNAKE_CASE	).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				(							__snake_case    ,			unittest.TestCase						):
     __magic_name__						=		PixaStructImageProcessor if is_vision_available() else None





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






         """simple docstring"""






         A       :   Optional[int]					=						PixaStructImageProcessingTester(self	)





     @property
     def 				__lowerCAmelCase							(							self	) ->				Tuple:






         """simple docstring"""






         return self.image_processor_tester.prepare_image_processor_dict()





     def 				__lowerCAmelCase							(							self	) ->				Tuple:






         """simple docstring"""






         A       :   List[str]					=						self.image_processing_class(**self.image_processor_dict	)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE						,			'''do_normalize'''	)	)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE						,			'''do_convert_rgb'''	)	)





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






         """simple docstring"""






         A       :   Dict					=						self.image_processor_tester.prepare_dummy_image()

         A       :   Union[str, Any]					=						self.image_processing_class(**self.image_processor_dict	)
         A       :   int					=						2048

         A       :   Tuple					=						image_processor(SCREAMING_SNAKE_CASE						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	)
         self.assertTrue(torch.allclose(inputs.flattened_patches.mean()						,			torch.tensor(0.0_606	)						,			atol=1e-3						,			rtol=1e-3	)	)





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






         """simple docstring"""






         A       :   Optional[int]					=						self.image_processing_class(**self.image_processor_dict	)
         # create random PIL images
         A       :   int					=						prepare_image_inputs(self.image_processor_tester						,			equal_resolution=SCREAMING_SNAKE_CASE	)
         for image in image_inputs:
             self.assertIsInstance(SCREAMING_SNAKE_CASE						,			Image.Image	)

         # Test not batched input
         A       :   str					=						(
             (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       :   Optional[int]					=						image_processor(
                 image_inputs[0]						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(1, max_patch, expected_hidden_dim)						,			)

             # Test batched
             A       :   Union[str, Any]					=						image_processor(
                 SCREAMING_SNAKE_CASE						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)						,			)





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






         """simple docstring"""






         A       :   List[Any]					=						self.image_processing_class(**self.image_processor_dict	)
         # create random PIL images
         A       :   Any					=						prepare_image_inputs(self.image_processor_tester						,			equal_resolution=SCREAMING_SNAKE_CASE	)
         for image in image_inputs:
             self.assertIsInstance(SCREAMING_SNAKE_CASE						,			Image.Image	)

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

         A       :   Optional[int]					=						True

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

             A       :   Any					=						'''Hello'''

             A       :   Any					=						image_processor(
                 image_inputs[0]						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE						,			header_text=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(1, max_patch, expected_hidden_dim)						,			)

             # Test batched
             A       :   Optional[int]					=						image_processor(
                 SCREAMING_SNAKE_CASE						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE						,			header_text=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)						,			)





     def 				__lowerCAmelCase							(							self	) ->				Dict:






         """simple docstring"""






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

         A       :   Tuple					=						(
             (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       :   List[Any]					=						image_processor(
                 image_inputs[0]						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(1, max_patch, expected_hidden_dim)						,			)

             # Test batched
             A       :   str					=						image_processor(
                 SCREAMING_SNAKE_CASE						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)						,			)





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






         """simple docstring"""






         A       :   str					=						self.image_processing_class(**self.image_processor_dict	)
         # create random PyTorch tensors
         A       :   Optional[Any]					=						prepare_image_inputs(self.image_processor_tester						,			equal_resolution=SCREAMING_SNAKE_CASE						,			torchify=SCREAMING_SNAKE_CASE	)
         for image in image_inputs:
             self.assertIsInstance(SCREAMING_SNAKE_CASE						,			torch.Tensor	)

         # Test not batched input
         A       :   int					=						(
             (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       :   Optional[Any]					=						image_processor(
                 image_inputs[0]						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(1, max_patch, expected_hidden_dim)						,			)

             # Test batched
             A       :   Dict					=						image_processor(
                 SCREAMING_SNAKE_CASE						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	).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				(							__snake_case    ,			unittest.TestCase						):
     __magic_name__						=		PixaStructImageProcessor if is_vision_available() else None





     def 				__lowerCAmelCase							(							self	) ->				str:






         """simple docstring"""






         A       :   Union[str, Any]					=						PixaStructImageProcessingTester(self						,			num_channels=4	)
         A       :   Optional[Any]					=						3





     @property
     def 				__lowerCAmelCase							(							self	) ->				Tuple:






         """simple docstring"""






         return self.image_processor_tester.prepare_image_processor_dict()





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






         """simple docstring"""






         A       :   str					=						self.image_processing_class(**self.image_processor_dict	)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE						,			'''do_normalize'''	)	)
         self.assertTrue(hasattr(SCREAMING_SNAKE_CASE						,			'''do_convert_rgb'''	)	)





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






         """simple docstring"""






         A       :   List[Any]					=						self.image_processing_class(**self.image_processor_dict	)
         # create random PIL images
         A       :   Optional[Any]					=						prepare_image_inputs(self.image_processor_tester						,			equal_resolution=SCREAMING_SNAKE_CASE	)
         for image in image_inputs:
             self.assertIsInstance(SCREAMING_SNAKE_CASE						,			Image.Image	)

         # Test not batched input
         A       :   int					=						(
             (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       :   Any					=						image_processor(
                 image_inputs[0]						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(1, max_patch, expected_hidden_dim)						,			)

             # Test batched
             A       :   int					=						image_processor(
                 SCREAMING_SNAKE_CASE						,			return_tensors='''pt'''						,			max_patches=SCREAMING_SNAKE_CASE	).flattened_patches
             self.assertEqual(
                 encoded_images.shape						,			(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim)						,			)





"""simple docstring"""


from .constants import (
    MODEL_NAME,
    OPTIMIZER_NAME,
    RNG_STATE_NAME,
    SAFE_WEIGHTS_INDEX_NAME,
    SAFE_WEIGHTS_NAME,
    SCALER_NAME,
    SCHEDULER_NAME,
    TORCH_LAUNCH_PARAMS,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
)
from .dataclasses import (
    BnbQuantizationConfig,
    ComputeEnvironment,
    CustomDtype,
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    DynamoBackend,
    FPaRecipeKwargs,
    FullyShardedDataParallelPlugin,
    GradientAccumulationPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    KwargsHandler,
    LoggerType,
    MegatronLMPlugin,
    PrecisionType,
    ProjectConfiguration,
    RNGType,
    SageMakerDistributedType,
    TensorInformation,
    TorchDynamoPlugin,
)
from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env
from .imports import (
    get_ccl_version,
    is_abit_bnb_available,
    is_abit_bnb_available,
    is_aim_available,
    is_bfaa_available,
    is_bnb_available,
    is_botoa_available,
    is_ccl_available,
    is_comet_ml_available,
    is_datasets_available,
    is_deepspeed_available,
    is_fpa_available,
    is_ipex_available,
    is_megatron_lm_available,
    is_mlflow_available,
    is_mps_available,
    is_npu_available,
    is_rich_available,
    is_safetensors_available,
    is_sagemaker_available,
    is_tensorboard_available,
    is_tpu_available,
    is_transformers_available,
    is_wandb_available,
    is_xpu_available,
)
from .modeling import (
    check_device_map,
    check_tied_parameters_in_config,
    check_tied_parameters_on_same_device,
    compute_module_sizes,
    convert_file_size_to_int,
    dtype_byte_size,
    find_tied_parameters,
    get_balanced_memory,
    get_max_layer_size,
    get_max_memory,
    get_mixed_precision_context_manager,
    id_tensor_storage,
    infer_auto_device_map,
    load_checkpoint_in_model,
    load_offloaded_weights,
    load_state_dict,
    named_module_tensors,
    retie_parameters,
    set_module_tensor_to_device,
    shard_checkpoint,
)
from .offload import (
    OffloadedWeightsLoader,
    PrefixedDataset,
    extract_submodules_state_dict,
    load_offloaded_weight,
    offload_state_dict,
    offload_weight,
    save_offload_index,
)
from .operations import (
    broadcast,
    broadcast_object_list,
    concatenate,
    convert_outputs_to_fpaa,
    convert_to_fpaa,
    find_batch_size,
    find_device,
    gather,
    gather_object,
    get_data_structure,
    honor_type,
    initialize_tensors,
    is_namedtuple,
    is_tensor_information,
    is_torch_tensor,
    listify,
    pad_across_processes,
    recursively_apply,
    reduce,
    send_to_device,
    slice_tensors,
)
from .versions import compare_versions, is_torch_version


if is_deepspeed_available():
    from .deepspeed import (
        DeepSpeedEngineWrapper,
        DeepSpeedOptimizerWrapper,
        DeepSpeedSchedulerWrapper,
        DummyOptim,
        DummyScheduler,
        HfDeepSpeedConfig,
    )

from .bnb import has_abit_bnb_layers, load_and_quantize_model
from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer
from .launch import (
    PrepareForLaunch,
    _filter_args,
    prepare_deepspeed_cmd_env,
    prepare_multi_gpu_env,
    prepare_sagemager_args_inputs,
    prepare_simple_launcher_cmd_env,
    prepare_tpu,
)
from .megatron_lm import (
    AbstractTrainStep,
    BertTrainStep,
    GPTTrainStep,
    MegatronEngine,
    MegatronLMDummyDataLoader,
    MegatronLMDummyScheduler,
    MegatronLMOptimizerWrapper,
    MegatronLMSchedulerWrapper,
    TaTrainStep,
    avg_losses_across_data_parallel_group,
    gather_across_data_parallel_groups,
)
from .megatron_lm import initialize as megatron_lm_initialize
from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader
from .megatron_lm import prepare_model as megatron_lm_prepare_model
from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer
from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler
from .memory import find_executable_batch_size, release_memory
from .other import (
    extract_model_from_parallel,
    get_pretty_name,
    is_port_in_use,
    merge_dicts,
    patch_environment,
    save,
    wait_for_everyone,
    write_basic_config,
)
from .random import set_seed, synchronize_rng_state, synchronize_rng_states
from .torch_xla import install_xla
from .tqdm import tqdm
from .transformer_engine import convert_model, has_transformer_engine_layers
