"""simple docstring"""
import collections
import inspect
import unittest

from transformers import FocalNetConfig
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 (
					    FocalNetBackbone,
					    FocalNetForImageClassification,
					    FocalNetForMaskedImageModeling,
					    FocalNetModel,
					)
					from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor



class 					lowerCAmelCase_      :



				"""simple docstring"""

				def __init__(			self						,      lowerCAmelCase						,      lowerCAmelCase=13						,      lowerCAmelCase=32						,      lowerCAmelCase=2						,      lowerCAmelCase=3						,      lowerCAmelCase=16						,      lowerCAmelCase=[32, 64, 1_28]						,      lowerCAmelCase=[1, 2, 1]						,      lowerCAmelCase=[2, 2, 4]						,      lowerCAmelCase=2						,      lowerCAmelCase=2.0						,      lowerCAmelCase=True						,      lowerCAmelCase=0.0						,      lowerCAmelCase=0.0						,      lowerCAmelCase=0.1						,      lowerCAmelCase="gelu"						,      lowerCAmelCase=False						,      lowerCAmelCase=True						,      lowerCAmelCase=0.02						,      lowerCAmelCase=1E-5						,      lowerCAmelCase=True						,      lowerCAmelCase=None						,      lowerCAmelCase=True						,      lowerCAmelCase=10						,      lowerCAmelCase=8						,      lowerCAmelCase=["stage1", "stage2"]						,      lowerCAmelCase=[1, 2]						,      ):






										"""simple docstring"""

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

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

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

										snake_case        =     self.get_config()

										return config, pixel_values, labels

				def 						snake_case	(			self      ):






										"""simple docstring"""

										return FocalNetConfig(
										    image_size=self.image_size						,      patch_size=self.patch_size						,      num_channels=self.num_channels						,      embed_dim=self.embed_dim						,      hidden_sizes=self.hidden_sizes						,      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 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     FocalNetModel(config=lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase      )

										snake_case        =     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths      ) - 1))
										snake_case        =     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 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     FocalNetBackbone(config=lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase      )

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps      )						,      len(config.out_features      )      )
										self.parent.assertListEqual(list(result.feature_maps[0].shape      )						,      [self.batch_size, self.image_size, 8, 8]      )

										# verify channels
										self.parent.assertEqual(len(model.channels      )						,      len(config.out_features      )      )
										self.parent.assertListEqual(model.channels						,      config.hidden_sizes[:-1]      )

										# verify backbone works with out_features=None
										snake_case        =     None
										snake_case        =     FocalNetBackbone(config=lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase      )

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps      )						,      1      )
										self.parent.assertListEqual(list(result.feature_maps[0].shape      )						,      [self.batch_size, self.image_size * 2, 4, 4]      )

										# verify channels
										self.parent.assertEqual(len(model.channels      )						,      1      )
										self.parent.assertListEqual(model.channels						,      [config.hidden_sizes[-1]]      )

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

										snake_case        =     FocalNetForMaskedImageModeling(config=lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()
										snake_case        =     model(lowerCAmelCase      )
										self.parent.assertEqual(
										    result.reconstruction.shape						,      (self.batch_size, self.num_channels, self.image_size, self.image_size)      )

										# test greyscale images
										snake_case        =     1
										snake_case        =     FocalNetForMaskedImageModeling(lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()

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

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

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

										# test greyscale images
										snake_case        =     1
										snake_case        =     FocalNetForImageClassification(lowerCAmelCase      )
										model.to(lowerCAmelCase      )
										model.eval()

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.prepare_config_and_inputs()

										snake_case   ,snake_case   ,snake_case        =     config_and_inputs
										snake_case        =     {'pixel_values': pixel_values}
										return config, inputs_dict





@require_torch
class 					lowerCAmelCase_      (     lowerCAmelCase       ,      lowerCAmelCase       ,      unittest.TestCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Optional[Any]     					=  (
				    (
				        FocalNetModel,
				        FocalNetForImageClassification,
				        FocalNetForMaskedImageModeling,
				        FocalNetBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				_lowerCAmelCase       :      List[str]     					=  (
				    {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
				    if is_torch_available()
				    else {}
				)
				_lowerCAmelCase       :      int     					=  False

				_lowerCAmelCase       :      List[str]     					=  False
				_lowerCAmelCase       :      Any     					=  False
				_lowerCAmelCase       :      Tuple     					=  False
				_lowerCAmelCase       :      List[str]     					=  False

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     FocalNetModelTester(self      )
										snake_case        =     ConfigTester(self						,      config_class=lowerCAmelCase						,      embed_dim=37						,      has_text_modality=lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										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 						snake_case	(			self      ):






										"""simple docstring"""

										return

				def 						snake_case	(			self      ):






										"""simple docstring"""

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_backbone(*lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

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

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






										"""simple docstring"""

										pass

				@unittest.skip(reason='FocalNet does not use feedforward chunking'      )
				def 						snake_case	(			self      ):






										"""simple docstring"""

										pass

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case   ,snake_case        =     self.model_tester.prepare_config_and_inputs_for_common()

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case   ,snake_case        =     self.model_tester.prepare_config_and_inputs_for_common()

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

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

				def 						snake_case	(			self						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      ):






										"""simple docstring"""

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

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

										snake_case        =     outputs.hidden_states

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

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

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

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

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

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case   ,snake_case        =     self.model_tester.prepare_config_and_inputs_for_common()

										snake_case        =     (
										    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[:-1]:
																snake_case        =     True
																self.check_hidden_states_output(lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      )

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

																self.check_hidden_states_output(lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

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

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

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

										for model_class in self.all_model_classes[:-1]:
																snake_case        =     True
																self.check_hidden_states_output(lowerCAmelCase						,      lowerCAmelCase						,      lowerCAmelCase						,      (padded_height, padded_width)      )

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

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																snake_case        =     FocalNetModel.from_pretrained(lowerCAmelCase      )
																self.assertIsNotNone(lowerCAmelCase      )

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case   ,snake_case        =     self.model_tester.prepare_config_and_inputs_for_common()

										snake_case        =     _config_zero_init(lowerCAmelCase      )
										for model_class in self.all_model_classes:
																snake_case        =     model_class(config=lowerCAmelCase      )
																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 					lowerCAmelCase_      (     unittest.TestCase   ):



				"""simple docstring"""

				@cached_property
				def 						snake_case	(			self      ):






										"""simple docstring"""

										return AutoImageProcessor.from_pretrained('microsoft/focalnet-tiny'      ) if is_vision_available() else None

				@slow
				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     FocalNetForImageClassification.from_pretrained('microsoft/focalnet-tiny'      ).to(lowerCAmelCase      )
										snake_case        =     self.default_image_processor

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

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

										# verify the logits
										snake_case        =     torch.Size((1, 10_00)      )
										self.assertEqual(outputs.logits.shape						,      lowerCAmelCase      )
										snake_case        =     torch.tensor([0.21_66, -0.43_68, 0.21_91]      ).to(lowerCAmelCase      )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]						,      lowerCAmelCase						,      atol=1E-4      )      )
										self.assertTrue(outputs.logits.argmax(dim=-1      ).item()						,      2_81      )





@require_torch
class 					lowerCAmelCase_      (     lowerCAmelCase       ,      unittest.TestCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Tuple     					=  (FocalNetBackbone,) if is_torch_available() else ()
				_lowerCAmelCase       :      Optional[int]     					=  FocalNetConfig

				_lowerCAmelCase       :      str     					=  False

				def 						snake_case	(			self      ):






										"""simple docstring"""

										snake_case        =     FocalNetModelTester(self      )



"""simple docstring"""
from ..utils import DummyObject, requires_backends



class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Dict     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Optional[Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Optional[Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Union[str, Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Optional[int]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Dict     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Union[str, Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Union[str, Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Optional[int]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Any     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Union[str, Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      List[Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      str     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Tuple     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Union[str, Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Union[str, Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      str     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Tuple     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Any     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Tuple     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Tuple     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      int     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Any     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Optional[int]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      int     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Dict     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Any     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Union[str, Any]     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      str     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Dict     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )





class 					lowerCAmelCase_      (     metaclass=lowerCAmelCase   ):



				"""simple docstring"""
				_lowerCAmelCase       :      Tuple     					=  ["""sentencepiece"""]

				def __init__(			self						,      *lowerCAmelCase						,      **lowerCAmelCase      ):






										"""simple docstring"""

										requires_backends(self						,      ['sentencepiece']      )


