

import collections
import inspect
import unittest

from transformers import SwinConfig
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_backbone_common import BackboneTesterMixin
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 SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
       from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import AutoImageProcessor
class    A_				:


    '''simple docstring'''






    def __init__(self       , lowercase__       , lowercase__=13       , lowercase__=32       , lowercase__=2       , lowercase__=3       , lowercase__=16       , lowercase__=[1, 2, 1]       , lowercase__=[2, 2, 4]       , lowercase__=2       , lowercase__=2.0       , lowercase__=True       , lowercase__=0.0       , lowercase__=0.0       , lowercase__=0.1       , lowercase__="gelu"       , lowercase__=False       , lowercase__=True       , lowercase__=0.02       , lowercase__=1E-5       , lowercase__=True       , lowercase__=None       , lowercase__=True       , lowercase__=10       , lowercase__=8       , lowercase__=["stage1", "stage2"]       , lowercase__=[1, 2]       , )       -> List[str]:
        __UpperCAmelCase			   =     parent
        __UpperCAmelCase			   =     batch_size
        __UpperCAmelCase			   =     image_size
        __UpperCAmelCase			   =     patch_size
        __UpperCAmelCase			   =     num_channels
        __UpperCAmelCase			   =     embed_dim
        __UpperCAmelCase			   =     depths
        __UpperCAmelCase			   =     num_heads
        __UpperCAmelCase			   =     window_size
        __UpperCAmelCase			   =     mlp_ratio
        __UpperCAmelCase			   =     qkv_bias
        __UpperCAmelCase			   =     hidden_dropout_prob
        __UpperCAmelCase			   =     attention_probs_dropout_prob
        __UpperCAmelCase			   =     drop_path_rate
        __UpperCAmelCase			   =     hidden_act
        __UpperCAmelCase			   =     use_absolute_embeddings
        __UpperCAmelCase			   =     patch_norm
        __UpperCAmelCase			   =     layer_norm_eps
        __UpperCAmelCase			   =     initializer_range
        __UpperCAmelCase			   =     is_training
        __UpperCAmelCase			   =     scope
        __UpperCAmelCase			   =     use_labels
        __UpperCAmelCase			   =     type_sequence_label_size
        __UpperCAmelCase			   =     encoder_stride
        __UpperCAmelCase			   =     out_features
        __UpperCAmelCase			   =     out_indices


    def        lowerCAmelCase_  (self					)       -> List[str]:
        __UpperCAmelCase			   =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

        __UpperCAmelCase			   =     self.get_config()

        return config, pixel_values, labels


    def        lowerCAmelCase_  (self					)       -> int:
        return SwinConfig(
            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       , out_features=self.out_features       , out_indices=self.out_indices       , )


    def        lowerCAmelCase_  (self       , lowercase__       , lowercase__       , lowercase__					)       -> Tuple:
        __UpperCAmelCase			   =     SwinModel(config=snake_case_					)
        model.to(snake_case_					)
        model.eval()
        __UpperCAmelCase			   =     model(snake_case_					)

        __UpperCAmelCase			   =     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
        __UpperCAmelCase			   =     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        lowerCAmelCase_  (self       , lowercase__       , lowercase__       , lowercase__					)       -> int:
        __UpperCAmelCase			   =     SwinBackbone(config=snake_case_					)
        model.to(snake_case_					)
        model.eval()
        __UpperCAmelCase			   =     model(snake_case_					)

        # verify hidden states
        self.parent.assertEqual(len(result.feature_maps					)       , len(config.out_features					)					)
        self.parent.assertListEqual(list(result.feature_maps[0].shape					)       , [self.batch_size, model.channels[0], 16, 16]					)

        # verify channels
        self.parent.assertEqual(len(model.channels					)       , len(config.out_features					)					)

        # verify backbone works with out_features=None
        __UpperCAmelCase			   =     None
        __UpperCAmelCase			   =     SwinBackbone(config=snake_case_					)
        model.to(snake_case_					)
        model.eval()
        __UpperCAmelCase			   =     model(snake_case_					)

        # verify feature maps
        self.parent.assertEqual(len(result.feature_maps					)       , 1					)
        self.parent.assertListEqual(list(result.feature_maps[0].shape					)       , [self.batch_size, model.channels[-1], 4, 4]					)

        # verify channels
        self.parent.assertEqual(len(model.channels					)       , 1					)


    def        lowerCAmelCase_  (self       , lowercase__       , lowercase__       , lowercase__					)       -> Any:
        __UpperCAmelCase			   =     SwinForMaskedImageModeling(config=snake_case_					)
        model.to(snake_case_					)
        model.eval()
        __UpperCAmelCase			   =     model(snake_case_					)
        self.parent.assertEqual(
            result.logits.shape       , (self.batch_size, self.num_channels, self.image_size, self.image_size)					)

        # test greyscale images
        __UpperCAmelCase			   =     1
        __UpperCAmelCase			   =     SwinForMaskedImageModeling(snake_case_					)
        model.to(snake_case_					)
        model.eval()

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


    def        lowerCAmelCase_  (self       , lowercase__       , lowercase__       , lowercase__					)       -> List[str]:
        __UpperCAmelCase			   =     self.type_sequence_label_size
        __UpperCAmelCase			   =     SwinForImageClassification(snake_case_					)
        model.to(snake_case_					)
        model.eval()
        __UpperCAmelCase			   =     model(snake_case_       , labels=snake_case_					)
        self.parent.assertEqual(result.logits.shape       , (self.batch_size, self.type_sequence_label_size)					)

        # test greyscale images
        __UpperCAmelCase			   =     1
        __UpperCAmelCase			   =     SwinForImageClassification(snake_case_					)
        model.to(snake_case_					)
        model.eval()

        __UpperCAmelCase			   =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
        __UpperCAmelCase			   =     model(snake_case_					)
        self.parent.assertEqual(result.logits.shape       , (self.batch_size, self.type_sequence_label_size)					)






    def        lowerCAmelCase_  (self					)       -> List[str]:
        __UpperCAmelCase			   =     self.prepare_config_and_inputs()
        (
            __UpperCAmelCase   
        )			   =     config_and_inputs
        __UpperCAmelCase			   =     {"""pixel_values""": pixel_values}
        return config, inputs_dict






