




import os
from pathlib import Path
from unittest.mock import patch

import pytest
import zstandard as zstd

from datasets.download.download_config import DownloadConfig
from datasets.utils.file_utils import (
    OfflineModeIsEnabled,
    cached_path,
    fsspec_get,
    fsspec_head,
    ftp_get,
    ftp_head,
    get_from_cache,
    http_get,
    http_head,
)


snake_case_ : Optional[Any]    		=       "\\n    Text data.\n    Second line of data."

snake_case_ : Dict    		=       "file"


@pytest.fixture(scope='''session'''       )
def    A						(__A   :    Dict       )   ->      List[str]:







     """simple docstring"""


     UpperCAmelCase_          =							tmp_path_factory.mktemp('''data'''       ) / (FILE_PATH + '''.zstd''')
     UpperCAmelCase_          =							bytes(__A   ,				'''utf-8'''       )
     with zstd.open(__A   ,				'''wb'''       ) as f:
          f.write(__A       )
     return path


@pytest.fixture
def    A						(__A   :    List[str]       )   ->      Dict:







     """simple docstring"""


     with open(os.path.join(tmpfs.local_root_dir   ,				__A       )   ,				'''w'''       ) as f:
          f.write(__A       )
     return FILE_PATH


@pytest.mark.parametrize('''compression_format'''   ,				['''gzip''', '''xz''', '''zstd''']       )
def    A						(__A   :    Tuple   ,				__A   :    Any   ,				__A   :    Optional[int]   ,				__A   :    List[str]   ,				__A   :    Optional[Any]   ,				__A   :    str       )   ->      List[Any]:







     """simple docstring"""


     UpperCAmelCase_          =							{'''gzip''': gz_file, '''xz''': xz_file, '''zstd''': zstd_path}
     UpperCAmelCase_          =							input_paths[compression_format]
     UpperCAmelCase_          =							tmp_path / '''cache'''
     UpperCAmelCase_          =							DownloadConfig(cache_dir=__A   ,				extract_compressed_file=__A       )
     UpperCAmelCase_          =							cached_path(__A   ,				download_config=__A       )
     with open(__A       ) as f:
          UpperCAmelCase_          =							f.read()
     with open(__A       ) as f:
          UpperCAmelCase_          =							f.read()
     assert extracted_file_content == expected_file_content


@pytest.mark.parametrize('''default_extracted'''   ,				[True, False]       )
@pytest.mark.parametrize('''default_cache_dir'''   ,				[True, False]       )
def    A						(__A   :    str   ,				__A   :    Any   ,				__A   :    Dict   ,				__A   :    Union[str, Any]   ,				__A   :    Union[str, Any]       )   ->      Any:







     """simple docstring"""


     UpperCAmelCase_          =							'''custom_cache'''
     UpperCAmelCase_          =							'''custom_extracted_dir'''
     UpperCAmelCase_          =							tmp_path / '''custom_extracted_path'''
     if default_extracted:
          UpperCAmelCase_          =							('''downloads''' if default_cache_dir else custom_cache_dir, '''extracted''')
     else:
          monkeypatch.setattr('''datasets.config.EXTRACTED_DATASETS_DIR'''   ,				__A       )
          monkeypatch.setattr('''datasets.config.EXTRACTED_DATASETS_PATH'''   ,				str(__A       )       )
          UpperCAmelCase_          =							custom_extracted_path.parts[-2:] if default_cache_dir else (custom_cache_dir, custom_extracted_dir)

     UpperCAmelCase_          =							xz_file
     UpperCAmelCase_          =							(
         DownloadConfig(extract_compressed_file=__A       )
         if default_cache_dir
         else DownloadConfig(cache_dir=tmp_path / custom_cache_dir   ,				extract_compressed_file=__A       )
     )
     UpperCAmelCase_          =							cached_path(__A   ,				download_config=__A       )
     assert Path(__A       ).parent.parts[-2:] == expected


def    A						(__A   :    Tuple       )   ->      Dict:







     """simple docstring"""


     UpperCAmelCase_          =							str(Path(__A       ).resolve()       )
     assert cached_path(__A       ) == text_file
     # relative path
     UpperCAmelCase_          =							str(Path(__A       ).resolve().relative_to(Path(os.getcwd()       )       )       )
     assert cached_path(__A       ) == text_file


