
"""simple docstring"""





import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import ConditionalDetrImageProcessor



class __lowerCAmelCase					(       unittest.TestCase   ):




			"""simple docstring"""







			def __init__(					self    :       Any							, _snake_case    :       Dict							, _snake_case    :       Tuple=7							, _snake_case    :       Dict=3							, _snake_case    :       Union[str, Any]=30							, _snake_case    :       int=400							, _snake_case    :       Tuple=True							, _snake_case    :       Tuple=None							, _snake_case    :       Any=True							, _snake_case    :       Union[str, Any]=[0.5, 0.5, 0.5]							, _snake_case    :       int=[0.5, 0.5, 0.5]							, _snake_case    :       Optional[int]=True							, _snake_case    :       List[Any]=1 / 255							, _snake_case    :       List[Any]=True							, )   ->			Tuple:







								"""simple docstring"""
								# by setting size["longest_edge"] > max_resolution we're effectively not testing this :p
								A_								=    size if size is not None else {"shortest_edge": 18, "longest_edge": 1_333}
								A_								=    parent
								A_								=    batch_size
								A_								=    num_channels
								A_								=    min_resolution
								A_								=    max_resolution
								A_								=    do_resize
								A_								=    size
								A_								=    do_normalize
								A_								=    image_mean
								A_								=    image_std
								A_								=    do_rescale
								A_								=    rescale_factor
								A_								=    do_pad




			def   lowerCamelCase__  (					self    :       Optional[Any]						)   ->			List[str]:







								"""simple docstring"""
								return {
								    "do_resize": self.do_resize,
								    "size": self.size,
								    "do_normalize": self.do_normalize,
								    "image_mean": self.image_mean,
								    "image_std": self.image_std,
								    "do_rescale": self.do_rescale,
								    "rescale_factor": self.rescale_factor,
								    "do_pad": self.do_pad,
								}






			def   lowerCamelCase__  (					self    :       List[str]							, _snake_case    :       str							, _snake_case    :       List[str]=False						)   ->			str:







								"""simple docstring"""
								if not batched:
													A_								=    image_inputs[0]
													if isinstance(_snake_case							, Image.Image						):
																		A_			,     A_								=    image.size
													else:
																		A_			,     A_								=    image.shape[1], image.shape[2]
													if w < h:
																		A_								=    int(self.size["shortest_edge"] * h / w						)
																		A_								=    self.size["shortest_edge"]
													elif w > h:
																		A_								=    self.size["shortest_edge"]
																		A_								=    int(self.size["shortest_edge"] * w / h						)
													else:
																		A_								=    self.size["shortest_edge"]
																		A_								=    self.size["shortest_edge"]

								else:
													A_								=    []
													for image in image_inputs:
																		A_			,     A_								=    self.get_expected_values([image]						)
																		expected_values.append((expected_height, expected_width)						)
													A_								=    max(_snake_case							, key=lambda _snake_case						: item[0]						)[0]
													A_								=    max(_snake_case							, key=lambda _snake_case						: item[1]						)[1]

								return expected_height, expected_width





