





"""simple docstring"""



import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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 (
           MODEL_MAPPING,
           BeitForImageClassification,
           BeitForMaskedImageModeling,
           BeitForSemanticSegmentation,
           BeitModel,
       )
       from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       import PIL
       from PIL import Image

       from transformers import BeitImageProcessor






class 						__snake_case   :





 """simple docstring"""


 def __init__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase=100   ,		__lowerCamelCase=13   ,		__lowerCamelCase=30   ,		__lowerCamelCase=2   ,		__lowerCamelCase=3   ,		__lowerCamelCase=True   ,		__lowerCamelCase=True   ,		__lowerCamelCase=32   ,		__lowerCamelCase=4   ,		__lowerCamelCase=4   ,		__lowerCamelCase=37   ,		__lowerCamelCase="gelu"   ,		__lowerCamelCase=0.1   ,		__lowerCamelCase=0.1   ,		__lowerCamelCase=10   ,		__lowerCamelCase=0.0_2   ,		__lowerCamelCase=3   ,		__lowerCamelCase=None   ,		__lowerCamelCase=[0, 1, 2, 3]   ,		):



     '''simple docstring'''




     __A       :		Tuple							=	parent
     __A       :		Optional[Any]							=	100
     __A       :		Dict							=	batch_size
     __A       :		int							=	image_size
     __A       :		List[str]							=	patch_size
     __A       :		Tuple							=	num_channels
     __A       :		str							=	is_training
     __A       :		List[Any]							=	use_labels
     __A       :		Any							=	hidden_size
     __A       :		List[Any]							=	num_hidden_layers
     __A       :		List[str]							=	num_attention_heads
     __A       :		Optional[int]							=	intermediate_size
     __A       :		str							=	hidden_act
     __A       :		List[str]							=	hidden_dropout_prob
     __A       :		Union[str, Any]							=	attention_probs_dropout_prob
     __A       :		Optional[int]							=	type_sequence_label_size
     __A       :		Any							=	initializer_range
     __A       :		Dict							=	scope
     __A       :		Union[str, Any]							=	out_indices
     __A       :		List[str]							=	num_labels

     # in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
     __A       :		Optional[Any]							=	(image_size // patch_size) ** 2
     __A       :		int							=	num_patches + 1

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		str							=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

     __A       :		Optional[int]							=	None
     __A       :		str							=	None
     if self.use_labels:
         __A       :		List[Any]							=	ids_tensor([self.batch_size]   ,		self.type_sequence_label_size    )
         __A       :		int							=	ids_tensor([self.batch_size, self.image_size, self.image_size]   ,		self.num_labels    )

     __A       :		List[Any]							=	self.get_config()

     return config, pixel_values, labels, pixel_labels

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return BeitConfig(
         vocab_size=self.vocab_size   ,		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   ,		hidden_act=self.hidden_act   ,		hidden_dropout_prob=self.hidden_dropout_prob   ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,		is_decoder=__lowerCamelCase   ,		initializer_range=self.initializer_range   ,		out_indices=self.out_indices   ,		)

 def    UpperCamelCase__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase    ):



     '''simple docstring'''




     __A       :		Union[str, Any]							=	BeitModel(config=__lowerCamelCase    )
     model.to(__lowerCamelCase    )
     model.eval()
     __A       :		Any							=	model(__lowerCamelCase    )
     self.parent.assertEqual(result.last_hidden_state.shape   ,		(self.batch_size, self.seq_length, self.hidden_size)    )

 def    UpperCamelCase__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase    ):



     '''simple docstring'''




     __A       :		Any							=	BeitForMaskedImageModeling(config=__lowerCamelCase    )
     model.to(__lowerCamelCase    )
     model.eval()
     __A       :		Dict							=	model(__lowerCamelCase    )
     self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.seq_length - 1, self.vocab_size)    )

 def    UpperCamelCase__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase    ):



     '''simple docstring'''




     __A       :		Tuple							=	self.type_sequence_label_size
     __A       :		Tuple							=	BeitForImageClassification(__lowerCamelCase    )
     model.to(__lowerCamelCase    )
     model.eval()
     __A       :		Optional[Any]							=	model(__lowerCamelCase   ,		labels=__lowerCamelCase    )
     self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.type_sequence_label_size)    )

     # test greyscale images
     __A       :		Any							=	1
     __A       :		Dict							=	BeitForImageClassification(__lowerCamelCase    )
     model.to(__lowerCamelCase    )
     model.eval()

     __A       :		List[Any]							=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
     __A       :		Optional[int]							=	model(__lowerCamelCase   ,		labels=__lowerCamelCase    )
     self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.type_sequence_label_size)    )

 def    UpperCamelCase__(       self   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase   ,		__lowerCamelCase    ):



     '''simple docstring'''




     __A       :		Union[str, Any]							=	self.num_labels
     __A       :		str							=	BeitForSemanticSegmentation(__lowerCamelCase    )
     model.to(__lowerCamelCase    )
     model.eval()
     __A       :		str							=	model(__lowerCamelCase    )
     self.parent.assertEqual(
         result.logits.shape   ,		(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)    )
     __A       :		str							=	model(__lowerCamelCase   ,		labels=__lowerCamelCase    )
     self.parent.assertEqual(
         result.logits.shape   ,		(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)    )







 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Dict							=	self.prepare_config_and_inputs()
     __A					,			__A					,			__A					,			__A       :		Any							=	config_and_inputs
     __A       :		Union[str, Any]							=	{'''pixel_values''': pixel_values}
     return config, inputs_dict