@require_torch
class    A_				( _a	,       _a	,       unittest.TestCase  ):


    '''simple docstring'''






    a__       							=    (
        (
            SwinModel,
            SwinBackbone,
            SwinForImageClassification,
            SwinForMaskedImageModeling,
        )
        if is_torch_available()
        else ()
    )
    a__       							=    (
        {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
        if is_torch_available()
        else {}
    )
    a__       							=    True

    a__       							=    False
    a__       							=    False
    a__       							=    False


    def        lowerCAmelCase_  (self					)       -> Union[str, Any]:
        __UpperCAmelCase			   =     SwinModelTester(self					)
        __UpperCAmelCase			   =     ConfigTester(self       , config_class=snake_case_       , embed_dim=37					)


    def        lowerCAmelCase_  (self					)       -> Any:
        self.create_and_test_config_common_properties()
        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        lowerCAmelCase_  (self					)       -> int:
        return


    def        lowerCAmelCase_  (self					)       -> str:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*snake_case_					)


    @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''					)
    def        lowerCAmelCase_  (self					)       -> List[Any]:
        pass


    def        lowerCAmelCase_  (self					)       -> Tuple:
        super().test_training_gradient_checkpointing()


    def        lowerCAmelCase_  (self					)       -> str:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*snake_case_					)


    def        lowerCAmelCase_  (self					)       -> Optional[int]:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*snake_case_					)


    def        lowerCAmelCase_  (self					)       -> Any:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*snake_case_					)


    @unittest.skip(reason='''Swin does not use inputs_embeds'''					)
    def        lowerCAmelCase_  (self					)       -> Union[str, Any]:
        pass


    @unittest.skip(reason='''Swin Transformer does not use feedforward chunking'''					)
    def        lowerCAmelCase_  (self					)       -> str:
        pass


    def        lowerCAmelCase_  (self					)       -> Union[str, Any]:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()

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


    def        lowerCAmelCase_  (self					)       -> int:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()

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

            __UpperCAmelCase			   =     ["""pixel_values"""]
            self.assertListEqual(arg_names[:1]       , snake_case_					)


    def        lowerCAmelCase_  (self					)       -> Optional[Any]:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()
        __UpperCAmelCase			   =     True

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

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

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

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

            # also another +1 for reshaped_hidden_states
            __UpperCAmelCase			   =     1 if model_class.__name__ == """SwinBackbone""" else 2
            self.assertEqual(out_len + added_hidden_states       , len(snake_case_					)					)

            __UpperCAmelCase			   =     outputs.attentions

            self.assertEqual(len(snake_case_					)       , snake_case_					)

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


    def        lowerCAmelCase_  (self       , lowercase__       , lowercase__       , lowercase__       , lowercase__					)       -> Dict:
        __UpperCAmelCase			   =     model_class(snake_case_					)
        model.to(snake_case_					)
        model.eval()

        with torch.no_grad():
            __UpperCAmelCase			   =     model(**self._prepare_for_class(snake_case_       , snake_case_					)					)

        __UpperCAmelCase			   =     outputs.hidden_states

        __UpperCAmelCase			   =     getattr(
            self.model_tester       , '''expected_num_hidden_layers'''       , len(self.model_tester.depths					) + 1					)
        self.assertEqual(len(snake_case_					)       , snake_case_					)

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

        __UpperCAmelCase			   =     (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]       , )

        if not model_class.__name__ == "SwinBackbone":
            __UpperCAmelCase			   =     outputs.reshaped_hidden_states
            self.assertEqual(len(snake_case_					)       , snake_case_					)

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


    def        lowerCAmelCase_  (self					)       -> Tuple:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()

        __UpperCAmelCase			   =     (
            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:
            __UpperCAmelCase			   =     True
            self.check_hidden_states_output(snake_case_       , snake_case_       , snake_case_       , snake_case_					)

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

            self.check_hidden_states_output(snake_case_       , snake_case_       , snake_case_       , snake_case_					)


    def        lowerCAmelCase_  (self					)       -> List[str]:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()
        __UpperCAmelCase			   =     3

        __UpperCAmelCase			   =     (
            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)
        )
        __UpperCAmelCase			   =     (
            config.patch_size
            if isinstance(config.patch_size       , collections.abc.Iterable					)
            else (config.patch_size, config.patch_size)
        )

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

        for model_class in self.all_model_classes:
            __UpperCAmelCase			   =     True
            self.check_hidden_states_output(snake_case_       , snake_case_       , snake_case_       , (padded_height, padded_width)					)

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


    @slow
    def        lowerCAmelCase_  (self					)       -> Optional[Any]:
        for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __UpperCAmelCase			   =     SwinModel.from_pretrained(snake_case_					)
            self.assertIsNotNone(snake_case_					)






    def        lowerCAmelCase_  (self					)       -> List[Any]:
        __UpperCAmelCase			   =     self.model_tester.prepare_config_and_inputs_for_common()

        __UpperCAmelCase			   =     _config_zero_init(snake_case_					)
        for model_class in self.all_model_classes:
            __UpperCAmelCase			   =     model_class(config=snake_case_					)
            for name, param in model.named_parameters():
                if "embeddings" 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    A_				( unittest.TestCase  ):


    '''simple docstring'''






    @cached_property
    def        lowerCAmelCase_  (self					)       -> str:
        return (
            AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''					)
            if is_vision_available()
            else None
        )






    @slow
    def        lowerCAmelCase_  (self					)       -> Tuple:
        __UpperCAmelCase			   =     SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''					).to(snake_case_					)
        __UpperCAmelCase			   =     self.default_image_processor

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

        # forward pass
        with torch.no_grad():
            __UpperCAmelCase			   =     model(**snake_case_					)

        # verify the logits
        __UpperCAmelCase			   =     torch.Size((1, 1_000)					)
        self.assertEqual(outputs.logits.shape       , snake_case_					)
        __UpperCAmelCase			   =     torch.tensor([-0.0948, -0.6454, -0.0921]					).to(snake_case_					)
        self.assertTrue(torch.allclose(outputs.logits[0, :3]       , snake_case_       , atol=1E-4					)					)