@require_torch
@require_vision
class __lowerCAmelCase					(       _lowercase  ,					unittest.TestCase   ):




			"""simple docstring"""







			snake_case						   =					ConditionalDetrImageProcessor if is_vision_available() else None




			def   lowerCamelCase__  (					self    :       int						)   ->			Optional[int]:







								"""simple docstring"""
								A_								=    ConditionalDetrImageProcessingTester(self						)




			@property
			def   lowerCamelCase__  (					self    :       List[Any]						)   ->			Optional[int]:







								"""simple docstring"""
								return self.image_processor_tester.prepare_image_processor_dict()




			def   lowerCamelCase__  (					self    :       Optional[int]						)   ->			Any:







								"""simple docstring"""
								A_								=    self.image_processing_class(**self.image_processor_dict						)
								self.assertTrue(hasattr(_snake_case							, "image_mean"						)						)
								self.assertTrue(hasattr(_snake_case							, "image_std"						)						)
								self.assertTrue(hasattr(_snake_case							, "do_normalize"						)						)
								self.assertTrue(hasattr(_snake_case							, "do_resize"						)						)
								self.assertTrue(hasattr(_snake_case							, "size"						)						)




			def   lowerCamelCase__  (					self    :       Optional[Any]						)   ->			int:







								"""simple docstring"""
								A_								=    self.image_processing_class.from_dict(self.image_processor_dict						)
								self.assertEqual(image_processor.size							, {"shortest_edge": 18, "longest_edge": 1_333}						)
								self.assertEqual(image_processor.do_pad							, _snake_case						)

								A_								=    self.image_processing_class.from_dict(
								    self.image_processor_dict							, size=42							, max_size=84							, pad_and_return_pixel_mask=_snake_case						)
								self.assertEqual(image_processor.size							, {"shortest_edge": 42, "longest_edge": 84}						)
								self.assertEqual(image_processor.do_pad							, _snake_case						)




			def   lowerCamelCase__  (					self    :       Any						)   ->			List[str]:







								"""simple docstring"""
								pass




			def   lowerCamelCase__  (					self    :       Dict						)   ->			List[str]:







								"""simple docstring"""
								# Initialize image_processing
								A_								=    self.image_processing_class(**self.image_processor_dict						)
								# create random PIL images
								A_								=    prepare_image_inputs(self.image_processor_tester							, equal_resolution=_snake_case						)
								for image in image_inputs:
													self.assertIsInstance(_snake_case							, Image.Image						)

								# Test not batched input
								A_								=    image_processing(image_inputs[0]							, return_tensors="pt"						).pixel_values

								A_			,     A_								=    self.image_processor_tester.get_expected_values(_snake_case						)

								self.assertEqual(
								    encoded_images.shape							, (1, self.image_processor_tester.num_channels, expected_height, expected_width)							, )

								# Test batched
								A_			,     A_								=    self.image_processor_tester.get_expected_values(_snake_case							, batched=_snake_case						)

								A_								=    image_processing(_snake_case							, return_tensors="pt"						).pixel_values
								self.assertEqual(
								    encoded_images.shape							, (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        expected_height,
								        expected_width,
								    )							, )




			def   lowerCamelCase__  (					self    :       Union[str, Any]						)   ->			Union[str, Any]:







								"""simple docstring"""
								# Initialize image_processing
								A_								=    self.image_processing_class(**self.image_processor_dict						)
								# create random numpy tensors
								A_								=    prepare_image_inputs(self.image_processor_tester							, equal_resolution=_snake_case							, numpify=_snake_case						)
								for image in image_inputs:
													self.assertIsInstance(_snake_case							, np.ndarray						)

								# Test not batched input
								A_								=    image_processing(image_inputs[0]							, return_tensors="pt"						).pixel_values

								A_			,     A_								=    self.image_processor_tester.get_expected_values(_snake_case						)

								self.assertEqual(
								    encoded_images.shape							, (1, self.image_processor_tester.num_channels, expected_height, expected_width)							, )

								# Test batched
								A_								=    image_processing(_snake_case							, return_tensors="pt"						).pixel_values

								A_			,     A_								=    self.image_processor_tester.get_expected_values(_snake_case							, batched=_snake_case						)

								self.assertEqual(
								    encoded_images.shape							, (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        expected_height,
								        expected_width,
								    )							, )




			def   lowerCamelCase__  (					self    :       Optional[Any]						)   ->			Tuple:







								"""simple docstring"""
								# Initialize image_processing
								A_								=    self.image_processing_class(**self.image_processor_dict						)
								# create random PyTorch tensors
								A_								=    prepare_image_inputs(self.image_processor_tester							, equal_resolution=_snake_case							, torchify=_snake_case						)
								for image in image_inputs:
													self.assertIsInstance(_snake_case							, torch.Tensor						)

								# Test not batched input
								A_								=    image_processing(image_inputs[0]							, return_tensors="pt"						).pixel_values

								A_			,     A_								=    self.image_processor_tester.get_expected_values(_snake_case						)

								self.assertEqual(
								    encoded_images.shape							, (1, self.image_processor_tester.num_channels, expected_height, expected_width)							, )

								# Test batched
								A_								=    image_processing(_snake_case							, return_tensors="pt"						).pixel_values

								A_			,     A_								=    self.image_processor_tester.get_expected_values(_snake_case							, batched=_snake_case						)

								self.assertEqual(
								    encoded_images.shape							, (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        expected_height,
								        expected_width,
								    )							, )




			@slow
			def   lowerCamelCase__  (					self    :       Tuple						)   ->			List[str]:







								"""simple docstring"""
								# prepare image and target
								A_								=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
								with open("./tests/fixtures/tests_samples/COCO/coco_annotations.txt"							, "r"						) as f:
													A_								=    json.loads(f.read()						)

								A_								=    {"image_id": 39_769, "annotations": target}

								# encode them
								A_								=    ConditionalDetrImageProcessor.from_pretrained("microsoft/conditional-detr-resnet-50"						)
								A_								=    image_processing(images=_snake_case							, annotations=_snake_case							, return_tensors="pt"						)

								# verify pixel values
								A_								=    torch.Size([1, 3, 800, 1_066]						)
								self.assertEqual(encoding["pixel_values"].shape							, _snake_case						)

								A_								=    torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]						)
								self.assertTrue(torch.allclose(encoding["pixel_values"][0, 0, 0, :3]							, _snake_case							, atol=1e-4						)						)

								# verify area
								A_								=    torch.tensor([5_8_8_7.9_6_0_0, 1_1_2_5_0.2_0_6_1, 4_8_9_3_5_3.8_4_3_8, 8_3_7_1_2_2.7_5_0_0, 1_4_7_9_6_7.5_1_5_6, 1_6_5_7_3_2.3_4_3_8]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["area"]							, _snake_case						)						)
								# verify boxes
								A_								=    torch.Size([6, 4]						)
								self.assertEqual(encoding["labels"][0]["boxes"].shape							, _snake_case						)
								A_								=    torch.tensor([0.5_5_0_3, 0.2_7_6_5, 0.0_6_0_4, 0.2_2_1_5]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["boxes"][0]							, _snake_case							, atol=1e-3						)						)
								# verify image_id
								A_								=    torch.tensor([39_769]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["image_id"]							, _snake_case						)						)
								# verify is_crowd
								A_								=    torch.tensor([0, 0, 0, 0, 0, 0]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["iscrowd"]							, _snake_case						)						)
								# verify class_labels
								A_								=    torch.tensor([75, 75, 63, 65, 17, 17]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["class_labels"]							, _snake_case						)						)
								# verify orig_size
								A_								=    torch.tensor([480, 640]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["orig_size"]							, _snake_case						)						)
								# verify size
								A_								=    torch.tensor([800, 1_066]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["size"]							, _snake_case						)						)






			@slow
			def   lowerCamelCase__  (					self    :       str						)   ->			str:







								"""simple docstring"""
								# prepare image, target and masks_path
								A_								=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
								with open("./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt"							, "r"						) as f:
													A_								=    json.loads(f.read()						)

								A_								=    {"file_name": "000000039769.png", "image_id": 39_769, "segments_info": target}

								A_								=    pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic"						)

								# encode them
								A_								=    ConditionalDetrImageProcessor(format="coco_panoptic"						)
								A_								=    image_processing(images=_snake_case							, annotations=_snake_case							, masks_path=_snake_case							, return_tensors="pt"						)

								# verify pixel values
								A_								=    torch.Size([1, 3, 800, 1_066]						)
								self.assertEqual(encoding["pixel_values"].shape							, _snake_case						)

								A_								=    torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]						)
								self.assertTrue(torch.allclose(encoding["pixel_values"][0, 0, 0, :3]							, _snake_case							, atol=1e-4						)						)

								# verify area
								A_								=    torch.tensor([1_4_7_9_7_9.6_8_7_5, 1_6_5_5_2_7.0_4_6_9, 4_8_4_6_3_8.5_9_3_8, 1_1_2_9_2.9_3_7_5, 5_8_7_9.6_5_6_2, 7_6_3_4.1_1_4_7]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["area"]							, _snake_case						)						)
								# verify boxes
								A_								=    torch.Size([6, 4]						)
								self.assertEqual(encoding["labels"][0]["boxes"].shape							, _snake_case						)
								A_								=    torch.tensor([0.2_6_2_5, 0.5_4_3_7, 0.4_6_8_8, 0.8_6_2_5]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["boxes"][0]							, _snake_case							, atol=1e-3						)						)
								# verify image_id
								A_								=    torch.tensor([39_769]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["image_id"]							, _snake_case						)						)
								# verify is_crowd
								A_								=    torch.tensor([0, 0, 0, 0, 0, 0]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["iscrowd"]							, _snake_case						)						)
								# verify class_labels
								A_								=    torch.tensor([17, 17, 63, 75, 75, 93]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["class_labels"]							, _snake_case						)						)
								# verify masks
								A_								=    822_873
								self.assertEqual(encoding["labels"][0]["masks"].sum().item()							, _snake_case						)
								# verify orig_size
								A_								=    torch.tensor([480, 640]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["orig_size"]							, _snake_case						)						)
								# verify size
								A_								=    torch.tensor([800, 1_066]						)
								self.assertTrue(torch.allclose(encoding["labels"][0]["size"]							, _snake_case						)						)