def    A						(__A   :    List[Any]       )   ->      str:







     """simple docstring"""


     UpperCAmelCase_          =							str(tmp_path.resolve() / '''__missing_file__.txt'''       )
     with pytest.raises(__A       ):
          cached_path(__A       )
     # relative path
     UpperCAmelCase_          =							'''./__missing_file__.txt'''
     with pytest.raises(__A       ):
          cached_path(__A       )


def    A						(__A   :    Optional[int]       )   ->      List[str]:







     """simple docstring"""


     UpperCAmelCase_          =							get_from_cache(F"""tmp://{tmpfs_file}"""       )
     with open(__A       ) as f:
          UpperCAmelCase_          =							f.read()
     assert output_file_content == FILE_CONTENT


@patch('''datasets.config.HF_DATASETS_OFFLINE'''   ,				__A       )
def    A						()   ->      Any:







     """simple docstring"""


     with pytest.raises(__A       ):
          cached_path('''https://huggingface.co'''       )


@patch('''datasets.config.HF_DATASETS_OFFLINE'''   ,				__A       )
def    A						(__A   :    Optional[int]       )   ->      str:







     """simple docstring"""


     UpperCAmelCase_          =							tmp_path_factory.mktemp('''data'''       ) / '''file.html'''
     with pytest.raises(__A       ):
          http_get('''https://huggingface.co'''   ,				temp_file=__A       )
     with pytest.raises(__A       ):
          http_head('''https://huggingface.co'''       )


@patch('''datasets.config.HF_DATASETS_OFFLINE'''   ,				__A       )
def    A						(__A   :    List[str]       )   ->      List[str]:







     """simple docstring"""


     UpperCAmelCase_          =							tmp_path_factory.mktemp('''data'''       ) / '''file.html'''
     with pytest.raises(__A       ):
          ftp_get('''ftp://huggingface.co'''   ,				temp_file=__A       )
     with pytest.raises(__A       ):
          ftp_head('''ftp://huggingface.co'''       )


@patch('''datasets.config.HF_DATASETS_OFFLINE'''   ,				__A       )
def    A						(__A   :    Optional[int]       )   ->      List[str]:







     """simple docstring"""


     UpperCAmelCase_          =							tmp_path_factory.mktemp('''data'''       ) / '''file.html'''
     with pytest.raises(__A       ):
          fsspec_get('''s3://huggingface.co'''   ,				temp_file=__A       )
     with pytest.raises(__A       ):
          fsspec_head('''s3://huggingface.co'''       )











from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


SCREAMING_SNAKE_CASE_:str             =						{
    """configuration_transfo_xl""": ["""TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """TransfoXLConfig"""],
    """tokenization_transfo_xl""": ["""TransfoXLCorpus""", """TransfoXLTokenizer"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     SCREAMING_SNAKE_CASE_:Union[str, Any]             =						[
         """TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """AdaptiveEmbedding""",
         """TransfoXLForSequenceClassification""",
         """TransfoXLLMHeadModel""",
         """TransfoXLModel""",
         """TransfoXLPreTrainedModel""",
         """load_tf_weights_in_transfo_xl""",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     SCREAMING_SNAKE_CASE_:Any             =						[
         """TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """TFAdaptiveEmbedding""",
         """TFTransfoXLForSequenceClassification""",
         """TFTransfoXLLMHeadModel""",
         """TFTransfoXLMainLayer""",
         """TFTransfoXLModel""",
         """TFTransfoXLPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
     from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_transfo_xl import (
              TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
              AdaptiveEmbedding,
              TransfoXLForSequenceClassification,
              TransfoXLLMHeadModel,
              TransfoXLModel,
              TransfoXLPreTrainedModel,
              load_tf_weights_in_transfo_xl,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_transfo_xl import (
              TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFAdaptiveEmbedding,
              TFTransfoXLForSequenceClassification,
              TFTransfoXLLMHeadModel,
              TFTransfoXLMainLayer,
              TFTransfoXLModel,
              TFTransfoXLPreTrainedModel,
          )

else:
     import sys

     SCREAMING_SNAKE_CASE_:Dict             =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


