

'''simple docstring'''



import collections
import inspect
import unittest

from transformers import SwinvaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
     from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor



class 				_snake_case					:

  def __init__(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE=13      , _SCREAMING_SNAKE_CASE=32      , _SCREAMING_SNAKE_CASE=2      , _SCREAMING_SNAKE_CASE=3      , _SCREAMING_SNAKE_CASE=16      , _SCREAMING_SNAKE_CASE=[1, 2, 1]      , _SCREAMING_SNAKE_CASE=[2, 2, 4]      , _SCREAMING_SNAKE_CASE=2      , _SCREAMING_SNAKE_CASE=2.0      , _SCREAMING_SNAKE_CASE=True      , _SCREAMING_SNAKE_CASE=0.0      , _SCREAMING_SNAKE_CASE=0.0      , _SCREAMING_SNAKE_CASE=0.1      , _SCREAMING_SNAKE_CASE="gelu"      , _SCREAMING_SNAKE_CASE=False      , _SCREAMING_SNAKE_CASE=True      , _SCREAMING_SNAKE_CASE=0.02      , _SCREAMING_SNAKE_CASE=1e-5      , _SCREAMING_SNAKE_CASE=True      , _SCREAMING_SNAKE_CASE=None      , _SCREAMING_SNAKE_CASE=True      , _SCREAMING_SNAKE_CASE=10      , _SCREAMING_SNAKE_CASE=8      , ):





      '''simple docstring'''

      lowerCAmelCase 						=							parent
      lowerCAmelCase 						=							batch_size
      lowerCAmelCase 						=							image_size
      lowerCAmelCase 						=							patch_size
      lowerCAmelCase 						=							num_channels
      lowerCAmelCase 						=							embed_dim
      lowerCAmelCase 						=							depths
      lowerCAmelCase 						=							num_heads
      lowerCAmelCase 						=							window_size
      lowerCAmelCase 						=							mlp_ratio
      lowerCAmelCase 						=							qkv_bias
      lowerCAmelCase 						=							hidden_dropout_prob
      lowerCAmelCase 						=							attention_probs_dropout_prob
      lowerCAmelCase 						=							drop_path_rate
      lowerCAmelCase 						=							hidden_act
      lowerCAmelCase 						=							use_absolute_embeddings
      lowerCAmelCase 						=							patch_norm
      lowerCAmelCase 						=							layer_norm_eps
      lowerCAmelCase 						=							initializer_range
      lowerCAmelCase 						=							is_training
      lowerCAmelCase 						=							scope
      lowerCAmelCase 						=							use_labels
      lowerCAmelCase 						=							type_sequence_label_size
      lowerCAmelCase 						=							encoder_stride

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

      lowerCAmelCase 						=							None
      if self.use_labels:
          lowerCAmelCase 						=							ids_tensor([self.batch_size]      , self.type_sequence_label_size	)

      lowerCAmelCase 						=							self.get_config()

      return config, pixel_values, labels

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      return SwinvaConfig(
          image_size=self.image_size      , patch_size=self.patch_size      , num_channels=self.num_channels      , embed_dim=self.embed_dim      , depths=self.depths      , num_heads=self.num_heads      , window_size=self.window_size      , mlp_ratio=self.mlp_ratio      , qkv_bias=self.qkv_bias      , hidden_dropout_prob=self.hidden_dropout_prob      , attention_probs_dropout_prob=self.attention_probs_dropout_prob      , drop_path_rate=self.drop_path_rate      , hidden_act=self.hidden_act      , use_absolute_embeddings=self.use_absolute_embeddings      , path_norm=self.patch_norm      , layer_norm_eps=self.layer_norm_eps      , initializer_range=self.initializer_range      , encoder_stride=self.encoder_stride      , )

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							SwinvaModel(config=_SCREAMING_SNAKE_CASE	)
      model.to(_SCREAMING_SNAKE_CASE	)
      model.eval()
      lowerCAmelCase 						=							model(_SCREAMING_SNAKE_CASE	)

      lowerCAmelCase 						=							((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
      lowerCAmelCase 						=							int(config.embed_dim * 2 ** (len(config.depths	) - 1)	)

      self.parent.assertEqual(result.last_hidden_state.shape      , (self.batch_size, expected_seq_len, expected_dim)	)

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							SwinvaForMaskedImageModeling(config=_SCREAMING_SNAKE_CASE	)
      model.to(_SCREAMING_SNAKE_CASE	)
      model.eval()
      lowerCAmelCase 						=							model(_SCREAMING_SNAKE_CASE	)
      self.parent.assertEqual(
          result.logits.shape      , (self.batch_size, self.num_channels, self.image_size, self.image_size)	)

      # test greyscale images
      lowerCAmelCase 						=							1
      lowerCAmelCase 						=							SwinvaForMaskedImageModeling(_SCREAMING_SNAKE_CASE	)
      model.to(_SCREAMING_SNAKE_CASE	)
      model.eval()

      lowerCAmelCase 						=							floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
      lowerCAmelCase 						=							model(_SCREAMING_SNAKE_CASE	)
      self.parent.assertEqual(result.logits.shape      , (self.batch_size, 1, self.image_size, self.image_size)	)

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.type_sequence_label_size
      lowerCAmelCase 						=							SwinvaForImageClassification(_SCREAMING_SNAKE_CASE	)
      model.to(_SCREAMING_SNAKE_CASE	)
      model.eval()
      lowerCAmelCase 						=							model(_SCREAMING_SNAKE_CASE      , labels=_SCREAMING_SNAKE_CASE	)
      self.parent.assertEqual(result.logits.shape      , (self.batch_size, self.type_sequence_label_size)	)


  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.prepare_config_and_inputs()
      lowerCAmelCase						,   lowerCAmelCase						,   lowerCAmelCase 						=							config_and_inputs
      lowerCAmelCase 						=							{'pixel_values': pixel_values}
      return config, inputs_dict



@require_torch
class 				_snake_case					(   a_     , a_     , unittest.TestCase			):
  SCREAMING_SNAKE_CASE			:       str				=     (
      (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
  )
  SCREAMING_SNAKE_CASE			:       List[Any]				=     (
      {'''feature-extraction''': SwinvaModel, '''image-classification''': SwinvaForImageClassification}
      if is_torch_available()
      else {}
  )

  SCREAMING_SNAKE_CASE			:       Union[str, Any]				=     False
  SCREAMING_SNAKE_CASE			:       Any				=     False
  SCREAMING_SNAKE_CASE			:       str				=     False
  SCREAMING_SNAKE_CASE			:       Union[str, Any]				=     False

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							SwinvaModelTester(self	)
      lowerCAmelCase 						=							ConfigTester(self      , config_class=_SCREAMING_SNAKE_CASE      , embed_dim=37	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      self.config_tester.create_and_test_config_to_json_string()
      self.config_tester.create_and_test_config_to_json_file()
      self.config_tester.create_and_test_config_from_and_save_pretrained()
      self.config_tester.create_and_test_config_with_num_labels()
      self.config_tester.check_config_can_be_init_without_params()
      self.config_tester.check_config_arguments_init()

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE	)

  @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass

  @unittest.skip(reason='Swinv2 does not use inputs_embeds'	)
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      pass

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							model_class(_SCREAMING_SNAKE_CASE	)
          self.assertIsInstance(model.get_input_embeddings()      , (nn.Module)	)
          lowerCAmelCase 						=							model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE      , nn.Linear	)	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							model_class(_SCREAMING_SNAKE_CASE	)
          lowerCAmelCase 						=							inspect.signature(model.forward	)
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          lowerCAmelCase 						=							[*signature.parameters.keys()]

          lowerCAmelCase 						=							['pixel_values']
          self.assertListEqual(arg_names[:1]      , _SCREAMING_SNAKE_CASE	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()
      lowerCAmelCase 						=							True

      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							True
          lowerCAmelCase 						=							False
          lowerCAmelCase 						=							True
          lowerCAmelCase 						=							model_class(_SCREAMING_SNAKE_CASE	)
          model.to(_SCREAMING_SNAKE_CASE	)
          model.eval()
          with torch.no_grad():
              lowerCAmelCase 						=							model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)	)
          lowerCAmelCase 						=							outputs.attentions
          lowerCAmelCase 						=							len(self.model_tester.depths	)
          self.assertEqual(len(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)

          # check that output_attentions also work using config
          del inputs_dict["output_attentions"]
          lowerCAmelCase 						=							True
          lowerCAmelCase 						=							config.window_size**2
          lowerCAmelCase 						=							model_class(_SCREAMING_SNAKE_CASE	)
          model.to(_SCREAMING_SNAKE_CASE	)
          model.eval()
          with torch.no_grad():
              lowerCAmelCase 						=							model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)	)
          lowerCAmelCase 						=							outputs.attentions
          self.assertEqual(len(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)

          self.assertListEqual(
              list(attentions[0].shape[-3:]	)      , [self.model_tester.num_heads[0], window_size_squared, window_size_squared]      , )
          lowerCAmelCase 						=							len(_SCREAMING_SNAKE_CASE	)

          # Check attention is always last and order is fine
          lowerCAmelCase 						=							True
          lowerCAmelCase 						=							True
          lowerCAmelCase 						=							model_class(_SCREAMING_SNAKE_CASE	)
          model.to(_SCREAMING_SNAKE_CASE	)
          model.eval()
          with torch.no_grad():
              lowerCAmelCase 						=							model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)	)

          if hasattr(self.model_tester      , 'num_hidden_states_types'	):
              lowerCAmelCase 						=							self.model_tester.num_hidden_states_types
          else:
              # also another +1 for reshaped_hidden_states
              lowerCAmelCase 						=							2
          self.assertEqual(out_len + added_hidden_states      , len(_SCREAMING_SNAKE_CASE	)	)

          lowerCAmelCase 						=							outputs.attentions

          self.assertEqual(len(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)

          self.assertListEqual(
              list(self_attentions[0].shape[-3:]	)      , [self.model_tester.num_heads[0], window_size_squared, window_size_squared]      , )

  def   _SCREAMING_SNAKE_CASE				(				self      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	):





      '''simple docstring'''

      lowerCAmelCase 						=							model_class(_SCREAMING_SNAKE_CASE	)
      model.to(_SCREAMING_SNAKE_CASE	)
      model.eval()

      with torch.no_grad():
          lowerCAmelCase 						=							model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)	)

      lowerCAmelCase 						=							outputs.hidden_states

      lowerCAmelCase 						=							getattr(
          self.model_tester      , 'expected_num_hidden_layers'      , len(self.model_tester.depths	) + 1	)
      self.assertEqual(len(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)

      # Swinv2 has a different seq_length
      lowerCAmelCase 						=							(
          config.patch_size
          if isinstance(config.patch_size      , collections.abc.Iterable	)
          else (config.patch_size, config.patch_size)
      )

      lowerCAmelCase 						=							(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

      self.assertListEqual(
          list(hidden_states[0].shape[-2:]	)      , [num_patches, self.model_tester.embed_dim]      , )

      lowerCAmelCase 						=							outputs.reshaped_hidden_states
      self.assertEqual(len(_SCREAMING_SNAKE_CASE	)      , _SCREAMING_SNAKE_CASE	)

      lowerCAmelCase						,   lowerCAmelCase						,   lowerCAmelCase						,   lowerCAmelCase 						=							reshaped_hidden_states[0].shape
      lowerCAmelCase 						=							(
          reshaped_hidden_states[0].view(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , height * width	).permute(0      , 2      , 1	)
      )
      self.assertListEqual(
          list(reshaped_hidden_states.shape[-2:]	)      , [num_patches, self.model_tester.embed_dim]      , )

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()

      lowerCAmelCase 						=							(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size      , collections.abc.Iterable	)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )

      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							True
          self.check_hidden_states_output(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)

          # check that output_hidden_states also work using config
          del inputs_dict["output_hidden_states"]
          lowerCAmelCase 						=							True

          self.check_hidden_states_output(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()
      lowerCAmelCase 						=							3

      lowerCAmelCase 						=							(
          self.model_tester.image_size
          if isinstance(self.model_tester.image_size      , collections.abc.Iterable	)
          else (self.model_tester.image_size, self.model_tester.image_size)
      )
      lowerCAmelCase 						=							(
          config.patch_size
          if isinstance(config.patch_size      , collections.abc.Iterable	)
          else (config.patch_size, config.patch_size)
      )

      lowerCAmelCase 						=							image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
      lowerCAmelCase 						=							image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							True
          self.check_hidden_states_output(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , (padded_height, padded_width)	)

          # check that output_hidden_states also work using config
          del inputs_dict["output_hidden_states"]
          lowerCAmelCase 						=							True
          self.check_hidden_states_output(_SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , _SCREAMING_SNAKE_CASE      , (padded_height, padded_width)	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_image_modeling(*_SCREAMING_SNAKE_CASE	)

  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE	)

  @slow
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowerCAmelCase 						=							SwinvaModel.from_pretrained(_SCREAMING_SNAKE_CASE	)
          self.assertIsNotNone(_SCREAMING_SNAKE_CASE	)


  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase						,   lowerCAmelCase 						=							self.model_tester.prepare_config_and_inputs_for_common()

      lowerCAmelCase 						=							_config_zero_init(_SCREAMING_SNAKE_CASE	)
      for model_class in self.all_model_classes:
          lowerCAmelCase 						=							model_class(config=_SCREAMING_SNAKE_CASE	)
          for name, param in model.named_parameters():
              if "embeddings" not in name and "logit_scale" not in name and param.requires_grad:
                  self.assertIn(
                      ((param.data.mean() * 1e9).round() / 1e9).item()      , [0.0, 1.0]      , msg=F'Parameter {name} of model {model_class} seems not properly initialized'      , )



@require_vision
@require_torch
class 				_snake_case					(   unittest.TestCase			):

  @cached_property
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      return (
          AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'	)
          if is_vision_available()
          else None
      )


  @slow
  def   _SCREAMING_SNAKE_CASE				(				self	):





      '''simple docstring'''

      lowerCAmelCase 						=							SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'	).to(
          _SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							self.default_image_processor

      lowerCAmelCase 						=							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
      lowerCAmelCase 						=							image_processor(images=_SCREAMING_SNAKE_CASE      , return_tensors='pt'	).to(_SCREAMING_SNAKE_CASE	)

      # forward pass
      with torch.no_grad():
          lowerCAmelCase 						=							model(**_SCREAMING_SNAKE_CASE	)

      # verify the logits
      lowerCAmelCase 						=							torch.Size((1, 10_00)	)
      self.assertEqual(outputs.logits.shape      , _SCREAMING_SNAKE_CASE	)
      lowerCAmelCase 						=							torch.tensor([-0.3_947, -0.4_306, 0.0_026]	).to(_SCREAMING_SNAKE_CASE	)
      self.assertTrue(torch.allclose(outputs.logits[0, :3]      , _SCREAMING_SNAKE_CASE      , atol=1e-4	)	)








'''simple docstring'''



import colorsys

from PIL import Image  # type: ignore


def       snake_case   (	snake_case      : float					,		snake_case      : float					,		snake_case      : int			) ->  float:


    """simple docstring"""


    lowerCAmelCase 						=							x
    lowerCAmelCase 						=							y
    for step in range(snake_case			):  # noqa: B007
        lowerCAmelCase 						=							a * a - b * b + x
        lowerCAmelCase 						=							2 * a * b + y
        lowerCAmelCase 						=							a_new

        # divergence happens for all complex number with an absolute value
        # greater than 4
        if a * a + b * b > 4:
            break
    return step / (max_step - 1)


def       snake_case   (	snake_case      : float			) ->  tuple:


    """simple docstring"""


    if distance == 1:
        return (0, 0, 0)
    else:
        return (255, 255, 255)


def       snake_case   (	snake_case      : float			) ->  tuple:


    """simple docstring"""


    if distance == 1:
        return (0, 0, 0)
    else:
        return tuple(round(i * 255			) for i in colorsys.hsv_to_rgb(snake_case					,		1					,		1			)			)


def       snake_case   (	snake_case      : int = 800					,		snake_case      : int = 600					,		snake_case      : float = -0.6					,		snake_case      : float = 0					,		snake_case      : float = 3.2					,		snake_case      : int = 50					,		snake_case      : bool = True					,		) ->  Image.Image:


    """simple docstring"""


    lowerCAmelCase 						=							Image.new('RGB'					,		(image_width, image_height)			)
    lowerCAmelCase 						=							img.load()

    # loop through the image-coordinates
    for image_x in range(snake_case			):
        for image_y in range(snake_case			):
            # determine the figure-coordinates based on the image-coordinates
            lowerCAmelCase 						=							figure_width / image_width * image_height
            lowerCAmelCase 						=							figure_center_x + (image_x / image_width - 0.5) * figure_width
            lowerCAmelCase 						=							figure_center_y + (image_y / image_height - 0.5) * figure_height

            lowerCAmelCase 						=							get_distance(snake_case					,		snake_case					,		snake_case			)

            # color the corresponding pixel based on the selected coloring-function
            if use_distance_color_coding:
                lowerCAmelCase 						=							get_color_coded_rgb(snake_case			)
            else:
                lowerCAmelCase 						=							get_black_and_white_rgb(snake_case			)

    return img


if __name__ == "__main__":
     import doctest

     doctest.testmod()

     # colored version, full figure
     _UpperCamelCase						:  Dict							       =				get_image()

     # uncomment for colored version, different section, zoomed in
     # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4,
     # figure_width = 0.8)

     # uncomment for black and white version, full figure
     # img = get_image(use_distance_color_coding = False)

     # uncomment to save the image
     # img.save("mandelbrot.png")

     img.show()