"""simple docstring"""





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

from tokenizers import processors

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


if is_sentencepiece_available():
		from .tokenization_mbart import MBartTokenizer
else:
		UpperCamelCase_       :    Dict						      =			None


UpperCamelCase_       :    int						      =			logging.get_logger(__name__)


UpperCamelCase_       :    str						      =			{'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}

UpperCamelCase_       :    List[Any]						      =			{
    '''vocab_file''': {
        '''facebook/mbart-large-en-ro''': (
            '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model'''
        ),
        '''facebook/mbart-large-cc25''': (
            '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model'''
        ),
    },
    '''tokenizer_file''': {
        '''facebook/mbart-large-en-ro''': '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/tokenizer.json''',
        '''facebook/mbart-large-cc25''': '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/tokenizer.json''',
    },
}

UpperCamelCase_       :    Optional[Any]						      =			{
    '''facebook/mbart-large-en-ro''': 1024,
    '''facebook/mbart-large-cc25''': 1024,
}

# fmt: off
UpperCamelCase_       :    str						      =			['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN''']



class __lowerCAmelCase					(       _lowercase   ):




			"""simple docstring"""







			snake_case						   =					VOCAB_FILES_NAMES
			snake_case						   =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			snake_case						   =					PRETRAINED_VOCAB_FILES_MAP
			snake_case						   =					["input_ids", "attention_mask"]
			snake_case						   =					MBartTokenizer

			snake_case						   =					[]
			snake_case						   =					[]




			def __init__(					self    :       List[str]							, _snake_case    :       Tuple=None							, _snake_case    :       int=None							, _snake_case    :       List[Any]="<s>"							, _snake_case    :       Tuple="</s>"							, _snake_case    :       str="</s>"							, _snake_case    :       List[Any]="<s>"							, _snake_case    :       Dict="<unk>"							, _snake_case    :       str="<pad>"							, _snake_case    :       Any="<mask>"							, _snake_case    :       int=None							, _snake_case    :       Optional[int]=None							, _snake_case    :       Any=None							, **_snake_case    :       Union[str, Any]							, )   ->			List[str]:







								"""simple docstring"""
								# Mask token behave like a normal word, i.e. include the space before it
								A_								=    AddedToken(_snake_case							, lstrip=_snake_case							, rstrip=_snake_case						) if isinstance(_snake_case							, _snake_case						) else mask_token

								super().__init__(
								    vocab_file=_snake_case							, tokenizer_file=_snake_case							, bos_token=_snake_case							, eos_token=_snake_case							, sep_token=_snake_case							, cls_token=_snake_case							, unk_token=_snake_case							, pad_token=_snake_case							, mask_token=_snake_case							, src_lang=_snake_case							, tgt_lang=_snake_case							, additional_special_tokens=_snake_case							, **_snake_case							, )

								A_								=    vocab_file
								A_								=    False if not self.vocab_file else True

								A_								=    FAIRSEQ_LANGUAGE_CODES.copy()

								if additional_special_tokens is not None:
													# Only add those special tokens if they are not already there.
													_additional_special_tokens.extend(
													    [t for t in additional_special_tokens if t not in _additional_special_tokens]						)

								self.add_special_tokens({"additional_special_tokens": _additional_special_tokens}						)
								A_								=    {
								    lang_code: self.convert_tokens_to_ids(_snake_case						) for lang_code in FAIRSEQ_LANGUAGE_CODES
								}

								A_								=    src_lang if src_lang is not None else "en_XX"
								A_								=    self.convert_tokens_to_ids(self._src_lang						)
								A_								=    tgt_lang
								self.set_src_lang_special_tokens(self._src_lang						)




			@property
			def   lowerCamelCase__  (					self    :       Dict						)   ->			str:







								"""simple docstring"""
								return self._src_lang




			@src_lang.setter
			def   lowerCamelCase__  (					self    :       Tuple							, _snake_case    :       str						)   ->			None:







								"""simple docstring"""
								A_								=    new_src_lang
								self.set_src_lang_special_tokens(self._src_lang						)




			def   lowerCamelCase__  (					self    :       Optional[Any]							, _snake_case    :       List[int]							, _snake_case    :       Optional[List[int]] = None						)   ->			List[int]:







								"""simple docstring"""
								if token_ids_a is None:
													return self.prefix_tokens + token_ids_a + self.suffix_tokens
								# We don't expect to process pairs, but leave the pair logic for API consistency
								return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens




			def   lowerCamelCase__  (					self    :       Dict							, _snake_case    :       List[int]							, _snake_case    :       Optional[List[int]] = None						)   ->			List[int]:







								"""simple docstring"""
								A_								=    [self.sep_token_id]
								A_								=    [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 + sep + token_ids_a + sep						) * [0]




			def   lowerCamelCase__  (					self    :       List[Any]							, _snake_case    :       str							, _snake_case    :       str							, _snake_case    :       Optional[str]							, _snake_case    :       Optional[str]							, **_snake_case    :       Optional[int]						)   ->			str:







								"""simple docstring"""
								if src_lang is None or tgt_lang is None:
													raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model"						)
								A_								=    src_lang
								A_								=    self(_snake_case							, add_special_tokens=_snake_case							, return_tensors=_snake_case							, **_snake_case						)
								A_								=    self.convert_tokens_to_ids(_snake_case						)
								A_								=    tgt_lang_id
								return inputs




			def   lowerCamelCase__  (					self    :       Dict							, _snake_case    :       List[str]							, _snake_case    :       str = "en_XX"							, _snake_case    :       Optional[List[str]] = None							, _snake_case    :       str = "ro_RO"							, **_snake_case    :       str							, )   ->			BatchEncoding:







								"""simple docstring"""
								A_								=    src_lang
								A_								=    tgt_lang
								return super().prepare_seqaseq_batch(_snake_case							, _snake_case							, **_snake_case						)




			def   lowerCamelCase__  (					self    :       Any						)   ->			Optional[Any]:







								"""simple docstring"""
								return self.set_src_lang_special_tokens(self.src_lang						)




			def   lowerCamelCase__  (					self    :       Dict						)   ->			List[Any]:







								"""simple docstring"""
								return self.set_tgt_lang_special_tokens(self.tgt_lang						)




			def   lowerCamelCase__  (					self    :       Tuple							, _snake_case    :       List[str]						)   ->			None:







								"""simple docstring"""
								A_								=    self.convert_tokens_to_ids(_snake_case						)
								A_								=    []
								A_								=    [self.eos_token_id, self.cur_lang_code]

								A_								=    self.convert_ids_to_tokens(self.prefix_tokens						)
								A_								=    self.convert_ids_to_tokens(self.suffix_tokens						)

								A_								=    processors.TemplateProcessing(
								    single=prefix_tokens_str + ["$A"] + suffix_tokens_str							, pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str							, special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str							, self.prefix_tokens + self.suffix_tokens						)						)							, )




			def   lowerCamelCase__  (					self    :       List[str]							, _snake_case    :       str						)   ->			None:







								"""simple docstring"""
								A_								=    self.convert_tokens_to_ids(_snake_case						)
								A_								=    []
								A_								=    [self.eos_token_id, self.cur_lang_code]

								A_								=    self.convert_ids_to_tokens(self.prefix_tokens						)
								A_								=    self.convert_ids_to_tokens(self.suffix_tokens						)

								A_								=    processors.TemplateProcessing(
								    single=prefix_tokens_str + ["$A"] + suffix_tokens_str							, pair=prefix_tokens_str + ["$A", "$B"] + suffix_tokens_str							, special_tokens=list(zip(prefix_tokens_str + suffix_tokens_str							, self.prefix_tokens + self.suffix_tokens						)						)							, )






			def   lowerCamelCase__  (					self    :       Union[str, Any]							, _snake_case    :       str							, _snake_case    :       Optional[str] = None						)   ->			Tuple[str]:







								"""simple docstring"""
								if not self.can_save_slow_tokenizer:
													raise ValueError(
													    "Your fast tokenizer does not have the necessary information to save the vocabulary for a slow "
													    "tokenizer."						)

								if not os.path.isdir(_snake_case						):
													logger.error(F'Vocabulary path ({save_directory}) should be a directory.'						)
													return
								A_								=    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,)




