



"""simple docstring"""
import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


A:   str								=		logging.get_logger(__name__)


A:   Dict								=		{"vocab_file": "vocab.json", "merges_file": "merges.txt"}

# See all BART models at https://huggingface.co/models?filter=bart
A:   int								=		{
    "vocab_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/vocab.json",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/vocab.json",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json",
    },
    "merges_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/merges.txt",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/merges.txt",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt",
    },
}

A:   str								=		{
    "facebook/bart-base": 1_0_2_4,
    "facebook/bart-large": 1_0_2_4,
    "facebook/bart-large-mnli": 1_0_2_4,
    "facebook/bart-large-cnn": 1_0_2_4,
    "facebook/bart-large-xsum": 1_0_2_4,
    "yjernite/bart_eli5": 1_0_2_4,
}

@lru_cache()
def       _snake_case						(						):
 UpperCAmelCase	:					List[Any]	=	(
     list(range(ord("""!"""						)			,		ord("""~"""						) + 1						)						) + list(range(ord("""¡"""						)			,		ord("""¬"""						) + 1						)						) + list(range(ord("""®"""						)			,		ord("""ÿ"""						) + 1						)						)
 )
 UpperCAmelCase	:					List[str]	=	bs[:]
 UpperCAmelCase	:					Any	=	0
 for b in range(2**8						):
  if b not in bs:
   bs.append(UpperCamelCase						)
   cs.append(2**8 + n						)
   n += 1
 UpperCAmelCase	:					Tuple	=	[chr(UpperCamelCase						) for n in cs]
 return dict(zip(UpperCamelCase			,		UpperCamelCase						)						)