@require_torch
class    A_				( unittest.TestCase	,       _a  ):


    '''simple docstring'''






    a__       							=    (SwinBackbone,) if is_torch_available() else ()
    a__       							=    SwinConfig


    def        lowerCAmelCase_  (self					)       -> Optional[int]:
        __UpperCAmelCase			   =     SwinModelTester(self					)








from __future__ import annotations


def  __a    (				SCREAMING_SNAKE_CASE ) ->       list[int]:






    '''simple docstring'''
    if not list_of_ints:
        return []

    if min(SCREAMING_SNAKE_CASE ) < 0:
        raise ValueError('''All numbers must be positive''' )

    __UpperCAmelCase			   =     max(len(bin(SCREAMING_SNAKE_CASE )[2:] ) for x in list_of_ints )
    return _msd_radix_sort(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE )


def  __a    (				SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE ) ->       list[int]:






    '''simple docstring'''
    if bit_position == 0 or len(SCREAMING_SNAKE_CASE ) in [0, 1]:
        return list_of_ints

    __UpperCAmelCase			   =     []
    __UpperCAmelCase			   =     []
    # Split numbers based on bit at bit_position from the right
    for number in list_of_ints:
        if (number >> (bit_position - 1)) & 1:
            # number has a one at bit bit_position
            ones.append(SCREAMING_SNAKE_CASE )
        else:
            # number has a zero at bit bit_position
            zeros.append(SCREAMING_SNAKE_CASE )

    # recursively split both lists further
    __UpperCAmelCase			   =     _msd_radix_sort(SCREAMING_SNAKE_CASE    ,				bit_position - 1 )
    __UpperCAmelCase			   =     _msd_radix_sort(SCREAMING_SNAKE_CASE    ,				bit_position - 1 )

    # recombine lists
    __UpperCAmelCase			   =     zeros
    res.extend(SCREAMING_SNAKE_CASE )

    return res