@require_torch
class 						__snake_case   (						SCREAMING_SNAKE_CASE__				,				SCREAMING_SNAKE_CASE__				,				unittest.TestCase	):





 """simple docstring"""


 _lowerCamelCase								=	(
     (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
     if is_torch_available()
     else ()
 )
 _lowerCamelCase								=	(
     {
         """feature-extraction""": BeitModel,
         """image-classification""": BeitForImageClassification,
         """image-segmentation""": BeitForSemanticSegmentation,
     }
     if is_torch_available()
     else {}
 )

 _lowerCamelCase								=	False
 _lowerCamelCase								=	False
 _lowerCamelCase								=	False

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		str							=	BeitModelTester(self    )
     __A       :		Optional[int]							=	ConfigTester(self   ,		config_class=__lowerCamelCase   ,		has_text_modality=__lowerCamelCase   ,		hidden_size=37    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     self.config_tester.run_common_tests()

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



     '''simple docstring'''




     pass

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



     '''simple docstring'''




     pass

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A					,			__A       :		Optional[int]							=	self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         __A       :		List[str]							=	model_class(__lowerCamelCase    )
         self.assertIsInstance(model.get_input_embeddings()   ,		(nn.Module)    )
         __A       :		Tuple							=	model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(__lowerCamelCase   ,		nn.Linear    )    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A					,			__A       :		Optional[int]							=	self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         __A       :		Union[str, Any]							=	model_class(__lowerCamelCase    )
         __A       :		str							=	inspect.signature(model.forward    )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         __A       :		List[str]							=	[*signature.parameters.keys()]

         __A       :		Tuple							=	['''pixel_values''']
         self.assertListEqual(arg_names[:1]   ,		__lowerCamelCase    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Any							=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*__lowerCamelCase    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		str							=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Optional[Any]							=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Tuple							=	self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_semantic_segmentation(*__lowerCamelCase    )

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     if not self.model_tester.is_training:
         return

     __A					,			__A       :		List[str]							=	self.model_tester.prepare_config_and_inputs_for_common()
     __A       :		str							=	True

     for model_class in self.all_model_classes:
         # we don't test BeitForMaskedImageModeling
         if model_class in [*get_values(__lowerCamelCase    ), BeitForMaskedImageModeling]:
             continue

         __A       :		Optional[Any]							=	model_class(__lowerCamelCase    )
         model.to(__lowerCamelCase    )
         model.train()
         __A       :		Optional[Any]							=	self._prepare_for_class(__lowerCamelCase   ,		__lowerCamelCase   ,		return_labels=__lowerCamelCase    )
         __A       :		Dict							=	model(**__lowerCamelCase    ).loss
         loss.backward()

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A					,			__A       :		List[str]							=	self.model_tester.prepare_config_and_inputs_for_common()
     if not self.model_tester.is_training:
         return

     __A       :		Optional[int]							=	False
     __A       :		Union[str, Any]							=	True

     for model_class in self.all_model_classes:
         # we don't test BeitForMaskedImageModeling
         if (
             model_class in [*get_values(__lowerCamelCase    ), BeitForMaskedImageModeling]
             or not model_class.supports_gradient_checkpointing
         ):
             continue

         __A       :		Any							=	model_class(__lowerCamelCase    )
         model.gradient_checkpointing_enable()
         model.to(__lowerCamelCase    )
         model.train()
         __A       :		str							=	self._prepare_for_class(__lowerCamelCase   ,		__lowerCamelCase   ,		return_labels=__lowerCamelCase    )
         __A       :		Any							=	model(**__lowerCamelCase    ).loss
         loss.backward()

 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A					,			__A       :		int							=	self.model_tester.prepare_config_and_inputs_for_common()

     __A       :		List[Any]							=	_config_zero_init(__lowerCamelCase    )
     for model_class in self.all_model_classes:
         __A       :		Any							=	model_class(config=__lowerCamelCase    )
         for name, param in model.named_parameters():
             # we skip lambda parameters as these require special initial values
             # determined by config.layer_scale_init_value
             if "lambda" in name:
                 continue
             if 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"""   ,		)







 @slow
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __A       :		int							=	BeitModel.from_pretrained(__lowerCamelCase    )
         self.assertIsNotNone(__lowerCamelCase    )







def 						__lowercase	(  )  ->List[str]:



    '''simple docstring'''







    __A       :		Union[str, Any]							=	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
    return image






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





 """simple docstring"""


 @cached_property
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     return BeitImageProcessor.from_pretrained('''microsoft/beit-base-patch16-224'''    ) if is_vision_available() else None

 @slow
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		int							=	BeitForMaskedImageModeling.from_pretrained('''microsoft/beit-base-patch16-224-pt22k'''    ).to(__lowerCamelCase    )

     __A       :		List[Any]							=	self.default_image_processor
     __A       :		int							=	prepare_img()
     __A       :		Union[str, Any]							=	image_processor(images=__lowerCamelCase   ,		return_tensors='''pt'''    ).pixel_values.to(__lowerCamelCase    )

     # prepare bool_masked_pos
     __A       :		int							=	torch.ones((1, 196)   ,		dtype=torch.bool    ).to(__lowerCamelCase    )

     # forward pass
     with torch.no_grad():
         __A       :		List[str]							=	model(pixel_values=__lowerCamelCase   ,		bool_masked_pos=__lowerCamelCase    )
     __A       :		Union[str, Any]							=	outputs.logits

     # verify the logits
     __A       :		List[Any]							=	torch.Size((1, 196, 8192)    )
     self.assertEqual(logits.shape   ,		__lowerCamelCase    )

     __A       :		Tuple							=	torch.tensor(
         [[-3.2_4_3_7, 0.5_0_7_2, -1_3.9_1_7_4], [-3.2_4_5_6, 0.4_9_4_8, -1_3.9_4_0_1], [-3.2_0_3_3, 0.5_1_2_1, -1_3.8_5_5_0]]    ).to(__lowerCamelCase    )

     self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]   ,		__lowerCamelCase   ,		atol=1e-2    )    )

 @slow
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Optional[int]							=	BeitForImageClassification.from_pretrained('''microsoft/beit-base-patch16-224'''    ).to(__lowerCamelCase    )

     __A       :		Dict							=	self.default_image_processor
     __A       :		Any							=	prepare_img()
     __A       :		Union[str, Any]							=	image_processor(images=__lowerCamelCase   ,		return_tensors='''pt'''    ).to(__lowerCamelCase    )

     # forward pass
     with torch.no_grad():
         __A       :		Union[str, Any]							=	model(**__lowerCamelCase    )
     __A       :		int							=	outputs.logits

     # verify the logits
     __A       :		Tuple							=	torch.Size((1, 1000)    )
     self.assertEqual(logits.shape   ,		__lowerCamelCase    )

     __A       :		str							=	torch.tensor([-1.2_3_8_5, -1.0_9_8_7, -1.0_1_0_8]    ).to(__lowerCamelCase    )

     self.assertTrue(torch.allclose(logits[0, :3]   ,		__lowerCamelCase   ,		atol=1e-4    )    )

     __A       :		List[Any]							=	281
     self.assertEqual(logits.argmax(-1    ).item()   ,		__lowerCamelCase    )

 @slow
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Dict							=	BeitForImageClassification.from_pretrained('''microsoft/beit-large-patch16-224-pt22k-ft22k'''    ).to(
         __lowerCamelCase    )

     __A       :		List[Any]							=	self.default_image_processor
     __A       :		Any							=	prepare_img()
     __A       :		int							=	image_processor(images=__lowerCamelCase   ,		return_tensors='''pt'''    ).to(__lowerCamelCase    )

     # forward pass
     with torch.no_grad():
         __A       :		Optional[int]							=	model(**__lowerCamelCase    )
     __A       :		str							=	outputs.logits

     # verify the logits
     __A       :		Optional[int]							=	torch.Size((1, 2_1841)    )
     self.assertEqual(logits.shape   ,		__lowerCamelCase    )

     __A       :		str							=	torch.tensor([1.6_8_8_1, -0.2_7_8_7, 0.5_9_0_1]    ).to(__lowerCamelCase    )

     self.assertTrue(torch.allclose(logits[0, :3]   ,		__lowerCamelCase   ,		atol=1e-4    )    )

     __A       :		Optional[Any]							=	2396
     self.assertEqual(logits.argmax(-1    ).item()   ,		__lowerCamelCase    )

 @slow
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		List[str]							=	BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''    )
     __A       :		List[Any]							=	model.to(__lowerCamelCase    )

     __A       :		int							=	BeitImageProcessor(do_resize=__lowerCamelCase   ,		size=640   ,		do_center_crop=__lowerCamelCase    )

     __A       :		Optional[int]							=	load_dataset('''hf-internal-testing/fixtures_ade20k'''   ,		split='''test'''    )
     __A       :		List[str]							=	Image.open(ds[0]['''file''']    )
     __A       :		Optional[int]							=	image_processor(images=__lowerCamelCase   ,		return_tensors='''pt'''    ).to(__lowerCamelCase    )

     # forward pass
     with torch.no_grad():
         __A       :		int							=	model(**__lowerCamelCase    )
     __A       :		Tuple							=	outputs.logits

     # verify the logits
     __A       :		Tuple							=	torch.Size((1, 150, 160, 160)    )
     self.assertEqual(logits.shape   ,		__lowerCamelCase    )

     __A       :		int							=	version.parse(PIL.__version__    ) < version.parse('''9.0.0'''    )

     if is_pillow_less_than_a:
         __A       :		str							=	torch.tensor(
             [
                 [[-4.9_2_2_5, -2.3_9_5_4, -3.0_5_2_2], [-2.8_8_2_2, -1.0_0_4_6, -1.7_5_6_1], [-2.9_5_4_9, -1.3_2_2_8, -2.1_3_4_7]],
                 [[-5.8_1_6_8, -3.4_1_2_9, -4.0_7_7_8], [-3.8_6_5_1, -2.2_2_1_4, -3.0_2_7_7], [-3.8_3_5_6, -2.4_6_4_3, -3.3_5_3_5]],
                 [[-0.0_0_7_8, 3.9_9_5_2, 4.0_7_5_4], [2.9_8_5_6, 4.6_9_4_4, 5.0_0_3_5], [3.2_4_1_3, 4.7_8_1_3, 4.9_9_6_9]],
             ]   ,		device=__lowerCamelCase   ,		)
     else:
         __A       :		Optional[int]							=	torch.tensor(
             [
                 [[-4.8_9_6_0, -2.3_6_8_8, -3.0_3_5_5], [-2.8_4_7_8, -0.9_8_3_6, -1.7_4_1_8], [-2.9_4_4_9, -1.3_3_3_2, -2.1_4_5_6]],
                 [[-5.8_0_8_1, -3.4_1_2_4, -4.1_0_0_6], [-3.8_5_6_1, -2.2_0_8_1, -3.0_3_2_3], [-3.8_3_6_5, -2.4_6_0_1, -3.3_6_6_9]],
                 [[-0.0_3_0_9, 3.9_8_6_8, 4.0_5_4_0], [2.9_6_4_0, 4.6_8_7_7, 4.9_9_7_6], [3.2_0_8_1, 4.7_6_9_0, 4.9_9_4_2]],
             ]   ,		device=__lowerCamelCase   ,		)

     self.assertTrue(torch.allclose(logits[0, :3, :3, :3]   ,		__lowerCamelCase   ,		atol=1e-4    )    )







 @slow
 def    UpperCamelCase__(       self    ):



     '''simple docstring'''




     __A       :		Optional[int]							=	BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''    )
     __A       :		Any							=	model.to(__lowerCamelCase    )

     __A       :		Optional[int]							=	BeitImageProcessor(do_resize=__lowerCamelCase   ,		size=640   ,		do_center_crop=__lowerCamelCase    )

     __A       :		List[Any]							=	load_dataset('''hf-internal-testing/fixtures_ade20k'''   ,		split='''test'''    )
     __A       :		int							=	Image.open(ds[0]['''file''']    )
     __A       :		Union[str, Any]							=	image_processor(images=__lowerCamelCase   ,		return_tensors='''pt'''    ).to(__lowerCamelCase    )

     # forward pass
     with torch.no_grad():
         __A       :		str							=	model(**__lowerCamelCase    )

     __A       :		List[Any]							=	outputs.logits.detach().cpu()

     __A       :		int							=	image_processor.post_process_semantic_segmentation(outputs=__lowerCamelCase   ,		target_sizes=[(500, 300)]    )
     __A       :		Dict							=	torch.Size((500, 300)    )
     self.assertEqual(segmentation[0].shape   ,		__lowerCamelCase    )

     __A       :		List[str]							=	image_processor.post_process_semantic_segmentation(outputs=__lowerCamelCase    )
     __A       :		int							=	torch.Size((160, 160)    )
     self.assertEqual(segmentation[0].shape   ,		__lowerCamelCase    )











"""simple docstring"""



def 						__lowercase	(  snake_case_    :    str							,snake_case_    :    str		)  ->float:



    '''simple docstring'''







    def get_matched_characters(snake_case_    :    str							,snake_case_    :    str		) -> str:
        __A       :		Any							=	[]
        __A       :		Any							=	min(len(_stra		)							,len(_stra		)		) // 2
        for i, l in enumerate(_stra		):
            __A       :		Dict							=	int(max(0							,i - limit		)		)
            __A       :		Tuple							=	int(min(i + limit + 1							,len(_stra		)		)		)
            if l in _stra[left:right]:
                matched.append(snake_case_		)
                __A       :		Any							=	F"""{_stra[0:_stra.index(snake_case_		)]} {_stra[_stra.index(snake_case_		) + 1:]}"""

        return "".join(snake_case_		)

    # matching characters
    __A       :		int							=	get_matched_characters(snake_case_							,snake_case_		)
    __A       :		Tuple							=	get_matched_characters(snake_case_							,snake_case_		)
    __A       :		str							=	len(snake_case_		)

    # transposition
    __A       :		Dict							=	(
        len([(ca, ca) for ca, ca in zip(snake_case_							,snake_case_		) if ca != ca]		) // 2
    )

    if not match_count:
        __A       :		List[str]							=	0.0
    else:
        __A       :		Tuple							=	(
            1
            / 3
            * (
                match_count / len(snake_case_		)
                + match_count / len(snake_case_		)
                + (match_count - transpositions) / match_count
            )
        )

    # common prefix up to 4 characters
    __A       :		Tuple							=	0
    for ca, ca in zip(stra[:4]							,stra[:4]		):
        if ca == ca:
            prefix_len += 1
        else:
            break

    return jaro + 0.1 * prefix_len * (1 - jaro)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       print(jaro_winkler("""hello""", """world"""))




