code: 
  import argparse
  import json
  import re
  from pathlib import Path
  
  import requests
  import torch
  from huggingface_hub import hf_hub_download
  from PIL import Image
  
  from transformers import (
      MobileNetVaConfig,
      MobileNetVaForImageClassification,
      MobileNetVaForSemanticSegmentation,
      MobileNetVaImageProcessor,
      load_tf_weights_in_mobilenet_va,
  )
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  UpperCamelCase_     			=       logging.get_logger(__name__)
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       Dict		)    ->						Union[str, Any]:
    _lowerCAmelCase       :  List[str]   				=					MobileNetVaConfig(layer_norm_eps=0.001		)
  
    if "quant" in model_name:
      raise ValueError("""Quantized models are not supported."""		)
  
    _lowerCAmelCase       :  Dict   				=					re.match(R"""^.*mobilenet_v2_([^_]*)_([^_]*)$"""  ,      _lowerCamelCase		)
    if matches:
      _lowerCAmelCase       :  Tuple   				=					float(matches[1]		)
      _lowerCAmelCase       :  List[Any]   				=					int(matches[2]		)
  
    if model_name.startswith("""deeplabv3_"""		):
      _lowerCAmelCase       :  Any   				=					8
      _lowerCAmelCase       :  Any   				=					21
      _lowerCAmelCase       :  Optional[Any]   				=					"pascal-voc-id2label.json"
    else:
      # The TensorFlow version of MobileNetV2 predicts 1001 classes instead
      # of the usual 1000. The first class (index 0) is "background".
      _lowerCAmelCase       :  Optional[Any]   				=					10_01
      _lowerCAmelCase       :  str   				=					"imagenet-1k-id2label.json"
  
    _lowerCAmelCase       :  Any   				=					"huggingface/label-files"
    _lowerCAmelCase       :  str   				=					json.load(open(hf_hub_download(_lowerCamelCase  ,      _lowerCamelCase  ,      repo_type="""dataset"""		)  ,      """r"""		)		)
  
    if config.num_labels == 10_01:
      _lowerCAmelCase       :  Optional[Any]   				=					{int(_lowerCamelCase		) + 1: v for k, v in idalabel.items()}
      _lowerCAmelCase       :  Any   				=					"background"
    else:
      _lowerCAmelCase       :  Optional[Any]   				=					{int(_lowerCamelCase		): v for k, v in idalabel.items()}
  
    _lowerCAmelCase       :  Any   				=					idalabel
    _lowerCAmelCase       :  List[str]   				=					{v: k for k, v in idalabel.items()}
  
    return config
  
  
  def 	_UpperCAmelCase				(  )    ->						Optional[Any]:
    _lowerCAmelCase       :  List[Any]   				=					"http://images.cocodataset.org/val2017/000000039769.jpg"
    _lowerCAmelCase       :  Union[str, Any]   				=					Image.open(requests.get(_lowerCamelCase  ,      stream=_lowerCamelCase		).raw		)
    return im
  
  
  @torch.no_grad()
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       str  ,      _lowerCamelCase						:       List[str]  ,      _lowerCamelCase						:       int  ,      _lowerCamelCase						:       List[str]=False		)    ->						str:
    _lowerCAmelCase       :  Dict   				=					get_mobilenet_va_config(_lowerCamelCase		)
  
    # Load 🤗 model
    if model_name.startswith("""deeplabv3_"""		):
      _lowerCAmelCase       :  str   				=					MobileNetVaForSemanticSegmentation(_lowerCamelCase		).eval()
    else:
      _lowerCAmelCase       :  Any   				=					MobileNetVaForImageClassification(_lowerCamelCase		).eval()
  
    # Load weights from TensorFlow checkpoint
    load_tf_weights_in_mobilenet_va(_lowerCamelCase  ,      _lowerCamelCase  ,      _lowerCamelCase		)
  
    # Check outputs on an image, prepared by MobileNetV2ImageProcessor
    _lowerCAmelCase       :  List[str]   				=					MobileNetVaImageProcessor(
        crop_size={"""width""": config.image_size, """height""": config.image_size}  ,      size={"""shortest_edge""": config.image_size + 32}  ,      )
    _lowerCAmelCase       :  Any   				=					image_processor(images=prepare_img()  ,      return_tensors="""pt"""		)
    _lowerCAmelCase       :  Dict   				=					model(**_lowerCamelCase		)
    _lowerCAmelCase       :  List[Any]   				=					outputs.logits
  
    if model_name.startswith("""deeplabv3_"""		):
      assert logits.shape == (1, 21, 65, 65)
  
      if model_name == "deeplabv3_mobilenet_v2_1.0_513":
        _lowerCAmelCase       :  Any   				=					torch.tensor(
            [
                [[17.57_90, 17.75_81, 18.33_55], [18.32_57, 18.42_30, 18.89_73], [18.61_69, 18.86_50, 19.21_87]],
                [[-2.1595, -2.0977, -2.3741], [-2.4226, -2.3028, -2.6835], [-2.7819, -2.5991, -2.7706]],
                [[4.2058, 4.8317, 4.7638], [4.4136, 5.0361, 4.9383], [4.5028, 4.9644, 4.8734]],
            ]		)
  
      else:
        raise ValueError(f'Unknown model name: {model_name}'		)
  
      assert torch.allclose(logits[0, :3, :3, :3]  ,      _lowerCamelCase  ,      atol=1e-4		)
    else:
      assert logits.shape == (1, 10_01)
  
      if model_name == "mobilenet_v2_1.4_224":
        _lowerCAmelCase       :  List[str]   				=					torch.tensor([0.0181, -1.0015, 0.4688]		)
      elif model_name == "mobilenet_v2_1.0_224":
        _lowerCAmelCase       :  str   				=					torch.tensor([0.2445, -1.1993, 0.1905]		)
      elif model_name == "mobilenet_v2_0.75_160":
        _lowerCAmelCase       :  Dict   				=					torch.tensor([0.2482, 0.4136, 0.6669]		)
      elif model_name == "mobilenet_v2_0.35_96":
        _lowerCAmelCase       :  List[Any]   				=					torch.tensor([0.1451, -0.4624, 0.7192]		)
      else:
        _lowerCAmelCase       :  int   				=					None
  
      if expected_logits is not None:
        assert torch.allclose(logits[0, :3]  ,      _lowerCamelCase  ,      atol=1e-4		)
  
    Path(_lowerCamelCase		).mkdir(exist_ok=_lowerCamelCase		)
    print(f'Saving model {model_name} to {pytorch_dump_folder_path}'		)
    model.save_pretrained(_lowerCamelCase		)
    print(f'Saving image processor to {pytorch_dump_folder_path}'		)
    image_processor.save_pretrained(_lowerCamelCase		)
  
    if push_to_hub:
      print("""Pushing to the hub..."""		)
      _lowerCAmelCase       :  Optional[Any]   				=					"google/" + model_name
      image_processor.push_to_hub(_lowerCamelCase		)
      model.push_to_hub(_lowerCamelCase		)
  
  
  if __name__ == "__main__":
       UpperCamelCase_     			=       argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           """--model_name""",
           default="""mobilenet_v2_1.0_224""",
           type=str,
           help="""Name of the MobileNetV2 model you\'d like to convert. Should in the form \'mobilenet_v2_<depth>_<size>\'.""",
       )
       parser.add_argument(
           """--checkpoint_path""", required=True, type=str, help="""Path to the original TensorFlow checkpoint (.ckpt file)."""
       )
       parser.add_argument(
           """--pytorch_dump_folder_path""", required=True, type=str, help="""Path to the output PyTorch model directory."""
       )
       parser.add_argument(
           """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
       )
  
       UpperCamelCase_     			=       parser.parse_args()
       convert_movilevit_checkpoint(
           args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
       )
  
  
  
style_context: 
  '''simple docstring'''
  
  from ..utils import DummyObject, requires_backends
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				str    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				str    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				int    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[str]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Any    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				str    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Union[str, Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Union[str, Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Dict    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Tuple    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[int]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Union[str, Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Union[str, Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[int]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Dict    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[str]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Dict    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[str]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Any    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				str    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Union[str, Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Any    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				str    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Union[str, Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[str]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Dict    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Dict    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				int    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Union[str, Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[int]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				int    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Any    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				str    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				int    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[int]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				List[str]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Union[str, Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Any    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  
  class   a_  (metaclass=_a    ):
         __lowerCAmelCase    :				Optional[Any]    =      ["""tokenizers"""]
  
  
  
  
         def __init__(     self   ,   *snake_case_   ,   **snake_case_  ):
           requires_backends(self   ,   ["""tokenizers"""]  )
  
  
  