def  __a    (				SCREAMING_SNAKE_CASE ) ->       Optional[int]:






    '''simple docstring'''
    __UpperCAmelCase			   =     len(SCREAMING_SNAKE_CASE )
    if not list_of_ints or length == 1:
        return

    if min(SCREAMING_SNAKE_CASE ) < 0:
        raise ValueError('''All numbers must be positive''' )

    __UpperCAmelCase			   =     max(len(bin(SCREAMING_SNAKE_CASE )[2:] ) for x in list_of_ints )
    _msd_radix_sort_inplace(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				0    ,				SCREAMING_SNAKE_CASE )


def  __a    (				SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE ) ->       int:






    '''simple docstring'''
    if bit_position == 0 or end_index - begin_index <= 1:
        return

    bit_position -= 1

    __UpperCAmelCase			   =     begin_index
    __UpperCAmelCase			   =     end_index - 1
    while i <= j:
        __UpperCAmelCase			   =     False
        if not (list_of_ints[i] >> bit_position) & 1:
            # found zero at the beginning
            i += 1
            __UpperCAmelCase			   =     True
        if (list_of_ints[j] >> bit_position) & 1:
            # found one at the end
            j -= 1
            __UpperCAmelCase			   =     True

        if changed:
            continue

        __UpperCAmelCase   ,       __UpperCAmelCase			   =     list_of_ints[j], list_of_ints[i]
        j -= 1
        if j != i:
            i += 1

    _msd_radix_sort_inplace(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE )
    _msd_radix_sort_inplace(SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE    ,				SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
       import doctest

       doctest.testmod()




