





import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel

   if is_vision_available():
      from transformers import MaskFormerImageProcessor

if is_vision_available():
   from PIL import Image




class 			__UpperCamelCase    :





     def __init__(     self				,							_UpperCamelCase				,							_UpperCamelCase=2				,							_UpperCamelCase=True				,							_UpperCamelCase=False				,							_UpperCamelCase=10				,							_UpperCamelCase=3				,							_UpperCamelCase=32 * 4				,							_UpperCamelCase=32 * 6				,							_UpperCamelCase=4				,							_UpperCamelCase=32				,							):
        _UpperCAmelCase           =   parent
        _UpperCAmelCase           =   batch_size
        _UpperCAmelCase           =   is_training
        _UpperCAmelCase           =   use_auxiliary_loss
        _UpperCAmelCase           =   num_queries
        _UpperCAmelCase           =   num_channels
        _UpperCAmelCase           =   min_size
        _UpperCAmelCase           =   max_size
        _UpperCAmelCase           =   num_labels
        _UpperCAmelCase           =   mask_feature_size





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]					).to(
            _UpperCamelCase					)

        _UpperCAmelCase           =   torch.ones([self.batch_size, self.min_size, self.max_size]				,							device=_UpperCamelCase					)

        _UpperCAmelCase           =   (
            torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]				,							device=_UpperCamelCase					) > 0.5
        ).float()
        _UpperCAmelCase           =   (torch.rand((self.batch_size, self.num_labels)				,							device=_UpperCamelCase					) > 0.5).long()

        _UpperCAmelCase           =   self.get_config()
        return config, pixel_values, pixel_mask, mask_labels, class_labels





     def 		UpperCamelCase(     self					):
        return MaskFormerConfig.from_backbone_and_decoder_configs(
            backbone_config=SwinConfig(
                depths=[1, 1, 1, 1]				,							)				,							decoder_config=DetrConfig(
                decoder_ffn_dim=128				,							num_queries=self.num_queries				,							decoder_attention_heads=2				,							d_model=self.mask_feature_size				,							)				,							mask_feature_size=self.mask_feature_size				,							fpn_feature_size=self.mask_feature_size				,							num_channels=self.num_channels				,							num_labels=self.num_labels				,							)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase           =   self.prepare_config_and_inputs()
        _UpperCAmelCase           =   {'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
        return config, inputs_dict





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   output.encoder_hidden_states
        _UpperCAmelCase           =   output.pixel_decoder_hidden_states
        _UpperCAmelCase           =   output.transformer_decoder_hidden_states

        self.parent.assertTrue(len(_UpperCamelCase					)				,							len(config.backbone_config.depths					)					)
        self.parent.assertTrue(len(_UpperCamelCase					)				,							len(config.backbone_config.depths					)					)
        self.parent.assertTrue(len(_UpperCamelCase					)				,							config.decoder_config.decoder_layers					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase=False					):
        with torch.no_grad():
           _UpperCAmelCase           =   MaskFormerModel(config=_UpperCamelCase					)
           model.to(_UpperCamelCase					)
           model.eval()

           _UpperCAmelCase           =   model(pixel_values=_UpperCamelCase				,							pixel_mask=_UpperCamelCase					)
           _UpperCAmelCase           =   model(_UpperCamelCase				,							output_hidden_states=_UpperCamelCase					)
        # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the
        # encoder and pixel decoder
        self.parent.assertEqual(
            output.transformer_decoder_last_hidden_state.shape				,							(self.batch_size, self.num_queries, self.mask_feature_size)				,							)
        # let's ensure the other two hidden state exists
        self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None					)
        self.parent.assertTrue(output.encoder_last_hidden_state is not None					)

        if output_hidden_states:
           self.check_output_hidden_state(_UpperCamelCase				,							_UpperCamelCase					)





     def 		UpperCamelCase(     self				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   MaskFormerForInstanceSegmentation(config=_UpperCamelCase					)
        model.to(_UpperCamelCase					)
        model.eval()

        def comm_check_on_output(_UpperCamelCase					):
           # let's still check that all the required stuff is there
           self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None					)
           self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None					)
           self.parent.assertTrue(result.encoder_last_hidden_state is not None					)
           # okay, now we need to check the logits shape
           # due to the encoder compression, masks have a //4 spatial size
           self.parent.assertEqual(
               result.masks_queries_logits.shape				,							(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)				,							)
           # + 1 for null class
           self.parent.assertEqual(
               result.class_queries_logits.shape				,							(self.batch_size, self.num_queries, self.num_labels + 1)					)

        with torch.no_grad():
           _UpperCAmelCase           =   model(pixel_values=_UpperCamelCase				,							pixel_mask=_UpperCamelCase					)
           _UpperCAmelCase           =   model(_UpperCamelCase					)

           comm_check_on_output(_UpperCamelCase					)

           _UpperCAmelCase           =   model(
               pixel_values=_UpperCamelCase				,							pixel_mask=_UpperCamelCase				,							mask_labels=_UpperCamelCase				,							class_labels=_UpperCamelCase					)

        comm_check_on_output(_UpperCamelCase					)

        self.parent.assertTrue(result.loss is not None					)
        self.parent.assertEqual(result.loss.shape				,							torch.Size([1]					)					)




