code: 
  
  
  '''simple docstring'''
  
  import importlib
  import os
  import platform
  from pathlib import Path
  
  from packaging import version
  
  from .utils.logging import get_logger
  
  
  __lowercase:		Dict							=     get_logger(__name__)
  
  # Datasets
  __lowercase:		Optional[Any]							=     "https://s3.amazonaws.com/datasets.huggingface.co/datasets/datasets"
  __lowercase:		Optional[int]							=     "https://cdn-datasets.huggingface.co/datasets/datasets"
  __lowercase:		Tuple							=     "https://raw.githubusercontent.com/huggingface/datasets/{revision}/datasets/{path}/{name}"
  
  # Metrics
  __lowercase:		Any							=     "https://s3.amazonaws.com/datasets.huggingface.co/datasets/metrics"
  __lowercase:		Any							=     "https://cdn-datasets.huggingface.co/datasets/metric"
  __lowercase:		List[Any]							=     "https://raw.githubusercontent.com/huggingface/datasets/{revision}/metrics/{path}/{name}"
  
  # Hub
  __lowercase:		Any							=     os.environ.get("HF_ENDPOINT", "https://huggingface.co")
  __lowercase:		Any							=     HF_ENDPOINT + "/datasets/{repo_id}/resolve/{revision}/{path}"
  __lowercase:		List[str]							=     "main"
  
  __lowercase:		Optional[Any]							=     version.parse(platform.python_version())
  
  if PY_VERSION < version.parse("3.8"):
         import importlib_metadata
  else:
         import importlib.metadata as importlib_metadata
  
  # General environment variables accepted values for booleans
  __lowercase:		Dict							=     {"1", "ON", "YES", "TRUE"}
  __lowercase:		Dict							=     ENV_VARS_TRUE_VALUES.union({"AUTO"})
  
  
  # Imports
  __lowercase:		Union[str, Any]							=     version.parse(importlib_metadata.version("dill"))
  __lowercase:		List[str]							=     version.parse(importlib_metadata.version("pandas"))
  __lowercase:		str							=     version.parse(importlib_metadata.version("pyarrow"))
  
  __lowercase:		Tuple							=     os.environ.get("USE_TF", "AUTO").upper()
  __lowercase:		Optional[Any]							=     os.environ.get("USE_TORCH", "AUTO").upper()
  __lowercase:		Any							=     os.environ.get("USE_JAX", "AUTO").upper()
  
  __lowercase:		int							=     "N/A"
  __lowercase:		Union[str, Any]							=     False
  
  if USE_TORCH in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TF not in ENV_VARS_TRUE_VALUES:
         __lowercase:		str							=     importlib.util.find_spec("torch") is not None
         if TORCH_AVAILABLE:
                try:
                       __lowercase:		Dict							=     version.parse(importlib_metadata.version("torch"))
                       logger.info(F"""PyTorch version {TORCH_VERSION} available.""")
                except importlib_metadata.PackageNotFoundError:
                       pass
  else:
         logger.info("Disabling PyTorch because USE_TF is set")
  
  __lowercase:		Optional[int]							=     "N/A"
  __lowercase:		Any							=     False
  
  if USE_TF in ENV_VARS_TRUE_AND_AUTO_VALUES and USE_TORCH not in ENV_VARS_TRUE_VALUES:
         __lowercase:		Optional[Any]							=     importlib.util.find_spec("tensorflow") is not None
         if TF_AVAILABLE:
                # For the metadata, we have to look for both tensorflow and tensorflow-cpu
                for package in [
                    "tensorflow",
                    "tensorflow-cpu",
                    "tensorflow-gpu",
                    "tf-nightly",
                    "tf-nightly-cpu",
                    "tf-nightly-gpu",
                    "intel-tensorflow",
                    "tensorflow-rocm",
                    "tensorflow-macos",
                ]:
                       try:
                              __lowercase:		Optional[Any]							=     version.parse(importlib_metadata.version(package))
                       except importlib_metadata.PackageNotFoundError:
                              continue
                       else:
                              break
                else:
                       __lowercase:		int							=     False
         if TF_AVAILABLE:
                if TF_VERSION.major < 2:
                       logger.info(F"""TensorFlow found but with version {TF_VERSION}. `datasets` requires version 2 minimum.""")
                       __lowercase:		Any							=     False
                else:
                       logger.info(F"""TensorFlow version {TF_VERSION} available.""")
  else:
         logger.info("Disabling Tensorflow because USE_TORCH is set")
  
  
  __lowercase:		int							=     "N/A"
  __lowercase:		Optional[Any]							=     False
  
  if USE_JAX in ENV_VARS_TRUE_AND_AUTO_VALUES:
         __lowercase:		List[Any]							=     importlib.util.find_spec("jax") is not None and importlib.util.find_spec("jaxlib") is not None
         if JAX_AVAILABLE:
                try:
                       __lowercase:		Optional[Any]							=     version.parse(importlib_metadata.version("jax"))
                       logger.info(F"""JAX version {JAX_VERSION} available.""")
                except importlib_metadata.PackageNotFoundError:
                       pass
  else:
         logger.info("Disabling JAX because USE_JAX is set to False")
  
  
  __lowercase:		int							=     os.environ.get("USE_BEAM", "AUTO").upper()
  __lowercase:		List[str]							=     "N/A"
  __lowercase:		List[Any]							=     False
  if USE_BEAM in ENV_VARS_TRUE_AND_AUTO_VALUES:
         try:
                __lowercase:		Dict							=     version.parse(importlib_metadata.version("apache_beam"))
                __lowercase:		Optional[Any]							=     True
                logger.info(F"""Apache Beam version {BEAM_VERSION} available.""")
         except importlib_metadata.PackageNotFoundError:
                pass
  else:
         logger.info("Disabling Apache Beam because USE_BEAM is set to False")
  
  
  # Optional tools for data loading
  __lowercase:		List[str]							=     importlib.util.find_spec("sqlalchemy") is not None
  
  # Optional tools for feature decoding
  __lowercase:		int							=     importlib.util.find_spec("PIL") is not None
  __lowercase:		Any							=     importlib.util.find_spec("soundfile") is not None and version.parse(
      importlib.import_module("soundfile").__libsndfile_version__
  ) >= version.parse("1.0.31")
  __lowercase:		Tuple							=     importlib.util.find_spec("soundfile") is not None and version.parse(
      importlib.import_module("soundfile").__libsndfile_version__
  ) >= version.parse("1.1.0")
  
  # Optional compression tools
  __lowercase:		Dict							=     importlib.util.find_spec("rarfile") is not None
  __lowercase:		Dict							=     importlib.util.find_spec("zstandard") is not None
  __lowercase:		Optional[Any]							=     importlib.util.find_spec("lz4") is not None
  __lowercase:		Optional[Any]							=     importlib.util.find_spec("py7zr") is not None
  
  
  # Cache location
  __lowercase:		str							=     "~/.cache"
  __lowercase:		List[Any]							=     os.getenv("XDG_CACHE_HOME", DEFAULT_XDG_CACHE_HOME)
  __lowercase:		Tuple							=     os.path.join(XDG_CACHE_HOME, "huggingface")
  __lowercase:		Any							=     os.path.expanduser(os.getenv("HF_HOME", DEFAULT_HF_CACHE_HOME))
  
  __lowercase:		str							=     os.path.join(HF_CACHE_HOME, "datasets")
  __lowercase:		str							=     Path(os.getenv("HF_DATASETS_CACHE", DEFAULT_HF_DATASETS_CACHE))
  
  __lowercase:		Union[str, Any]							=     os.path.join(HF_CACHE_HOME, "metrics")
  __lowercase:		Optional[int]							=     Path(os.getenv("HF_METRICS_CACHE", DEFAULT_HF_METRICS_CACHE))
  
  __lowercase:		Dict							=     os.path.join(HF_CACHE_HOME, "modules")
  __lowercase:		List[str]							=     Path(os.getenv("HF_MODULES_CACHE", DEFAULT_HF_MODULES_CACHE))
  
  __lowercase:		Any							=     "downloads"
  __lowercase:		Optional[Any]							=     os.path.join(HF_DATASETS_CACHE, DOWNLOADED_DATASETS_DIR)
  __lowercase:		Dict							=     Path(os.getenv("HF_DATASETS_DOWNLOADED_DATASETS_PATH", DEFAULT_DOWNLOADED_DATASETS_PATH))
  
  __lowercase:		Optional[Any]							=     "extracted"
  __lowercase:		Optional[Any]							=     os.path.join(DEFAULT_DOWNLOADED_DATASETS_PATH, EXTRACTED_DATASETS_DIR)
  __lowercase:		List[Any]							=     Path(os.getenv("HF_DATASETS_EXTRACTED_DATASETS_PATH", DEFAULT_EXTRACTED_DATASETS_PATH))
  
  # Download count for the website
  __lowercase:		Optional[Any]							=     (
      os.environ.get("HF_UPDATE_DOWNLOAD_COUNTS", "AUTO").upper() in ENV_VARS_TRUE_AND_AUTO_VALUES
  )
  
  # Batch size constants. For more info, see:
  # https://github.com/apache/arrow/blob/master/docs/source/cpp/arrays.rst#size-limitations-and-recommendations)
  __lowercase:		List[Any]							=     1_000
  
  # Size of the preloaded record batch in `Dataset.__iter__`
  __lowercase:		List[str]							=     10
  
  # Pickling tables works only for small tables (<4GiB)
  # For big tables, we write them on disk instead
  __lowercase:		int							=     4 << 30
  
  # Max shard size in bytes (e.g. to shard parquet datasets in push_to_hub or download_and_prepare)
  __lowercase:		Union[str, Any]							=     "500MB"
  
  # Parquet configuration
  __lowercase:		Optional[Any]							=     100
  __lowercase:		int							=     100
  __lowercase:		List[Any]							=     100
  
  # Offline mode
  __lowercase:		str							=     os.environ.get("HF_DATASETS_OFFLINE", "AUTO").upper() in ENV_VARS_TRUE_VALUES
  
  # In-memory
  __lowercase:		Any							=     0  # Disabled
  __lowercase:		Optional[int]							=     float(os.environ.get("HF_DATASETS_IN_MEMORY_MAX_SIZE", DEFAULT_IN_MEMORY_MAX_SIZE))
  
  # File names
  __lowercase:		List[Any]							=     "dataset.arrow"
  __lowercase:		str							=     "indices.arrow"
  __lowercase:		str							=     "state.json"
  __lowercase:		str							=     "dataset_info.json"
  __lowercase:		Any							=     "dataset_infos.json"
  __lowercase:		Any							=     "LICENSE"
  __lowercase:		Optional[Any]							=     "metric_info.json"
  __lowercase:		int							=     "dataset_dict.json"
  
  __lowercase:		Optional[int]							=     "datasets_modules"
  
  __lowercase:		Tuple							=     255
  
  # Streaming
  __lowercase:		List[Any]							=     20
  __lowercase:		Dict							=     5
  
  # Datasets without script
  __lowercase:		str							=     200
  __lowercase:		Optional[Any]							=     10
  __lowercase:		Optional[int]							=     200
  
  # Progress bars
  __lowercase:		Union[str, Any]							=     0.0_5  # 20 progress updates per sec
