


import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()


class 			A_   (			A__   , A__   , unittest.TestCase       ):




      '''simple docstring'''


      __snake_case   			=  AutoencoderKL
      __snake_case   			=  """sample"""
      __snake_case   			=  1e-2




      @property
      def 	_snake_case      (							self:			Tuple							):
       __lowerCamelCase						:				Any						   =		4
       __lowerCamelCase						:				Optional[Any]						   =		3
       __lowerCamelCase						:				Dict						   =		(32, 32)

       __lowerCamelCase						:				str						   =		floats_tensor((batch_size, num_channels) + sizes							).to(__snake_case							)

       return {"sample": image}




      @property
      def 	_snake_case      (							self:			int							):
       return (3, 32, 32)




      @property
      def 	_snake_case      (							self:			str							):
       return (3, 32, 32)




      def 	_snake_case      (							self:			List[Any]							):
       __lowerCamelCase						:				Tuple						   =		{
           'block_out_channels': [32, 64],
           'in_channels': 3,
           'out_channels': 3,
           'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
           'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
           'latent_channels': 4,
       }
       __lowerCamelCase						:				List[Any]						   =		self.dummy_input
       return init_dict, inputs_dict




      def 	_snake_case      (							self:			List[Any]							):
       pass




      def 	_snake_case      (							self:			List[Any]							):
       pass




      @unittest.skipIf(torch_device == 'mps'		, 'Gradient checkpointing skipped on MPS'							)
      def 	_snake_case      (							self:			List[Any]							):
       # enable deterministic behavior for gradient checkpointing
       __lowerCamelCase   ,	__lowerCamelCase						:				Optional[Any]						   =		self.prepare_init_args_and_inputs_for_common()
       __lowerCamelCase						:				Tuple						   =		self.model_class(**__snake_case							)
       model.to(__snake_case							)

       assert not model.is_gradient_checkpointing and model.training

       __lowerCamelCase						:				str						   =		model(**__snake_case							).sample
       # run the backwards pass on the model. For backwards pass, for simplicity purpose,
       # we won't calculate the loss and rather backprop on out.sum()
       model.zero_grad()

       __lowerCamelCase						:				Dict						   =		torch.randn_like(__snake_case							)
       __lowerCamelCase						:				int						   =		(out - labels).mean()
       loss.backward()

       # re-instantiate the model now enabling gradient checkpointing
       __lowerCamelCase						:				List[Any]						   =		self.model_class(**__snake_case							)
       # clone model
       model_a.load_state_dict(model.state_dict()							)
       model_a.to(__snake_case							)
       model_a.enable_gradient_checkpointing()

       assert model_a.is_gradient_checkpointing and model_a.training

       __lowerCamelCase						:				int						   =		model_a(**__snake_case							).sample
       # run the backwards pass on the model. For backwards pass, for simplicity purpose,
       # we won't calculate the loss and rather backprop on out.sum()
       model_a.zero_grad()
       __lowerCamelCase						:				Tuple						   =		(out_a - labels).mean()
       loss_a.backward()

       # compare the output and parameters gradients
       self.assertTrue((loss - loss_a).abs() < 1e-5							)
       __lowerCamelCase						:				Optional[int]						   =		dict(model.named_parameters()							)
       __lowerCamelCase						:				List[str]						   =		dict(model_a.named_parameters()							)
       for name, param in named_params.items():
        self.assertTrue(torch_all_close(param.grad.data		, named_params_a[name].grad.data		, atol=5e-5							)							)




      def 	_snake_case      (							self:			List[str]							):
       __lowerCamelCase   ,	__lowerCamelCase						:				Any						   =		AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'		, output_loading_info=__snake_case							)
       self.assertIsNotNone(__snake_case							)
       self.assertEqual(len(loading_info['missing_keys']							)		, 0							)

       model.to(__snake_case							)
       __lowerCamelCase						:				Dict						   =		model(**self.dummy_input							)

       assert image is not None, "Make sure output is not None"




      def 	_snake_case      (							self:			str							):
       __lowerCamelCase						:				Union[str, Any]						   =		AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'							)
       __lowerCamelCase						:				int						   =		model.to(__snake_case							)
       model.eval()

       if torch_device == "mps":
        __lowerCamelCase						:				Optional[Any]						   =		torch.manual_seed(0							)
       else:
        __lowerCamelCase						:				Tuple						   =		torch.Generator(device=__snake_case							).manual_seed(0							)

       __lowerCamelCase						:				Dict						   =		torch.randn(
           1		, model.config.in_channels		, model.config.sample_size		, model.config.sample_size		, generator=torch.manual_seed(0							)		, )
       __lowerCamelCase						:				Union[str, Any]						   =		image.to(__snake_case							)
       with torch.no_grad():
        __lowerCamelCase						:				Union[str, Any]						   =		model(__snake_case		, sample_posterior=__snake_case		, generator=__snake_case							).sample

       __lowerCamelCase						:				Any						   =		output[0, -1, -3:, -3:].flatten().cpu()

       # Since the VAE Gaussian prior's generator is seeded on the appropriate device,
       # the expected output slices are not the same for CPU and GPU.
       if torch_device == "mps":
        __lowerCamelCase						:				Any						   =		torch.tensor(
            [
                -4.0078e-01,
                -3.8323e-04,
                -1.2681e-01,
                -1.1462e-01,
                2.0095e-01,
                1.0893e-01,
                -8.8247e-02,
                -3.0361e-01,
                -9.8644e-03,
            ]							)
       elif torch_device == "cpu":
        __lowerCamelCase						:				int						   =		torch.tensor(
            [-0.1_3_5_2, 0.0_8_7_8, 0.0_4_1_9, -0.0_8_1_8, -0.1_0_6_9, 0.0_6_8_8, -0.1_4_5_8, -0.4_4_4_6, -0.0_0_2_6]							)
       else:
        __lowerCamelCase						:				List[str]						   =		torch.tensor(
            [-0.2_4_2_1, 0.4_6_4_2, 0.2_5_0_7, -0.0_4_3_8, 0.0_6_8_2, 0.3_1_6_0, -0.2_0_1_8, -0.0_7_2_7, 0.2_4_8_5]							)

       self.assertTrue(torch_all_close(__snake_case		, __snake_case		, rtol=1e-2							)							)



