
from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
 from PIL import Image

 from transformers import ViTImageProcessor


class 						__lowerCAmelCase	:



      """simple docstring"""







      def __init__(      self		:       Optional[int]				,       _snake_case		:       str				,       _snake_case		:       Tuple=13				,       _snake_case		:       Any=30				,       _snake_case		:       int=2				,       _snake_case		:       Union[str, Any]=3				,       _snake_case		:       str=True				,       _snake_case		:       Tuple=True				,       _snake_case		:       Optional[int]=32				,       _snake_case		:       Optional[int]=2				,       _snake_case		:       Tuple=4				,       _snake_case		:       int=37				,       _snake_case		:       Optional[int]="gelu"				,       _snake_case		:       str=0.1				,       _snake_case		:       List[str]=0.1				,       _snake_case		:       List[str]=10				,       _snake_case		:       Union[str, Any]=0.02				,       _snake_case		:       Dict=3				,       _snake_case		:       Any=0.6				,       _snake_case		:       Union[str, Any]=None				,       ):
          __lowercase		:			str	    =       parent
          __lowercase		:			Union[str, Any]	    =       batch_size
          __lowercase		:			Dict	    =       image_size
          __lowercase		:			Optional[Any]	    =       patch_size
          __lowercase		:			Any	    =       num_channels
          __lowercase		:			List[Any]	    =       is_training
          __lowercase		:			Tuple	    =       use_labels
          __lowercase		:			Optional[int]	    =       hidden_size
          __lowercase		:			List[Any]	    =       num_hidden_layers
          __lowercase		:			Union[str, Any]	    =       num_attention_heads
          __lowercase		:			Tuple	    =       intermediate_size
          __lowercase		:			Dict	    =       hidden_act
          __lowercase		:			Dict	    =       hidden_dropout_prob
          __lowercase		:			List[Any]	    =       attention_probs_dropout_prob
          __lowercase		:			int	    =       type_sequence_label_size
          __lowercase		:			Dict	    =       initializer_range
          __lowercase		:			Optional[int]	    =       mask_ratio
          __lowercase		:			Optional[Any]	    =       scope

          # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
          # (we add 1 for the [CLS] token)
          __lowercase		:			List[Any]	    =       (image_size // patch_size) ** 2
          __lowercase		:			Union[str, Any]	    =       int(math.ceil((1 - mask_ratio) * (num_patches + 1)				)				)




      def 		snake_case_			(      self		:       Optional[Any]				):
          __lowercase		:			Dict	    =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

          __lowercase		:			int	    =       None
          if self.use_labels:
              __lowercase		:			Any	    =       ids_tensor([self.batch_size]				,       self.type_sequence_label_size				)

          __lowercase		:			Optional[Any]	    =       self.get_config()

          return config, pixel_values, labels




      def 		snake_case_			(      self		:       Union[str, Any]				):
          return ViTMAEConfig(
              image_size=self.image_size				,       patch_size=self.patch_size				,       num_channels=self.num_channels				,       hidden_size=self.hidden_size				,       num_hidden_layers=self.num_hidden_layers				,       num_attention_heads=self.num_attention_heads				,       intermediate_size=self.intermediate_size				,       decoder_hidden_size=self.hidden_size				,       decoder_num_hidden_layers=self.num_hidden_layers				,       decoder_num_attention_heads=self.num_attention_heads				,       decoder_intermediate_size=self.intermediate_size				,       hidden_act=self.hidden_act				,       hidden_dropout_prob=self.hidden_dropout_prob				,       attention_probs_dropout_prob=self.attention_probs_dropout_prob				,       is_decoder=_snake_case				,       initializer_range=self.initializer_range				,       mask_ratio=self.mask_ratio				,       )




      def 		snake_case_			(      self		:       Tuple				,       _snake_case		:       Union[str, Any]				,       _snake_case		:       Tuple				,       _snake_case		:       Optional[Any]				):
          __lowercase		:			Optional[int]	    =       TFViTMAEModel(config=_snake_case				)
          __lowercase		:			Any	    =       model(_snake_case				,       training=_snake_case				)
          self.parent.assertEqual(result.last_hidden_state.shape				,       (self.batch_size, self.seq_length, self.hidden_size)				)




      def 		snake_case_			(      self		:       Any				,       _snake_case		:       List[Any]				,       _snake_case		:       int				,       _snake_case		:       Tuple				):
          __lowercase		:			List[str]	    =       TFViTMAEForPreTraining(_snake_case				)
          __lowercase		:			List[Any]	    =       model(_snake_case				,       training=_snake_case				)
          # expected sequence length = num_patches
          __lowercase		:			Union[str, Any]	    =       (self.image_size // self.patch_size) ** 2
          __lowercase		:			str	    =       self.patch_size**2 * self.num_channels
          self.parent.assertEqual(result.logits.shape				,       (self.batch_size, num_patches, expected_num_channels)				)

          # test greyscale images
          __lowercase		:			Optional[Any]	    =       1
          __lowercase		:			Dict	    =       TFViTMAEForPreTraining(_snake_case				)

          __lowercase		:			List[str]	    =       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
          __lowercase		:			int	    =       model(_snake_case				,       training=_snake_case				)
          __lowercase		:			Union[str, Any]	    =       self.patch_size**2
          self.parent.assertEqual(result.logits.shape				,       (self.batch_size, num_patches, expected_num_channels)				)




      def 		snake_case_			(      self		:       int				):
          __lowercase		:			int	    =       self.prepare_config_and_inputs()
          ((__lowercase)    ,      (__lowercase)    ,      (__lowercase))		:			Any	    =       config_and_inputs
          __lowercase		:			List[Any]	    =       {'''pixel_values''': pixel_values}
          return config, inputs_dict






@require_tf
class 						__lowerCAmelCase	(	lowerCAmelCase_ , lowerCAmelCase_ , unittest.TestCase      ):



      """simple docstring"""







      A__	:			Tuple        =    (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
      A__	:			Dict        =    {'''feature-extraction''': TFViTMAEModel} if is_tf_available() else {}

      A__	:			str        =    False
      A__	:			int        =    False
      A__	:			Optional[Any]        =    False
      A__	:			Optional[int]        =    False




      def 		snake_case_			(      self		:       List[str]				):
          __lowercase		:			Union[str, Any]	    =       TFViTMAEModelTester(self				)
          __lowercase		:			Optional[Any]	    =       ConfigTester(self				,       config_class=_snake_case				,       has_text_modality=_snake_case				,       hidden_size=37				)




      def 		snake_case_			(      self		:       Union[str, Any]				):
          self.config_tester.run_common_tests()




      @unittest.skip(reason='''ViTMAE does not use inputs_embeds'''				)
      def 		snake_case_			(      self		:       Tuple				):
          pass




      def 		snake_case_			(      self		:       Optional[Any]				):
          __lowercase    ,      __lowercase		:			Tuple	    =       self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              __lowercase		:			Any	    =       model_class(_snake_case				)
              self.assertIsInstance(model.get_input_embeddings()				,       (tf.keras.layers.Layer)				)
              __lowercase		:			Tuple	    =       model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(_snake_case				,       tf.keras.layers.Layer				)				)




      def 		snake_case_			(      self		:       Any				):
          __lowercase    ,      __lowercase		:			Union[str, Any]	    =       self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              __lowercase		:			Dict	    =       model_class(_snake_case				)
              __lowercase		:			str	    =       inspect.signature(model.call				)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              __lowercase		:			List[Any]	    =       [*signature.parameters.keys()]

              __lowercase		:			Dict	    =       ['''pixel_values''']
              self.assertListEqual(arg_names[:1]				,       _snake_case				)




      def 		snake_case_			(      self		:       List[Any]				):
          __lowercase		:			Optional[Any]	    =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_snake_case				)




      def 		snake_case_			(      self		:       List[Any]				):
          __lowercase		:			Optional[int]	    =       self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_pretraining(*_snake_case				)




      def 		snake_case_			(      self		:       List[Any]				):
          # make the mask reproducible
          np.random.seed(2				)

          __lowercase    ,      __lowercase		:			str	    =       self.model_tester.prepare_config_and_inputs_for_common()

          __lowercase		:			int	    =       int((config.image_size // config.patch_size) ** 2				)
          __lowercase		:			Tuple	    =       np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)

          for model_class in self.all_model_classes:
              __lowercase		:			List[Any]	    =       model_class(_snake_case				)
              __lowercase		:			Optional[Any]	    =       self._prepare_for_class(_snake_case				,       _snake_case				)

              __lowercase		:			Optional[Any]	    =       model(_snake_case				,       noise=_snake_case				)

              __lowercase		:			List[Any]	    =       copy.deepcopy(self._prepare_for_class(_snake_case				,       _snake_case				)				)
              __lowercase		:			Optional[int]	    =       model(**_snake_case				,       noise=_snake_case				)
              __lowercase		:			Dict	    =       outputs_dict[0].numpy()
              __lowercase		:			Optional[Any]	    =       outputs_keywords[0].numpy()

              self.assertLess(np.sum(np.abs(output_dict - output_keywords				)				)				,       1E-6				)




      def 		snake_case_			(      self		:       Optional[Any]				):
          # make the mask reproducible
          np.random.seed(2				)

          __lowercase    ,      __lowercase		:			Any	    =       self.model_tester.prepare_config_and_inputs_for_common()

          __lowercase		:			int	    =       int((config.image_size // config.patch_size) ** 2				)
          __lowercase		:			int	    =       np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)

          def prepare_numpy_arrays(_snake_case		:       Tuple				):
              __lowercase		:			Dict	    =       {}
              for k, v in inputs_dict.items():
                  if tf.is_tensor(_snake_case				):
                      __lowercase		:			Optional[int]	    =       v.numpy()
                  else:
                      __lowercase		:			List[Any]	    =       np.array(_snake_case				)

              return inputs_np_dict

          for model_class in self.all_model_classes:
              __lowercase		:			Optional[int]	    =       model_class(_snake_case				)

              __lowercase		:			Any	    =       self._prepare_for_class(_snake_case				,       _snake_case				)
              __lowercase		:			Union[str, Any]	    =       prepare_numpy_arrays(_snake_case				)

              __lowercase		:			int	    =       model(_snake_case				,       noise=_snake_case				)
              __lowercase		:			int	    =       model(**_snake_case				,       noise=_snake_case				)
              self.assert_outputs_same(_snake_case				,       _snake_case				)




      def 		snake_case_			(      self		:       Optional[Any]				,       _snake_case		:       int				,       _snake_case		:       str				,       _snake_case		:       str				):
          # make masks reproducible
          np.random.seed(2				)

          __lowercase		:			List[str]	    =       int((tf_model.config.image_size // tf_model.config.patch_size) ** 2				)
          __lowercase		:			Union[str, Any]	    =       np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)
          __lowercase		:			Union[str, Any]	    =       tf.constant(_snake_case				)

          # Add `noise` argument.
          # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
          __lowercase		:			Any	    =       tf_noise

          super().check_pt_tf_models(_snake_case				,       _snake_case				,       _snake_case				)




      def 		snake_case_			(      self		:       str				):
          # make mask reproducible
          np.random.seed(2				)

          __lowercase    ,      __lowercase		:			str	    =       self.model_tester.prepare_config_and_inputs_for_common()

          __lowercase		:			Tuple	    =       {
              module_member
              for model_class in self.all_model_classes
              for module in (import_module(model_class.__module__				),)
              for module_member_name in dir(_snake_case				)
              if module_member_name.endswith('''MainLayer'''				)
              # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
              and module_member_name[: -len('''MainLayer'''				)] == model_class.__name__[: -len('''Model'''				)]
              for module_member in (getattr(_snake_case				,       _snake_case				),)
              if isinstance(_snake_case				,       _snake_case				)
              and tf.keras.layers.Layer in module_member.__bases__
              and getattr(_snake_case				,       '''_keras_serializable'''				,       _snake_case				)
          }

          __lowercase		:			Dict	    =       int((config.image_size // config.patch_size) ** 2				)
          __lowercase		:			Optional[Any]	    =       np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)
          __lowercase		:			List[Any]	    =       tf.convert_to_tensor(_snake_case				)
          inputs_dict.update({'''noise''': noise}				)

          for main_layer_class in tf_main_layer_classes:
              __lowercase		:			Optional[Any]	    =       main_layer_class(_snake_case				)

              __lowercase		:			Tuple	    =       {
                  name: tf.keras.Input(tensor.shape[1:]				,       dtype=tensor.dtype				) for name, tensor in inputs_dict.items()
              }

              __lowercase		:			Dict	    =       tf.keras.Model(_snake_case				,       outputs=main_layer(_snake_case				)				)
              __lowercase		:			Optional[int]	    =       model(_snake_case				)

              with tempfile.TemporaryDirectory() as tmpdirname:
                  __lowercase		:			Optional[int]	    =       os.path.join(_snake_case				,       '''keras_model.h5'''				)
                  model.save(_snake_case				)
                  __lowercase		:			Optional[Any]	    =       tf.keras.models.load_model(
                      _snake_case				,       custom_objects={main_layer_class.__name__: main_layer_class}				)
                  assert isinstance(_snake_case				,       tf.keras.Model				)
                  __lowercase		:			Tuple	    =       model(_snake_case				)
                  self.assert_outputs_same(_snake_case				,       _snake_case				)




      @slow
      def 		snake_case_			(      self		:       Optional[Any]				):
          # make mask reproducible
          np.random.seed(2				)

          __lowercase    ,      __lowercase		:			Any	    =       self.model_tester.prepare_config_and_inputs_for_common()

          __lowercase		:			Optional[int]	    =       int((config.image_size // config.patch_size) ** 2				)
          __lowercase		:			List[Any]	    =       np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)

          for model_class in self.all_model_classes:
              __lowercase		:			str	    =       model_class(_snake_case				)
              __lowercase		:			Optional[int]	    =       self._prepare_for_class(_snake_case				,       _snake_case				)
              __lowercase		:			List[str]	    =       model(_snake_case				,       noise=_snake_case				)

              if model_class.__name__ == "TFViTMAEModel":
                  __lowercase		:			str	    =       outputs.last_hidden_state.numpy()
                  __lowercase		:			Union[str, Any]	    =       0
              else:
                  __lowercase		:			List[Any]	    =       outputs.logits.numpy()
                  __lowercase		:			int	    =       0

              with tempfile.TemporaryDirectory() as tmpdirname:
                  model.save_pretrained(_snake_case				,       saved_model=_snake_case				)
                  __lowercase		:			Dict	    =       model_class.from_pretrained(_snake_case				)
                  __lowercase		:			Dict	    =       model(_snake_case				,       noise=_snake_case				)

                  if model_class.__name__ == "TFViTMAEModel":
                      __lowercase		:			int	    =       after_outputs['''last_hidden_state'''].numpy()
                      __lowercase		:			Optional[Any]	    =       0
                  else:
                      __lowercase		:			Optional[Any]	    =       after_outputs['''logits'''].numpy()
                      __lowercase		:			Dict	    =       0

                  __lowercase		:			Any	    =       np.amax(np.abs(out_a - out_a				)				)
                  self.assertLessEqual(_snake_case				,       1E-5				)




      def 		snake_case_			(      self		:       Union[str, Any]				):
          # make mask reproducible
          np.random.seed(2				)

          __lowercase    ,      __lowercase		:			str	    =       self.model_tester.prepare_config_and_inputs_for_common()

          __lowercase		:			Optional[int]	    =       int((config.image_size // config.patch_size) ** 2				)
          __lowercase		:			Dict	    =       np.random.uniform(size=(self.model_tester.batch_size, num_patches)				)

          for model_class in self.all_model_classes:
              __lowercase		:			int	    =       model_class(_snake_case				)
              __lowercase		:			str	    =       self._prepare_for_class(_snake_case				,       _snake_case				)

              __lowercase		:			List[str]	    =       model(_snake_case				,       noise=_snake_case				)
              __lowercase		:			Any	    =       model.get_config()
              # make sure that returned config is jsonifiable, which is required by keras
              json.dumps(_snake_case				)
              __lowercase		:			Any	    =       model_class.from_config(model.get_config()				)
              # make sure it also accepts a normal config
              __lowercase		:			Dict	    =       model_class.from_config(model.config				)
              __lowercase		:			str	    =       new_model(_snake_case				)  # Build model
              new_model.set_weights(model.get_weights()				)
              __lowercase		:			Any	    =       new_model(_snake_case				,       noise=_snake_case				)

              self.assert_outputs_same(_snake_case				,       _snake_case				)




      @unittest.skip(
          reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''				)
      def 		snake_case_			(      self		:       str				):
          pass




      @unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'''				)
      def 		snake_case_			(      self		:       Dict				):
          pass




      @slow
      def 		snake_case_			(      self		:       Any				):
          __lowercase		:			List[Any]	    =       TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224'''				)
          self.assertIsNotNone(_snake_case				)






def     UpperCAmelCase_  (						) ->						Union[str, Any]:
    __lowercase		:			List[Any]	    =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
    return image





@require_tf
@require_vision
class 						__lowerCAmelCase	(	unittest.TestCase      ):



      """simple docstring"""







      @cached_property
      def 		snake_case_			(      self		:       Tuple				):
          return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base'''				) if is_vision_available() else None




      @slow
      def 		snake_case_			(      self		:       List[str]				):
          # make random mask reproducible across the PT and TF model
          np.random.seed(2				)

          __lowercase		:			Dict	    =       TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base'''				)

          __lowercase		:			List[Any]	    =       self.default_image_processor
          __lowercase		:			Tuple	    =       prepare_img()
          __lowercase		:			Dict	    =       image_processor(images=_snake_case				,       return_tensors='''tf'''				)

          # prepare a noise vector that will be also used for testing the TF model
          # (this way we can ensure that the PT and TF models operate on the same inputs)
          __lowercase		:			str	    =       ViTMAEConfig()
          __lowercase		:			Tuple	    =       int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2				)
          __lowercase		:			Tuple	    =       np.random.uniform(size=(1, num_patches)				)

          # forward pass
          __lowercase		:			Optional[Any]	    =       model(**_snake_case				,       noise=_snake_case				)

          # verify the logits
          __lowercase		:			int	    =       tf.convert_to_tensor([1, 196, 768]				)
          self.assertEqual(outputs.logits.shape				,       _snake_case				)

          __lowercase		:			str	    =       tf.convert_to_tensor(
              [[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]]				)

          tf.debugging.assert_near(outputs.logits[0, :3, :3]				,       _snake_case				,       atol=1E-4				)




import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


__lowerCAmelCase					:			int			      =		{
    "debug": logging.DEBUG,
    "info": logging.INFO,
    "warning": logging.WARNING,
    "error": logging.ERROR,
    "critical": logging.CRITICAL,
}

__lowerCAmelCase					:			Optional[int]			      =		logging.WARNING


def     UpperCAmelCase_  (						) ->						Optional[Any]:
    __lowercase		:			Any	    =       os.getenv('''DATASETS_VERBOSITY'''	,					__lowerCAmelCase	)
    if env_level_str:
        if env_level_str in log_levels:
            return log_levels[env_level_str]
        else:
            logging.getLogger().warning(
                F'Unknown option DATASETS_VERBOSITY={env_level_str}, '
                F'has to be one of: { ", ".join(log_levels.keys()	) }'	)
    return _default_log_level


def     UpperCAmelCase_  (						) ->						str:
    return __name__.split('''.'''	)[0]


def     UpperCAmelCase_  (						) ->						logging.Logger:
    return logging.getLogger(_get_library_name()	)


def     UpperCAmelCase_  (						) ->						None:
    # Apply our default configuration to the library root logger.
    __lowercase		:			Union[str, Any]	    =       _get_library_root_logger()
    library_root_logger.setLevel(_get_default_logging_level()	)


def     UpperCAmelCase_  (						) ->						None:
    __lowercase		:			List[Any]	    =       _get_library_root_logger()
    library_root_logger.setLevel(logging.NOTSET	)


def     UpperCAmelCase_  (						__lowerCAmelCase = None	) ->						logging.Logger:
    if name is None:
        __lowercase		:			Optional[Any]	    =       _get_library_name()
    return logging.getLogger(__lowerCAmelCase	)


def     UpperCAmelCase_  (						) ->						int:
    return _get_library_root_logger().getEffectiveLevel()


def     UpperCAmelCase_  (						__lowerCAmelCase	) ->						None:
    _get_library_root_logger().setLevel(__lowerCAmelCase	)


def     UpperCAmelCase_  (						) ->						int:
    return set_verbosity(__lowerCAmelCase	)


def     UpperCAmelCase_  (						) ->						List[str]:
    return set_verbosity(__lowerCAmelCase	)


def     UpperCAmelCase_  (						) ->						Optional[int]:
    return set_verbosity(__lowerCAmelCase	)


def     UpperCAmelCase_  (						) ->						Any:
    return set_verbosity(__lowerCAmelCase	)


def     UpperCAmelCase_  (						) ->						None:
    __lowercase		:			Tuple	    =       False


def     UpperCAmelCase_  (						) ->						None:
    __lowercase		:			Dict	    =       True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()


class 						__lowerCAmelCase	:



      """simple docstring"""







      def __init__(      self		:       List[Any]				,       *_snake_case		:       List[Any]				,       **_snake_case		:       Dict				):  # pylint: disable=unused-argument
          __lowercase		:			Tuple	    =       args[0] if args else None




      def __iter__(      self		:       Tuple				):
          return iter(self._iterator				)




      def __getattr__(      self		:       Optional[int]				,       _snake_case		:       Union[str, Any]				):

          def empty_fn(*_snake_case		:       Tuple				,       **_snake_case		:       int				):  # pylint: disable=unused-argument
              return

          return empty_fn




      def __enter__(      self		:       Optional[Any]				):
          return self




      def __exit__(      self		:       Optional[Any]				,       _snake_case		:       Any				,       _snake_case		:       List[Any]				,       _snake_case		:       List[Any]				):
          return






__lowerCAmelCase					:			int			      =		True


class 						__lowerCAmelCase	:



      """simple docstring"""







      def __call__(      self		:       List[str]				,       *_snake_case		:       Dict				,       _snake_case		:       str=False				,       **_snake_case		:       List[str]				):
          if _tqdm_active and not disable:
              return tqdm_lib.tqdm(*_snake_case				,       **_snake_case				)
          else:
              return EmptyTqdm(*_snake_case				,       **_snake_case				)




      def 		snake_case_			(      self		:       Optional[Any]				,       *_snake_case		:       str				,       **_snake_case		:       List[str]				):
          __lowercase		:			Dict	    =       None
          if _tqdm_active:
              return tqdm_lib.tqdm.set_lock(*_snake_case				,       **_snake_case				)




      def 		snake_case_			(      self		:       Tuple				):
          if _tqdm_active:
              return tqdm_lib.tqdm.get_lock()






__lowerCAmelCase					:			Tuple			      =		_tqdm_cls()


def     UpperCAmelCase_  (						) ->						bool:
    global _tqdm_active
    return bool(_tqdm_active	)


def     UpperCAmelCase_  (						) ->						Union[str, Any]:
    global _tqdm_active
    __lowercase		:			Dict	    =       True





def     UpperCAmelCase_  (						) ->						Tuple:
    global _tqdm_active
    __lowercase		:			Optional[int]	    =       False