@require_torch
class 			__UpperCamelCase    (							A__	, A__	, unittest.TestCase    ):
     __A	:  int							  =   (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
     __A	:  int							  =   (
         {"""feature-extraction""": MaskFormerModel, """image-segmentation""": MaskFormerForInstanceSegmentation}
         if is_torch_available()
         else {}
     )

     __A	:  List[str]							  =   False
     __A	:  Optional[Any]							  =   False
     __A	:  Union[str, Any]							  =   False
     __A	:  Optional[Any]							  =   False





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   MaskFormerModelTester(self					)
        _UpperCAmelCase           =   ConfigTester(self				,							config_class=_UpperCamelCase				,							has_text_modality=_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        self.config_tester.run_common_tests()





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.create_and_check_maskformer_model(_UpperCamelCase				,							**_UpperCamelCase				,							output_hidden_states=_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*_UpperCamelCase					)





     @unittest.skip(reason='''MaskFormer does not use inputs_embeds'''					)
     def 		UpperCamelCase(     self					):
        pass





     @unittest.skip(reason='''MaskFormer does not have a get_input_embeddings method'''					)
     def 		UpperCamelCase(     self					):
        pass





     @unittest.skip(reason='''MaskFormer is not a generative model'''					)
     def 		UpperCamelCase(     self					):
        pass





     @unittest.skip(reason='''MaskFormer does not use token embeddings'''					)
     def 		UpperCamelCase(     self					):
        pass





     @require_torch_multi_gpu
     @unittest.skip(
         reason='''MaskFormer has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''					)
     def 		UpperCamelCase(     self					):
        pass





     @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''					)
     def 		UpperCamelCase(     self					):
        pass





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           _UpperCAmelCase           =   model_class(_UpperCamelCase					)
           _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]				,							_UpperCamelCase					)





     @slow
     def 		UpperCamelCase(     self					):
        for model_name in ["facebook/maskformer-swin-small-coco"]:
           _UpperCAmelCase           =   MaskFormerModel.from_pretrained(_UpperCamelCase					)
           self.assertIsNotNone(_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   (self.model_tester.min_size,) * 2
        _UpperCAmelCase           =   {
            '''pixel_values''': torch.randn((2, 3, *size)				,							device=_UpperCamelCase					),
            '''mask_labels''': torch.randn((2, 10, *size)				,							device=_UpperCamelCase					),
            '''class_labels''': torch.zeros(2				,							10				,							device=_UpperCamelCase					).long(),
        }

        _UpperCAmelCase           =   MaskFormerForInstanceSegmentation(MaskFormerConfig()					).to(_UpperCamelCase					)
        _UpperCAmelCase           =   model(**_UpperCamelCase					)
        self.assertTrue(outputs.loss is not None					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.create_and_check_maskformer_model(_UpperCamelCase				,							**_UpperCamelCase				,							output_hidden_states=_UpperCamelCase					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
           _UpperCAmelCase           =   model_class(_UpperCamelCase					).to(_UpperCamelCase					)
           _UpperCAmelCase           =   model(**_UpperCamelCase				,							output_attentions=_UpperCamelCase					)
           self.assertTrue(outputs.attentions is not None					)





     def 		UpperCamelCase(     self					):
        if not self.model_tester.is_training:
           return
        # only MaskFormerForInstanceSegmentation has the loss
        _UpperCAmelCase           =   self.all_model_classes[1]
        _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()

        _UpperCAmelCase           =   model_class(_UpperCamelCase					)
        model.to(_UpperCamelCase					)
        model.train()

        _UpperCAmelCase           =   model(_UpperCamelCase				,							mask_labels=_UpperCamelCase				,							class_labels=_UpperCamelCase					).loss
        loss.backward()





     def 		UpperCamelCase(     self					):
        # only MaskFormerForInstanceSegmentation has the loss
        _UpperCAmelCase           =   self.all_model_classes[1]
        _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase       ,      _UpperCAmelCase           =   self.model_tester.prepare_config_and_inputs()
        _UpperCAmelCase           =   True
        _UpperCAmelCase           =   True

        _UpperCAmelCase           =   model_class(_UpperCamelCase					)
        model.to(_UpperCamelCase					)
        model.train()

        _UpperCAmelCase           =   model(_UpperCamelCase				,							mask_labels=_UpperCamelCase				,							class_labels=_UpperCamelCase					)

        _UpperCAmelCase           =   outputs.encoder_hidden_states[0]
        encoder_hidden_states.retain_grad()

        _UpperCAmelCase           =   outputs.pixel_decoder_hidden_states[0]
        pixel_decoder_hidden_states.retain_grad()
        # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't
        _UpperCAmelCase           =   outputs.transformer_decoder_hidden_states[0]
        transformer_decoder_hidden_states.retain_grad()

        _UpperCAmelCase           =   outputs.attentions[0]
        attentions.retain_grad()

        outputs.loss.backward(retain_graph=_UpperCamelCase					)

        self.assertIsNotNone(encoder_hidden_states.grad					)
        self.assertIsNotNone(pixel_decoder_hidden_states.grad					)
        self.assertIsNotNone(transformer_decoder_hidden_states.grad					)
        self.assertIsNotNone(attentions.grad					)




UpperCAmelCase_           =	1e-4
def      A__       (    )  ->  Dict:






   """simple docstring"""







   _UpperCAmelCase           =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''						)
   return image




@require_vision
@slow
class 			__UpperCamelCase    (							unittest.TestCase    ):





     @cached_property
     def 		UpperCamelCase(     self					):
        return (
            MaskFormerImageProcessor.from_pretrained('''facebook/maskformer-swin-small-coco'''					)
            if is_vision_available()
            else None
        )





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   MaskFormerModel.from_pretrained('''facebook/maskformer-swin-small-coco'''					).to(_UpperCamelCase					)
        _UpperCAmelCase           =   self.default_image_processor
        _UpperCAmelCase           =   prepare_img()
        _UpperCAmelCase           =   image_processor(_UpperCamelCase				,							return_tensors='''pt'''					).to(_UpperCamelCase					)
        _UpperCAmelCase           =   inputs['''pixel_values'''].shape
        # check size is divisible by 32
        self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0					)
        # check size
        self.assertEqual(_UpperCamelCase				,							(1, 3, 800, 1088)					)

        with torch.no_grad():
           _UpperCAmelCase           =   model(**_UpperCamelCase					)

        _UpperCAmelCase           =   torch.tensor(
            [[-0.0482, 0.9228, 0.4951], [-0.2547, 0.8017, 0.8527], [-0.0069, 0.3385, -0.0089]]					).to(_UpperCamelCase					)
        self.assertTrue(
            torch.allclose(
                outputs.encoder_last_hidden_state[0, 0, :3, :3]				,							_UpperCamelCase				,							atol=_UpperCamelCase					)					)

        _UpperCAmelCase           =   torch.tensor(
            [[-0.8422, -0.8434, -0.9718], [-1.0144, -0.5565, -0.4195], [-1.0038, -0.4484, -0.1961]]					).to(_UpperCamelCase					)
        self.assertTrue(
            torch.allclose(
                outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]				,							_UpperCamelCase				,							atol=_UpperCamelCase					)					)

        _UpperCAmelCase           =   torch.tensor(
            [[0.2852, -0.0159, 0.9735], [0.6254, 0.1858, 0.8529], [-0.0680, -0.4116, 1.8413]]					).to(_UpperCamelCase					)
        self.assertTrue(
            torch.allclose(
                outputs.transformer_decoder_last_hidden_state[0, :3, :3]				,							_UpperCamelCase				,							atol=_UpperCamelCase					)					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   (
            MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco'''					)
            .to(_UpperCamelCase					)
            .eval()
        )
        _UpperCAmelCase           =   self.default_image_processor
        _UpperCAmelCase           =   prepare_img()
        _UpperCAmelCase           =   image_processor(_UpperCamelCase				,							return_tensors='''pt'''					).to(_UpperCamelCase					)
        _UpperCAmelCase           =   inputs['''pixel_values'''].shape
        # check size is divisible by 32
        self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0					)
        # check size
        self.assertEqual(_UpperCamelCase				,							(1, 3, 800, 1088)					)

        with torch.no_grad():
           _UpperCAmelCase           =   model(**_UpperCamelCase					)
        # masks_queries_logits
        _UpperCAmelCase           =   outputs.masks_queries_logits
        self.assertEqual(
            masks_queries_logits.shape				,							(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)				,							)
        _UpperCAmelCase           =   [
            [-1.3737124, -1.7724937, -1.9364233],
            [-1.5977281, -1.9867939, -2.1523695],
            [-1.5795398, -1.9269832, -2.093942],
        ]
        _UpperCAmelCase           =   torch.tensor(_UpperCamelCase					).to(_UpperCamelCase					)
        self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]				,							_UpperCamelCase				,							atol=_UpperCamelCase					)					)
        # class_queries_logits
        _UpperCAmelCase           =   outputs.class_queries_logits
        self.assertEqual(
            class_queries_logits.shape				,							(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)					)
        _UpperCAmelCase           =   torch.tensor(
            [
                [1.6512e00, -5.2572e00, -3.3519e00],
                [3.6169e-02, -5.9025e00, -2.9313e00],
                [1.0766e-04, -7.7630e00, -5.1263e00],
            ]					).to(_UpperCamelCase					)
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]				,							_UpperCamelCase				,							atol=_UpperCamelCase					)					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   (
            MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-resnet101-coco-stuff'''					)
            .to(_UpperCamelCase					)
            .eval()
        )
        _UpperCAmelCase           =   self.default_image_processor
        _UpperCAmelCase           =   prepare_img()
        _UpperCAmelCase           =   image_processor(_UpperCamelCase				,							return_tensors='''pt'''					).to(_UpperCamelCase					)
        _UpperCAmelCase           =   inputs['''pixel_values'''].shape
        # check size is divisible by 32
        self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0					)
        # check size
        self.assertEqual(_UpperCamelCase				,							(1, 3, 800, 1088)					)

        with torch.no_grad():
           _UpperCAmelCase           =   model(**_UpperCamelCase					)
        # masks_queries_logits
        _UpperCAmelCase           =   outputs.masks_queries_logits
        self.assertEqual(
            masks_queries_logits.shape				,							(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)				,							)
        _UpperCAmelCase           =   [[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
        _UpperCAmelCase           =   torch.tensor(_UpperCamelCase					).to(_UpperCamelCase					)
        self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]				,							_UpperCamelCase				,							atol=_UpperCamelCase					)					)
        # class_queries_logits
        _UpperCAmelCase           =   outputs.class_queries_logits
        self.assertEqual(
            class_queries_logits.shape				,							(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)					)
        _UpperCAmelCase           =   torch.tensor(
            [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]]					).to(_UpperCamelCase					)
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]				,							_UpperCamelCase				,							atol=_UpperCamelCase					)					)





     def 		UpperCamelCase(     self					):
        _UpperCAmelCase           =   (
            MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco'''					)
            .to(_UpperCamelCase					)
            .eval()
        )
        _UpperCAmelCase           =   self.default_image_processor

        _UpperCAmelCase           =   image_processor(
            [np.zeros((3, 800, 1333)					), np.zeros((3, 800, 1333)					)]				,							segmentation_maps=[np.zeros((384, 384)					).astype(np.floataa					), np.zeros((384, 384)					).astype(np.floataa					)]				,							return_tensors='''pt'''				,							)

        _UpperCAmelCase           =   inputs['''pixel_values'''].to(_UpperCamelCase					)
        _UpperCAmelCase           =   [el.to(_UpperCamelCase					) for el in inputs['''mask_labels''']]
        _UpperCAmelCase           =   [el.to(_UpperCamelCase					) for el in inputs['''class_labels''']]

        with torch.no_grad():
           _UpperCAmelCase           =   model(**_UpperCamelCase					)

        self.assertTrue(outputs.loss is not None					)