style_context: 
  
  
  '''simple docstring'''
  
  from transformers import SqueezeBertTokenizer, SqueezeBertTokenizerFast
  from transformers.testing_utils import require_tokenizers, slow
  
  from ..bert.test_tokenization_bert import BertTokenizationTest
  
  
  
  
  
  
  
  @require_tokenizers
  class  UpperCAmelCase (       SCREAMING_SNAKE_CASE__):
   _lowerCamelCase :					Optional[int]    					=					SqueezeBertTokenizer
   _lowerCamelCase :					List[Any]    					=					SqueezeBertTokenizerFast
   _lowerCamelCase :					int    					=					True
  
   def 		lowercase_						( self :	List[str],					**a_ :	str					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      return SqueezeBertTokenizerFast.from_pretrained(self.tmpdirname,					**a_					)
  
   @slow
   def 		lowercase_						( self :	int					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      UpperCamelCase__ 						=						SqueezeBertTokenizer.from_pretrained("squeezebert/squeezebert-mnli-headless"					)
  
      UpperCamelCase__ 						=						tokenizer.encode("sequence builders",					add_special_tokens=a_					)
      UpperCamelCase__ 						=						tokenizer.encode("multi-sequence build",					add_special_tokens=a_					)
  
      UpperCamelCase__ 						=						tokenizer.build_inputs_with_special_tokens(a_					)
      UpperCamelCase__ 						=						tokenizer.build_inputs_with_special_tokens(a_,					a_					)
  
      assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
      assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
          tokenizer.sep_token_id
      ]