






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,
)


UpperCamelCase        =				"\\n    Text data.\n    Second line of data."

UpperCamelCase        =				"file"




@pytest.fixture(scope="""session"""  )
def 				A		(					lowercase__  :  List[str]  )		-> Union[str, Any]:
	UpperCamelCase__ :Optional[int]						=      tmp_path_factory.mktemp("""data"""  ) / (FILE_PATH + """.zstd""")
	UpperCamelCase__ :Optional[Any]						=      bytes(lowercase__ ,		"""utf-8"""  )
	with zstd.open(lowercase__ ,		"""wb"""  ) as f:
		f.write(lowercase__  )
	return path




@pytest.fixture
def 				A		(					lowercase__  :  str  )		-> int:
	with open(os.path.join(tmpfs.local_root_dir ,		lowercase__  ) ,		"""w"""  ) as f:
		f.write(lowercase__  )
	return FILE_PATH




@pytest.mark.parametrize("""compression_format""" ,		["""gzip""", """xz""", """zstd"""]  )
def 				A		(					lowercase__  :  Optional[Any] ,		lowercase__  :  Dict ,		lowercase__  :  int ,		lowercase__  :  List[str] ,		lowercase__  :  Optional[int] ,		lowercase__  :  Any  )		-> Union[str, Any]:
	UpperCamelCase__ :Optional[int]						=      {"""gzip""": gz_file, """xz""": xz_file, """zstd""": zstd_path}
	UpperCamelCase__ :List[Any]						=      input_paths[compression_format]
	UpperCamelCase__ :Tuple						=      tmp_path / """cache"""
	UpperCamelCase__ :Dict						=      DownloadConfig(cache_dir=lowercase__ ,		extract_compressed_file=lowercase__  )
	UpperCamelCase__ :int						=      cached_path(lowercase__ ,		download_config=lowercase__  )
	with open(lowercase__  ) as f:
		UpperCamelCase__ :int						=      f.read()
	with open(lowercase__  ) as f:
		UpperCamelCase__ :Tuple						=      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		(					lowercase__  :  Union[str, Any] ,		lowercase__  :  Dict ,		lowercase__  :  Dict ,		lowercase__  :  Any ,		lowercase__  :  List[Any]  )		-> List[str]:
	UpperCamelCase__ :Dict						=      """custom_cache"""
	UpperCamelCase__ :Union[str, Any]						=      """custom_extracted_dir"""
	UpperCamelCase__ :Optional[int]						=      tmp_path / """custom_extracted_path"""
	if default_extracted:
		UpperCamelCase__ :Union[str, Any]						=      ("""downloads""" if default_cache_dir else custom_cache_dir, """extracted""")
	else:
		monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_DIR""" ,		lowercase__  )
		monkeypatch.setattr("""datasets.config.EXTRACTED_DATASETS_PATH""" ,		str(lowercase__  )  )
		UpperCamelCase__ :Dict						=      custom_extracted_path.parts[-2:] if default_cache_dir else (custom_cache_dir, custom_extracted_dir)

	UpperCamelCase__ :Optional[int]						=      xz_file
	UpperCamelCase__ :Optional[Any]						=      (
	    DownloadConfig(extract_compressed_file=lowercase__  )
	    if default_cache_dir
	    else DownloadConfig(cache_dir=tmp_path / custom_cache_dir ,		extract_compressed_file=lowercase__  )
	)
	UpperCamelCase__ :str						=      cached_path(lowercase__ ,		download_config=lowercase__  )
	assert Path(lowercase__  ).parent.parts[-2:] == expected




def 				A		(					lowercase__  :  List[str]  )		-> Dict:
	# absolute path
	UpperCamelCase__ :Optional[Any]						=      str(Path(lowercase__  ).resolve()  )
	assert cached_path(lowercase__  ) == text_file
	# relative path
	UpperCamelCase__ :str						=      str(Path(lowercase__  ).resolve().relative_to(Path(os.getcwd()  )  )  )
	assert cached_path(lowercase__  ) == text_file




def 				A		(					lowercase__  :  Optional[Any]  )		-> Tuple:
	# absolute path
	UpperCamelCase__ :Tuple						=      str(tmp_path.resolve() / """__missing_file__.txt"""  )
	with pytest.raises(lowercase__  ):
		cached_path(lowercase__  )
	# relative path
	UpperCamelCase__ :Tuple						=      """./__missing_file__.txt"""
	with pytest.raises(lowercase__  ):
		cached_path(lowercase__  )




def 				A		(					lowercase__  :  str  )		-> Optional[int]:
	UpperCamelCase__ :Any						=      get_from_cache(f"""tmp://{tmpfs_file}"""  )
	with open(lowercase__  ) as f:
		UpperCamelCase__ :Tuple						=      f.read()
	assert output_file_content == FILE_CONTENT




@patch("""datasets.config.HF_DATASETS_OFFLINE""" ,		lowercase__  )
def 				A		(					)		-> Tuple:
	with pytest.raises(lowercase__  ):
		cached_path("""https://huggingface.co"""  )




@patch("""datasets.config.HF_DATASETS_OFFLINE""" ,		lowercase__  )
def 				A		(					lowercase__  :  str  )		-> Optional[int]:
	UpperCamelCase__ :Optional[Any]						=      tmp_path_factory.mktemp("""data"""  ) / """file.html"""
	with pytest.raises(lowercase__  ):
		http_get("""https://huggingface.co""" ,		temp_file=lowercase__  )
	with pytest.raises(lowercase__  ):
		http_head("""https://huggingface.co"""  )




@patch("""datasets.config.HF_DATASETS_OFFLINE""" ,		lowercase__  )
def 				A		(					lowercase__  :  List[Any]  )		-> int:
	UpperCamelCase__ :List[str]						=      tmp_path_factory.mktemp("""data"""  ) / """file.html"""
	with pytest.raises(lowercase__  ):
		ftp_get("""ftp://huggingface.co""" ,		temp_file=lowercase__  )
	with pytest.raises(lowercase__  ):
		ftp_head("""ftp://huggingface.co"""  )




@patch("""datasets.config.HF_DATASETS_OFFLINE""" ,		lowercase__  )
def 				A		(					lowercase__  :  Optional[int]  )		-> List[Any]:
	UpperCamelCase__ :Optional[Any]						=      tmp_path_factory.mktemp("""data"""  ) / """file.html"""
	with pytest.raises(lowercase__  ):
		fsspec_get("""s3://huggingface.co""" ,		temp_file=lowercase__  )
	with pytest.raises(lowercase__  ):
		fsspec_head("""s3://huggingface.co"""  )

'''simple docstring'''

import os


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_doctest_list.py
snake_case									=    """."""


if __name__ == "__main__":
     snake_case									=    os.path.join(REPO_PATH, """utils/documentation_tests.txt""")
     snake_case									=    []
     snake_case									=    []
     with open(doctest_file_path) as fp:
          for line in fp:
               snake_case									=    line.strip()
               snake_case									=    os.path.join(REPO_PATH, line)
               if not (os.path.isfile(path) or os.path.isdir(path)):
                    non_existent_paths.append(line)
               all_paths.append(path)
     if len(non_existent_paths) > 0:
          snake_case									=    """\n""".join(non_existent_paths)
          raise ValueError(f'`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}')
     if all_paths != sorted(all_paths):
          raise ValueError("""Files in `utils/documentation_tests.txt` are not in alphabetical order.""")