from typing import List

from .keymap import KEYMAP, get_character
def      A__       (    SCREAMING_SNAKE_CASE_   :      str						)  ->  List[str]:






   """simple docstring"""







   def decorator(SCREAMING_SNAKE_CASE_   :      List[Any]						):
      _UpperCAmelCase           =   getattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	[]						)
      handle += [key]
      setattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	SCREAMING_SNAKE_CASE_						)
      return func

   return decorator
def      A__       (    *SCREAMING_SNAKE_CASE_   :      List[str]						)  ->  Dict:






   """simple docstring"""







   def decorator(SCREAMING_SNAKE_CASE_   :      Any						):
      _UpperCAmelCase           =   getattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	[]						)
      handle += keys
      setattr(SCREAMING_SNAKE_CASE_				,	'''handle_key'''				,	SCREAMING_SNAKE_CASE_						)
      return func

   return decorator




class 			__UpperCamelCase    (							A__    ):





     def __new__(     cls				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					):
        _UpperCAmelCase           =   super().__new__(cls				,							_UpperCamelCase				,							_UpperCamelCase				,							_UpperCamelCase					)
        if not hasattr(_UpperCamelCase				,							'''key_handler'''					):
           setattr(_UpperCamelCase				,							'''key_handler'''				,							{}					)
        setattr(_UpperCamelCase				,							'''handle_input'''				,							KeyHandler.handle_input					)

        for value in attrs.values():
           _UpperCAmelCase           =   getattr(_UpperCamelCase				,							'''handle_key'''				,							[]					)
           for key in handled_keys:
              _UpperCAmelCase           =   value
        return new_cls





     @staticmethod
     def 		UpperCamelCase(     cls					):
        _UpperCAmelCase           =   get_character()
        if char != KEYMAP["undefined"]:
           _UpperCAmelCase           =   ord(_UpperCamelCase					)
        _UpperCAmelCase           =   cls.key_handler.get(_UpperCamelCase					)
        if handler:
           _UpperCAmelCase           =   char
           return handler(cls					)
        else:
           return None




def      A__       (    cls   :      Union[str, Any]						)  ->  Any:






   """simple docstring"""







   return KeyHandler(cls.__name__				,	cls.__bases__				,	cls.__dict__.copy()						)