def       _snake_case						(						UpperCamelCase						:		Dict						):
 UpperCAmelCase	:					Union[str, Any]	=	set()
 UpperCAmelCase	:					int	=	word[0]
 for char in word[1:]:
  pairs.add((prev_char, char)						)
  UpperCAmelCase	:					Any	=	char
 return pairs



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):
   __lowerCAmelCase  :   List[str]						=						VOCAB_FILES_NAMES
   __lowerCAmelCase  :   Any						=						PRETRAINED_VOCAB_FILES_MAP
   __lowerCAmelCase  :   List[str]						=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
   __lowerCAmelCase  :   int						=						['input_ids', 'attention_mask']

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE="replace"      ,     _SCREAMING_SNAKE_CASE="<s>"      ,     _SCREAMING_SNAKE_CASE="</s>"      ,     _SCREAMING_SNAKE_CASE="</s>"      ,     _SCREAMING_SNAKE_CASE="<s>"      ,     _SCREAMING_SNAKE_CASE="<unk>"      ,     _SCREAMING_SNAKE_CASE="<pad>"      ,     _SCREAMING_SNAKE_CASE="<mask>"      ,     _SCREAMING_SNAKE_CASE=False      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					List[Any]	=	AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE      ,     rstrip=_SCREAMING_SNAKE_CASE						) if isinstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) else bos_token
    UpperCAmelCase	:					List[Any]	=	AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE      ,     rstrip=_SCREAMING_SNAKE_CASE						) if isinstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) else eos_token
    UpperCAmelCase	:					Optional[int]	=	AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE      ,     rstrip=_SCREAMING_SNAKE_CASE						) if isinstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) else sep_token
    UpperCAmelCase	:					Union[str, Any]	=	AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE      ,     rstrip=_SCREAMING_SNAKE_CASE						) if isinstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) else cls_token
    UpperCAmelCase	:					Union[str, Any]	=	AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE      ,     rstrip=_SCREAMING_SNAKE_CASE						) if isinstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) else unk_token
    UpperCAmelCase	:					Tuple	=	AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE      ,     rstrip=_SCREAMING_SNAKE_CASE						) if isinstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) else pad_token

    # Mask token behave like a normal word, i.e. include the space before it
    UpperCAmelCase	:					List[str]	=	AddedToken(_SCREAMING_SNAKE_CASE      ,     lstrip=_SCREAMING_SNAKE_CASE      ,     rstrip=_SCREAMING_SNAKE_CASE						) if isinstance(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) else mask_token

    super().__init__(
        errors=_SCREAMING_SNAKE_CASE      ,     bos_token=_SCREAMING_SNAKE_CASE      ,     eos_token=_SCREAMING_SNAKE_CASE      ,     unk_token=_SCREAMING_SNAKE_CASE      ,     sep_token=_SCREAMING_SNAKE_CASE      ,     cls_token=_SCREAMING_SNAKE_CASE      ,     pad_token=_SCREAMING_SNAKE_CASE      ,     mask_token=_SCREAMING_SNAKE_CASE      ,     add_prefix_space=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE      ,     )

    with open(_SCREAMING_SNAKE_CASE      ,     encoding="""utf-8"""						) as vocab_handle:
     UpperCAmelCase	:					str	=	json.load(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[Any]	=	{v: k for k, v in self.encoder.items()}
    UpperCAmelCase	:					int	=	errors  # how to handle errors in decoding
    UpperCAmelCase	:					str	=	bytes_to_unicode()
    UpperCAmelCase	:					Tuple	=	{v: k for k, v in self.byte_encoder.items()}
    with open(_SCREAMING_SNAKE_CASE      ,     encoding="""utf-8"""						) as merges_handle:
     UpperCAmelCase	:					Union[str, Any]	=	merges_handle.read().split("""\n"""						)[1:-1]
    UpperCAmelCase	:					Dict	=	[tuple(merge.split()						) for merge in bpe_merges]
    UpperCAmelCase	:					Union[str, Any]	=	dict(zip(_SCREAMING_SNAKE_CASE      ,     range(len(_SCREAMING_SNAKE_CASE						)						)						)						)
    UpperCAmelCase	:					Optional[Any]	=	{}
    UpperCAmelCase	:					str	=	add_prefix_space

    # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
    UpperCAmelCase	:					List[Any]	=	re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""						)

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    return len(self.encoder						)

   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Any:





    '''simple docstring'''




    return dict(self.encoder      ,     **self.added_tokens_encoder						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      Optional[Any]:





    '''simple docstring'''




    if token in self.cache:
     return self.cache[token]
    UpperCAmelCase	:					List[str]	=	tuple(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Optional[int]	=	get_pairs(_SCREAMING_SNAKE_CASE						)

    if not pairs:
     return token

    while True:
     UpperCAmelCase	:					Union[str, Any]	=	min(_SCREAMING_SNAKE_CASE      ,     key=lambda _SCREAMING_SNAKE_CASE						: self.bpe_ranks.get(_SCREAMING_SNAKE_CASE      ,     float("""inf"""						)						)						)
     if bigram not in self.bpe_ranks:
      break
     UpperCAmelCase	,		UpperCAmelCase	:					Optional[int]	=	bigram
     UpperCAmelCase	:					Optional[Any]	=	[]
     UpperCAmelCase	:					Optional[Any]	=	0
     while i < len(_SCREAMING_SNAKE_CASE						):
      try:
       UpperCAmelCase	:					List[str]	=	word.index(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
      except ValueError:
       new_word.extend(word[i:]						)
       break
      else:
       new_word.extend(word[i:j]						)
       UpperCAmelCase	:					Union[str, Any]	=	j

      if word[i] == first and i < len(_SCREAMING_SNAKE_CASE						) - 1 and word[i + 1] == second:
       new_word.append(first + second						)
       i += 2
      else:
       new_word.append(word[i]						)
       i += 1
     UpperCAmelCase	:					Union[str, Any]	=	tuple(_SCREAMING_SNAKE_CASE						)
     UpperCAmelCase	:					Dict	=	new_word
     if len(_SCREAMING_SNAKE_CASE						) == 1:
      break
     else:
      UpperCAmelCase	:					Union[str, Any]	=	get_pairs(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					List[Any]	=	""" """.join(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Tuple	=	word
    return word

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      List[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	[]
    for token in re.findall(self.pat      ,     _SCREAMING_SNAKE_CASE						):
     UpperCAmelCase	:					Tuple	=	"""""".join(
         self.byte_encoder[b] for b in token.encode("""utf-8"""						)						)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
     bpe_tokens.extend(bpe_token for bpe_token in self.bpe(_SCREAMING_SNAKE_CASE						).split(""" """						)						)
    return bpe_tokens

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      List[Any]:





    '''simple docstring'''




    return self.encoder.get(_SCREAMING_SNAKE_CASE      ,     self.encoder.get(self.unk_token						)						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      int:





    '''simple docstring'''




    return self.decoder.get(_SCREAMING_SNAKE_CASE						)

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE						)  ->      Optional[int]:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	"""""".join(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Union[str, Any]	=	bytearray([self.byte_decoder[c] for c in text]						).decode("""utf-8"""      ,     errors=self.errors						)
    return text

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None						)  ->      Tuple[str]:





    '''simple docstring'''




    if not os.path.isdir(_SCREAMING_SNAKE_CASE						):
     logger.error(F"Vocabulary path ({save_directory}) should be a directory"						)
     return
    UpperCAmelCase	:					int	=	os.path.join(
        _SCREAMING_SNAKE_CASE      ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]						)
    UpperCAmelCase	:					Optional[int]	=	os.path.join(
        _SCREAMING_SNAKE_CASE      ,     (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]						)

    with open(_SCREAMING_SNAKE_CASE      ,     """w"""      ,     encoding="""utf-8"""						) as f:
     f.write(json.dumps(self.encoder      ,     indent=2      ,     sort_keys=_SCREAMING_SNAKE_CASE      ,     ensure_ascii=_SCREAMING_SNAKE_CASE						) + """\n"""						)

    UpperCAmelCase	:					Optional[Any]	=	0
    with open(_SCREAMING_SNAKE_CASE      ,     """w"""      ,     encoding="""utf-8"""						) as writer:
     writer.write("""#version: 0.2\n"""						)
     for bpe_tokens, token_index in sorted(self.bpe_ranks.items()      ,     key=lambda _SCREAMING_SNAKE_CASE						: kv[1]						):
      if index != token_index:
       logger.warning(
           F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
           """ Please check that the tokenizer is not corrupted!"""						)
       UpperCAmelCase	:					str	=	token_index
      writer.write(""" """.join(_SCREAMING_SNAKE_CASE						) + """\n"""						)
      index += 1

    return vocab_file, merge_file

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None						)  ->      List[int]:





    '''simple docstring'''




    if token_ids_a is None:
     return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
    UpperCAmelCase	:					List[str]	=	[self.cls_token_id]
    UpperCAmelCase	:					Dict	=	[self.sep_token_id]
    return cls + token_ids_a + sep + sep + token_ids_a + sep

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = False						)  ->      List[int]:





    '''simple docstring'''




    if already_has_special_tokens:
     return super().get_special_tokens_mask(
         token_ids_a=_SCREAMING_SNAKE_CASE      ,     token_ids_a=_SCREAMING_SNAKE_CASE      ,     already_has_special_tokens=_SCREAMING_SNAKE_CASE						)

    if token_ids_a is None:
     return [1] + ([0] * len(_SCREAMING_SNAKE_CASE						)) + [1]
    return [1] + ([0] * len(_SCREAMING_SNAKE_CASE						)) + [1, 1] + ([0] * len(_SCREAMING_SNAKE_CASE						)) + [1]

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None						)  ->      List[int]:





    '''simple docstring'''




    UpperCAmelCase	:					Dict	=	[self.sep_token_id]
    UpperCAmelCase	:					Optional[int]	=	[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 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE=False      ,     **_SCREAMING_SNAKE_CASE						)  ->      Optional[Any]:





    '''simple docstring'''




    UpperCAmelCase	:					int	=	kwargs.pop("""add_prefix_space"""      ,     self.add_prefix_space						)
    if (is_split_into_words or add_prefix_space) and (len(_SCREAMING_SNAKE_CASE						) > 0 and not text[0].isspace()):
     UpperCAmelCase	:					Optional[Any]	=	""" """ + text
    return (text, kwargs)




'''simple docstring'''






import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


__A					:  str											=      get_tests_dir("fixtures")






class    __snake_case       (   unittest.TestCase):







    """simple docstring"""



    def __lowercase   (   self    :  int		)   ->  List[str]:
      # A mock response for an HTTP head request to emulate server down
      lowerCAmelCase_			:      str			=   mock.Mock()
      lowerCAmelCase_			:      Optional[Any]			=   5_00
      lowerCAmelCase_			:      List[str]			=   {}
      lowerCAmelCase_			:      str			=   HTTPError
      lowerCAmelCase_			:      Any			=   {}

      # Download this model to make sure it's in the cache.
      lowerCAmelCase_			:      Optional[Any]			=   WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2"""		)
      # Under the mock environment we get a 500 error when trying to reach the model.
      with mock.patch("""requests.Session.request"""    ,						return_value=lowerCamelCase		) as mock_head:
        lowerCAmelCase_			:      Union[str, Any]			=   WavaVecaFeatureExtractor.from_pretrained("""hf-internal-testing/tiny-random-wav2vec2"""		)
        # This check we did call the fake head request
        mock_head.assert_called()





    def __lowercase   (   self    :  Dict		)   ->  Any:
      # This test is for deprecated behavior and can be removed in v5
      lowerCAmelCase_			:      List[str]			=   WavaVecaFeatureExtractor.from_pretrained(
          """https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"""		)







@is_staging_test
class    __snake_case       (   unittest.TestCase):







    """simple docstring"""



    @classmethod
    def __lowercase   (   cls    :  Tuple		)   ->  str:
      lowerCAmelCase_			:      Dict			=   TOKEN
      HfFolder.save_token(lowerCamelCase		)

    @classmethod
    def __lowercase   (   cls    :  Any		)   ->  Any:
      try:
        delete_repo(token=cls._token    ,						repo_id="""test-feature-extractor"""		)
      except HTTPError:
        pass

      try:
        delete_repo(token=cls._token    ,						repo_id="""valid_org/test-feature-extractor-org"""		)
      except HTTPError:
        pass

      try:
        delete_repo(token=cls._token    ,						repo_id="""test-dynamic-feature-extractor"""		)
      except HTTPError:
        pass

    def __lowercase   (   self    :  int		)   ->  str:
      lowerCAmelCase_			:      Tuple			=   WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase		)
      feature_extractor.push_to_hub("""test-feature-extractor"""    ,						use_auth_token=self._token		)

      lowerCAmelCase_			:      Optional[Any]			=   WavaVecaFeatureExtractor.from_pretrained(F'{USER}/test-feature-extractor'		)
      for k, v in feature_extractor.__dict__.items():
        self.assertEqual(lowerCamelCase    ,						getattr(lowerCamelCase    ,						lowerCamelCase		)		)

      # Reset repo
      delete_repo(token=self._token    ,						repo_id="""test-feature-extractor"""		)

      # Push to hub via save_pretrained
      with tempfile.TemporaryDirectory() as tmp_dir:
        feature_extractor.save_pretrained(
            lowerCamelCase    ,						repo_id="""test-feature-extractor"""    ,						push_to_hub=lowerCamelCase    ,						use_auth_token=self._token		)

      lowerCAmelCase_			:      Any			=   WavaVecaFeatureExtractor.from_pretrained(F'{USER}/test-feature-extractor'		)
      for k, v in feature_extractor.__dict__.items():
        self.assertEqual(lowerCamelCase    ,						getattr(lowerCamelCase    ,						lowerCamelCase		)		)

    def __lowercase   (   self    :  Optional[Any]		)   ->  int:
      lowerCAmelCase_			:      Union[str, Any]			=   WavaVecaFeatureExtractor.from_pretrained(lowerCamelCase		)
      feature_extractor.push_to_hub("""valid_org/test-feature-extractor"""    ,						use_auth_token=self._token		)

      lowerCAmelCase_			:      Optional[int]			=   WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor"""		)
      for k, v in feature_extractor.__dict__.items():
        self.assertEqual(lowerCamelCase    ,						getattr(lowerCamelCase    ,						lowerCamelCase		)		)

      # Reset repo
      delete_repo(token=self._token    ,						repo_id="""valid_org/test-feature-extractor"""		)

      # Push to hub via save_pretrained
      with tempfile.TemporaryDirectory() as tmp_dir:
        feature_extractor.save_pretrained(
            lowerCamelCase    ,						repo_id="""valid_org/test-feature-extractor-org"""    ,						push_to_hub=lowerCamelCase    ,						use_auth_token=self._token		)

      lowerCAmelCase_			:      Optional[int]			=   WavaVecaFeatureExtractor.from_pretrained("""valid_org/test-feature-extractor-org"""		)
      for k, v in feature_extractor.__dict__.items():
        self.assertEqual(lowerCamelCase    ,						getattr(lowerCamelCase    ,						lowerCamelCase		)		)





    def __lowercase   (   self    :  Optional[Any]		)   ->  Any:
      CustomFeatureExtractor.register_for_auto_class()
      lowerCAmelCase_			:      Dict			=   CustomFeatureExtractor.from_pretrained(lowerCamelCase		)

      feature_extractor.push_to_hub("""test-dynamic-feature-extractor"""    ,						use_auth_token=self._token		)

      # This has added the proper auto_map field to the config
      self.assertDictEqual(
          feature_extractor.auto_map    ,						{"""AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor"""}    ,						)

      lowerCAmelCase_			:      Union[str, Any]			=   AutoFeatureExtractor.from_pretrained(
          F'{USER}/test-dynamic-feature-extractor'    ,						trust_remote_code=lowerCamelCase		)
      # Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
      self.assertEqual(new_feature_extractor.__class__.__name__    ,						"""CustomFeatureExtractor"""		)