@slow
class 			A_   (			unittest.TestCase       ):




      '''simple docstring'''


      def 	_snake_case      (							self:			Tuple		, a:			Tuple		, a:			int							):
       return F'gaussian_noise_s={seed}_shape={"_".join([str(__snake_case							) for s in shape]							)}.npy'




      def 	_snake_case      (							self:			List[Any]							):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()




      def 	_snake_case      (							self:			Optional[Any]		, a:			List[str]=0		, a:			Union[str, Any]=(4, 3, 512, 512)		, a:			Any=False							):
       __lowerCamelCase						:				Optional[int]						   =		torch.floataa if fpaa else torch.floataa
       __lowerCamelCase						:				Optional[int]						   =		torch.from_numpy(load_hf_numpy(self.get_file_format(__snake_case		, __snake_case							)							)							).to(__snake_case							).to(__snake_case							)
       return image




      def 	_snake_case      (							self:			Optional[Any]		, a:			Optional[int]="CompVis/stable-diffusion-v1-4"		, a:			Optional[int]=False							):
       __lowerCamelCase						:				Optional[Any]						   =		'fp16' if fpaa else None
       __lowerCamelCase						:				Dict						   =		torch.floataa if fpaa else torch.floataa

       __lowerCamelCase						:				Dict						   =		AutoencoderKL.from_pretrained(
           __snake_case		, subfolder='vae'		, torch_dtype=__snake_case		, revision=__snake_case		, )
       model.to(__snake_case							).eval()

       return model




      def 	_snake_case      (							self:			List[str]		, a:			Union[str, Any]=0							):
       if torch_device == "mps":
        return torch.manual_seed(__snake_case							)
       return torch.Generator(device=__snake_case							).manual_seed(__snake_case							)




      @parameterized.expand(
          [
              # fmt: off
              [33, [-0.1_6_0_3, 0.9_8_7_8, -0.0_4_9_5, -0.0_7_9_0, -0.2_7_0_9, 0.8_3_7_5, -0.2_0_6_0, -0.0_8_2_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
              [47, [-0.2_3_7_6, 0.1_1_6_8, 0.1_3_3_2, -0.4_8_4_0, -0.2_5_0_8, -0.0_7_9_1, -0.0_4_9_3, -0.4_0_8_9], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
              # fmt: on
          ]							)
      def 	_snake_case      (							self:			Optional[Any]		, a:			Optional[int]		, a:			Dict		, a:			Dict							):
       __lowerCamelCase						:				Dict						   =		self.get_sd_vae_model()
       __lowerCamelCase						:				int						   =		self.get_sd_image(__snake_case							)
       __lowerCamelCase						:				Tuple						   =		self.get_generator(__snake_case							)

       with torch.no_grad():
        __lowerCamelCase						:				Dict						   =		model(__snake_case		, generator=__snake_case		, sample_posterior=__snake_case							).sample

       assert sample.shape == image.shape

       __lowerCamelCase						:				Tuple						   =		sample[-1, -2:, -2:, :2].flatten().float().cpu()
       __lowerCamelCase						:				Optional[Any]						   =		torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice							)

       assert torch_all_close(__snake_case		, __snake_case		, atol=3e-3							)




      @parameterized.expand(
          [
              # fmt: off
              [33, [-0.0_5_1_3, 0.0_2_8_9, 1.3_7_9_9, 0.2_1_6_6, -0.2_5_7_3, -0.0_8_7_1, 0.5_1_0_3, -0.0_9_9_9]],
              [47, [-0.4_1_2_8, -0.1_3_2_0, -0.3_7_0_4, 0.1_9_6_5, -0.4_1_1_6, -0.2_3_3_2, -0.3_3_4_0, 0.2_2_4_7]],
              # fmt: on
          ]							)
      @require_torch_gpu
      def 	_snake_case      (							self:			List[str]		, a:			Union[str, Any]		, a:			Tuple							):
       __lowerCamelCase						:				List[str]						   =		self.get_sd_vae_model(fpaa=__snake_case							)
       __lowerCamelCase						:				Dict						   =		self.get_sd_image(__snake_case		, fpaa=__snake_case							)
       __lowerCamelCase						:				Tuple						   =		self.get_generator(__snake_case							)

       with torch.no_grad():
        __lowerCamelCase						:				Optional[int]						   =		model(__snake_case		, generator=__snake_case		, sample_posterior=__snake_case							).sample

       assert sample.shape == image.shape

       __lowerCamelCase						:				Dict						   =		sample[-1, -2:, :2, -2:].flatten().float().cpu()
       __lowerCamelCase						:				str						   =		torch.tensor(__snake_case							)

       assert torch_all_close(__snake_case		, __snake_case		, atol=1e-2							)




      @parameterized.expand(
          [
              # fmt: off
              [33, [-0.1_6_0_9, 0.9_8_6_6, -0.0_4_8_7, -0.0_7_7_7, -0.2_7_1_6, 0.8_3_6_8, -0.2_0_5_5, -0.0_8_1_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
              [47, [-0.2_3_7_7, 0.1_1_4_7, 0.1_3_3_3, -0.4_8_4_1, -0.2_5_0_6, -0.0_8_0_5, -0.0_4_9_1, -0.4_0_8_5], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
              # fmt: on
          ]							)
      def 	_snake_case      (							self:			List[str]		, a:			Any		, a:			Tuple		, a:			str							):
       __lowerCamelCase						:				Tuple						   =		self.get_sd_vae_model()
       __lowerCamelCase						:				List[str]						   =		self.get_sd_image(__snake_case							)

       with torch.no_grad():
        __lowerCamelCase						:				Dict						   =		model(__snake_case							).sample

       assert sample.shape == image.shape

       __lowerCamelCase						:				Optional[Any]						   =		sample[-1, -2:, -2:, :2].flatten().float().cpu()
       __lowerCamelCase						:				List[Any]						   =		torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice							)

       assert torch_all_close(__snake_case		, __snake_case		, atol=3e-3							)




      @parameterized.expand(
          [
              # fmt: off
              [13, [-0.2_0_5_1, -0.1_8_0_3, -0.2_3_1_1, -0.2_1_1_4, -0.3_2_9_2, -0.3_5_7_4, -0.2_9_5_3, -0.3_3_2_3]],
              [37, [-0.2_6_3_2, -0.2_6_2_5, -0.2_1_9_9, -0.2_7_4_1, -0.4_5_3_9, -0.4_9_9_0, -0.3_7_2_0, -0.4_9_2_5]],
              # fmt: on
          ]							)
      @require_torch_gpu
      def 	_snake_case      (							self:			Tuple		, a:			Optional[int]		, a:			Any							):
       __lowerCamelCase						:				Dict						   =		self.get_sd_vae_model()
       __lowerCamelCase						:				Any						   =		self.get_sd_image(__snake_case		, shape=(3, 4, 64, 64)							)

       with torch.no_grad():
        __lowerCamelCase						:				int						   =		model.decode(__snake_case							).sample

       assert list(sample.shape							) == [3, 3, 512, 512]

       __lowerCamelCase						:				Dict						   =		sample[-1, -2:, :2, -2:].flatten().cpu()
       __lowerCamelCase						:				Union[str, Any]						   =		torch.tensor(__snake_case							)

       assert torch_all_close(__snake_case		, __snake_case		, atol=1e-3							)




      @parameterized.expand(
          [
              # fmt: off
              [27, [-0.0_3_6_9, 0.0_2_0_7, -0.0_7_7_6, -0.0_6_8_2, -0.1_7_4_7, -0.1_9_3_0, -0.1_4_6_5, -0.2_0_3_9]],
              [16, [-0.1_6_2_8, -0.2_1_3_4, -0.2_7_4_7, -0.2_6_4_2, -0.3_7_7_4, -0.4_4_0_4, -0.3_6_8_7, -0.4_2_7_7]],
              # fmt: on
          ]							)
      @require_torch_gpu
      def 	_snake_case      (							self:			str		, a:			str		, a:			str							):
       __lowerCamelCase						:				Any						   =		self.get_sd_vae_model(fpaa=__snake_case							)
       __lowerCamelCase						:				Optional[Any]						   =		self.get_sd_image(__snake_case		, shape=(3, 4, 64, 64)		, fpaa=__snake_case							)

       with torch.no_grad():
        __lowerCamelCase						:				Tuple						   =		model.decode(__snake_case							).sample

       assert list(sample.shape							) == [3, 3, 512, 512]

       __lowerCamelCase						:				Union[str, Any]						   =		sample[-1, -2:, :2, -2:].flatten().float().cpu()
       __lowerCamelCase						:				Optional[int]						   =		torch.tensor(__snake_case							)

       assert torch_all_close(__snake_case		, __snake_case		, atol=5e-3							)




      @parameterized.expand([(13,), (16,), (27,)]							)
      @require_torch_gpu
      @unittest.skipIf(not is_xformers_available()		, reason='xformers is not required when using PyTorch 2.0.'							)
      def 	_snake_case      (							self:			Union[str, Any]		, a:			int							):
       __lowerCamelCase						:				int						   =		self.get_sd_vae_model(fpaa=__snake_case							)
       __lowerCamelCase						:				Union[str, Any]						   =		self.get_sd_image(__snake_case		, shape=(3, 4, 64, 64)		, fpaa=__snake_case							)

       with torch.no_grad():
        __lowerCamelCase						:				int						   =		model.decode(__snake_case							).sample

       model.enable_xformers_memory_efficient_attention()
       with torch.no_grad():
        __lowerCamelCase						:				List[str]						   =		model.decode(__snake_case							).sample

       assert list(sample.shape							) == [3, 3, 512, 512]

       assert torch_all_close(__snake_case		, __snake_case		, atol=1e-1							)




      @parameterized.expand([(13,), (16,), (37,)]							)
      @require_torch_gpu
      @unittest.skipIf(not is_xformers_available()		, reason='xformers is not required when using PyTorch 2.0.'							)
      def 	_snake_case      (							self:			List[str]		, a:			List[str]							):
       __lowerCamelCase						:				Optional[int]						   =		self.get_sd_vae_model()
       __lowerCamelCase						:				Optional[int]						   =		self.get_sd_image(__snake_case		, shape=(3, 4, 64, 64)							)

       with torch.no_grad():
        __lowerCamelCase						:				Optional[int]						   =		model.decode(__snake_case							).sample

       model.enable_xformers_memory_efficient_attention()
       with torch.no_grad():
        __lowerCamelCase						:				Optional[int]						   =		model.decode(__snake_case							).sample

       assert list(sample.shape							) == [3, 3, 512, 512]

       assert torch_all_close(__snake_case		, __snake_case		, atol=1e-2							)




      @parameterized.expand(
          [
              # fmt: off
              [33, [-0.3_0_0_1, 0.0_9_1_8, -2.6_9_8_4, -3.9_7_2_0, -3.2_0_9_9, -5.0_3_5_3, 1.7_3_3_8, -0.2_0_6_5, 3.4_2_6_7]],
              [47, [-1.5_0_3_0, -4.3_8_7_1, -6.0_3_5_5, -9.1_1_5_7, -1.6_6_6_1, -2.7_8_5_3, 2.1_6_0_7, -5.0_8_2_3, 2.5_6_3_3]],
              # fmt: on
          ]							)
      def 	_snake_case      (							self:			Optional[int]		, a:			Optional[Any]		, a:			int							):
       __lowerCamelCase						:				Optional[Any]						   =		self.get_sd_vae_model()
       __lowerCamelCase						:				Union[str, Any]						   =		self.get_sd_image(__snake_case							)
       __lowerCamelCase						:				List[str]						   =		self.get_generator(__snake_case							)

       with torch.no_grad():
        __lowerCamelCase						:				str						   =		model.encode(__snake_case							).latent_dist
        __lowerCamelCase						:				List[Any]						   =		dist.sample(generator=__snake_case							)

       assert list(sample.shape							) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

       __lowerCamelCase						:				List[Any]						   =		sample[0, -1, -3:, -3:].flatten().cpu()
       __lowerCamelCase						:				int						   =		torch.tensor(__snake_case							)

       __lowerCamelCase						:				Optional[int]						   =		3e-3 if torch_device != 'mps' else 1e-2
       assert torch_all_close(__snake_case		, __snake_case		, atol=__snake_case							)








'''simple docstring'''




import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
 from .tokenization_rembert import RemBertTokenizer
else:
 _SCREAMING_SNAKE_CASE							     =			None

_SCREAMING_SNAKE_CASE							     =			logging.get_logger(__name__)
_SCREAMING_SNAKE_CASE							     =			{"vocab_file": "sentencepiece.model", "tokenizer_file": "tokenizer.json"}

_SCREAMING_SNAKE_CASE							     =			{
    "vocab_file": {
        "google/rembert": "https://huggingface.co/google/rembert/resolve/main/sentencepiece.model",
    },
    "tokenizer_file": {
        "google/rembert": "https://huggingface.co/google/rembert/resolve/main/tokenizer.json",
    },
}

_SCREAMING_SNAKE_CASE							     =			{
    "google/rembert": 256,
}

_SCREAMING_SNAKE_CASE							     =			"▁"
class 			_lowerCAmelCase		(			A__	):






     """simple docstring"""






     snake_case_						      =   VOCAB_FILES_NAMES
     snake_case_						      =   PRETRAINED_VOCAB_FILES_MAP
     snake_case_						      =   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     snake_case_						      =   RemBertTokenizer



     def __init__(   self							:			List[Any]   ,       __snake_case							:			int=None   ,       __snake_case							:			Union[str, Any]=None   ,       __snake_case							:			Tuple=True   ,       __snake_case							:			Dict=True   ,       __snake_case							:			str=False   ,       __snake_case							:			Union[str, Any]="[CLS]"   ,       __snake_case							:			Optional[int]="[SEP]"   ,       __snake_case							:			str="<unk>"   ,       __snake_case							:			Dict="[SEP]"   ,       __snake_case							:			Dict="<pad>"   ,       __snake_case							:			Union[str, Any]="[CLS]"   ,       __snake_case							:			int="[MASK]"   ,       **__snake_case							:			Optional[int]   ,       )->	Tuple:
        # Mask token behave like a normal word, i.e. include the space before it
        snake_case 						=   AddedToken(__snake_case   ,       lstrip=__snake_case   ,       rstrip=__snake_case						) if isinstance(__snake_case   ,       __snake_case						) else mask_token

        super().__init__(
            __snake_case   ,       tokenizer_file=__snake_case   ,       do_lower_case=__snake_case   ,       remove_space=__snake_case   ,       keep_accents=__snake_case   ,       bos_token=__snake_case   ,       eos_token=__snake_case   ,       unk_token=__snake_case   ,       sep_token=__snake_case   ,       pad_token=__snake_case   ,       cls_token=__snake_case   ,       mask_token=__snake_case   ,       **__snake_case   ,       )

        snake_case 						=   do_lower_case
        snake_case 						=   remove_space
        snake_case 						=   keep_accents
        snake_case 						=   vocab_file
        snake_case 						=   False if not self.vocab_file else True



     def      lowerCAmelCase			(   self							:			List[str]   ,       __snake_case							:			List[int]   ,       __snake_case							:			Optional[List[int]] = None						)->	List[int]:
        snake_case 						=   [self.sep_token_id]
        snake_case 						=   [self.cls_token_id]
        if token_ids_a is None:
           return cls + token_ids_a + sep
        return cls + token_ids_a + sep + token_ids_a + sep



     def      lowerCAmelCase			(   self							:			List[Any]   ,       __snake_case							:			List[int]   ,       __snake_case							:			Optional[List[int]] = None   ,       __snake_case							:			bool = False						)->	List[int]:

        if already_has_special_tokens:
           if token_ids_a is not None:
              raise ValueError(
                  """You should not supply a second sequence if the provided sequence of """
                  """ids is already formatted with special tokens for the model."""						)
           return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

        if token_ids_a is not None:
           return [1] + ([0] * len(__snake_case						)) + [1] + ([0] * len(__snake_case						)) + [1]
        return [1] + ([0] * len(__snake_case						)) + [1]



     def      lowerCAmelCase			(   self							:			int   ,       __snake_case							:			List[int]   ,       __snake_case							:			Optional[List[int]] = None						)->	List[int]:
        snake_case 						=   [self.sep_token_id]
        snake_case 						=   [self.cls_token_id]

        if token_ids_a is None:
           return len(cls + token_ids_a + sep						) * [0]
        return len(cls + token_ids_a + sep						) * [0] + len(token_ids_a + sep						) * [1]



     def      lowerCAmelCase			(   self							:			Tuple   ,       __snake_case							:			str   ,       __snake_case							:			Optional[str] = None						)->	Tuple[str]:
        if not os.path.isdir(__snake_case						):
           logger.error("""Vocabulary path ({}) should be a directory""".format(__snake_case						)						)
           return
        snake_case 						=   os.path.join(
            __snake_case   ,       (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]						)

        if os.path.abspath(self.vocab_file						) != os.path.abspath(__snake_case						):
           copyfile(self.vocab_file   ,       __snake_case						)

        return (out_vocab_file,)

