



"""simple docstring"""





import os
import zipfile

import pytest

from datasets.utils.extract import (
    BzipaExtractor,
    Extractor,
    GzipExtractor,
    LzaExtractor,
    SevenZipExtractor,
    TarExtractor,
    XzExtractor,
    ZipExtractor,
    ZstdExtractor,
)

from .utils import require_lza, require_pyazr, require_zstandard
@pytest.mark.parametrize(
    """compression_format, is_archive"""					, [
        ("""7z""", True),
        ("""bz2""", False),
        ("""gzip""", False),
        ("""lz4""", False),
        ("""tar""", True),
        ("""xz""", False),
        ("""zip""", True),
        ("""zstd""", False),
    ]					, )
def 	__lowerCAmelCase						(		__UpperCamelCase      :			List[str]					, __UpperCamelCase      :			Optional[Any]					, __UpperCamelCase      :			Dict					, __UpperCamelCase      :			List[str]					, __UpperCamelCase      :			Optional[Any]					, __UpperCamelCase      :			Optional[Any]					, __UpperCamelCase      :			Any					, __UpperCamelCase      :			str					, __UpperCamelCase      :			Any					, __UpperCamelCase      :			Any					, __UpperCamelCase      :			Tuple					, __UpperCamelCase      :			Optional[int]					, ):


						'''simple docstring'''






						snake_case_   : int						=			{
						    """7z""": (seven_zip_file, SevenZipExtractor),
						    """bz2""": (bza_file, BzipaExtractor),
						    """gzip""": (gz_file, GzipExtractor),
						    """lz4""": (lza_file, LzaExtractor),
						    """tar""": (tar_file, TarExtractor),
						    """xz""": (xz_file, XzExtractor),
						    """zip""": (zip_file, ZipExtractor),
						    """zstd""": (zstd_file, ZstdExtractor),
						}
						snake_case_			,		snake_case_   : List[Any]						=			input_paths_and_base_extractors[compression_format]
						if input_path is None:
												snake_case_   : Optional[Any]						=			F'for \'{compression_format}\' compression_format, '
												if compression_format == "7z":
																		reason += require_pyazr.kwargs["reason"]
												elif compression_format == "lz4":
																		reason += require_lza.kwargs["reason"]
												elif compression_format == "zstd":
																		reason += require_zstandard.kwargs["reason"]
												pytest.skip(__UpperCamelCase    )
						assert base_extractor.is_extractable(__UpperCamelCase    )
						snake_case_   : Tuple						=			tmp_path / ("""extracted""" if is_archive else """extracted.txt""")
						base_extractor.extract(__UpperCamelCase					, __UpperCamelCase    )
						if is_archive:
												assert output_path.is_dir()
												for file_path in output_path.iterdir():
																		assert file_path.name == text_file.name
																		snake_case_   : Optional[Any]						=			file_path.read_text(encoding="""utf-8"""    )
						else:
												snake_case_   : Dict						=			output_path.read_text(encoding="""utf-8"""    )
						snake_case_   : Any						=			text_file.read_text(encoding="""utf-8"""    )
						assert extracted_file_content == expected_file_content
@pytest.mark.parametrize(
    """compression_format, is_archive"""					, [
        ("""7z""", True),
        ("""bz2""", False),
        ("""gzip""", False),
        ("""lz4""", False),
        ("""tar""", True),
        ("""xz""", False),
        ("""zip""", True),
        ("""zstd""", False),
    ]					, )
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int					, __UpperCamelCase      :			List[Any]					, __UpperCamelCase      :			Dict					, __UpperCamelCase      :			Tuple					, __UpperCamelCase      :			str					, __UpperCamelCase      :			Tuple					, __UpperCamelCase      :			Optional[Any]					, __UpperCamelCase      :			Optional[Any]					, __UpperCamelCase      :			str					, __UpperCamelCase      :			Any					, __UpperCamelCase      :			Dict					, __UpperCamelCase      :			int					, ):


						'''simple docstring'''






						snake_case_   : int						=			{
						    """7z""": seven_zip_file,
						    """bz2""": bza_file,
						    """gzip""": gz_file,
						    """lz4""": lza_file,
						    """tar""": tar_file,
						    """xz""": xz_file,
						    """zip""": zip_file,
						    """zstd""": zstd_file,
						}
						snake_case_   : Tuple						=			input_paths[compression_format]
						if input_path is None:
												snake_case_   : str						=			F'for \'{compression_format}\' compression_format, '
												if compression_format == "7z":
																		reason += require_pyazr.kwargs["reason"]
												elif compression_format == "lz4":
																		reason += require_lza.kwargs["reason"]
												elif compression_format == "zstd":
																		reason += require_zstandard.kwargs["reason"]
												pytest.skip(__UpperCamelCase    )
						snake_case_   : str						=			Extractor.infer_extractor_format(__UpperCamelCase    )
						assert extractor_format is not None
						snake_case_   : List[Any]						=			tmp_path / ("""extracted""" if is_archive else """extracted.txt""")
						Extractor.extract(__UpperCamelCase					, __UpperCamelCase					, __UpperCamelCase    )
						if is_archive:
												assert output_path.is_dir()
												for file_path in output_path.iterdir():
																		assert file_path.name == text_file.name
																		snake_case_   : Optional[int]						=			file_path.read_text(encoding="""utf-8"""    )
						else:
												snake_case_   : str						=			output_path.read_text(encoding="""utf-8"""    )
						snake_case_   : Union[str, Any]						=			text_file.read_text(encoding="""utf-8"""    )
						assert extracted_file_content == expected_file_content
@pytest.fixture
def 	__lowerCAmelCase						(		__UpperCamelCase      :			List[str]					, __UpperCamelCase      :			Dict    ):


						'''simple docstring'''






						import tarfile

						snake_case_   : Any						=			tmp_path / """data_dot_dot"""
						directory.mkdir()
						snake_case_   : Dict						=			directory / """tar_file_with_dot_dot.tar"""
						with tarfile.TarFile(__UpperCamelCase					, """w"""    ) as f:
												f.add(__UpperCamelCase					, arcname=os.path.join(""".."""					, text_file.name    )    )
						return path
@pytest.fixture
def 	__lowerCAmelCase						(		__UpperCamelCase      :			str    ):


						'''simple docstring'''






						import tarfile

						snake_case_   : List[str]						=			tmp_path / """data_sym_link"""
						directory.mkdir()
						snake_case_   : Optional[Any]						=			directory / """tar_file_with_sym_link.tar"""
						os.symlink(""".."""					, directory / """subdir"""					, target_is_directory=__UpperCamelCase    )
						with tarfile.TarFile(__UpperCamelCase					, """w"""    ) as f:
												f.add(str(directory / """subdir"""    )					, arcname="""subdir"""    )  # str required by os.readlink on Windows and Python < 3.8
						return path
@pytest.mark.parametrize(
    """insecure_tar_file, error_log"""					, [("""tar_file_with_dot_dot""", """illegal path"""), ("""tar_file_with_sym_link""", """Symlink""")]					, )
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Optional[int]					, __UpperCamelCase      :			Optional[Any]					, __UpperCamelCase      :			Dict					, __UpperCamelCase      :			Optional[Any]					, __UpperCamelCase      :			int					, __UpperCamelCase      :			Union[str, Any]    ):


						'''simple docstring'''






						snake_case_   : Optional[int]						=			{
						    """tar_file_with_dot_dot""": tar_file_with_dot_dot,
						    """tar_file_with_sym_link""": tar_file_with_sym_link,
						}
						snake_case_   : Dict						=			insecure_tar_files[insecure_tar_file]
						snake_case_   : str						=			tmp_path / """extracted"""
						TarExtractor.extract(__UpperCamelCase					, __UpperCamelCase    )
						assert caplog.text
						for record in caplog.records:
												assert record.levelname == "ERROR"
												assert error_log in record.msg






def 	__lowerCAmelCase						(		__UpperCamelCase      :			Optional[int]    ):


						'''simple docstring'''






						snake_case_   : int						=			tmpdir / """not_a_zip_file"""
						# From: https://github.com/python/cpython/pull/5053
						snake_case_   : Optional[Any]						=			(
						    B"""\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00"""
						    B"""\x00\x02\x08\x06\x00\x00\x00\x99\x81\xb6'\x00\x00\x00\x15I"""
						    B"""DATx\x01\x01\n\x00\xf5\xff\x00PK\x05\x06\x00PK\x06\x06\x07"""
						    B"""\xac\x01N\xc6|a\r\x00\x00\x00\x00IEND\xaeB`\x82"""
						)
						with not_a_zip_file.open("""wb"""    ) as f:
												f.write(__UpperCamelCase    )
						assert zipfile.is_zipfile(str(__UpperCamelCase    )    )  # is a false positive for `zipfile`
						assert not ZipExtractor.is_extractable(__UpperCamelCase    )  # but we're right






"""simple docstring"""





def 	__lowerCAmelCase						(		__UpperCamelCase      :			int					, __UpperCamelCase      :			int    ):


						'''simple docstring'''






						snake_case_   : Any						=			1  # To kept the Calculated Value
						# Since C(n, k) = C(n, n-k)
						if k > (n - k):
												snake_case_   : Optional[int]						=			n - k
						# Calculate C(n,k)
						for i in range(__UpperCamelCase    ):
												result *= n - i
												result //= i + 1
						return result
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						return binomial_coefficient(2 * node_count					, __UpperCamelCase    ) // (node_count + 1)
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						if n < 0:
												raise ValueError("""factorial() not defined for negative values"""    )
						snake_case_   : Optional[int]						=			1
						for i in range(1					, n + 1    ):
												result *= i
						return result
def 	__lowerCAmelCase						(		__UpperCamelCase      :			int    ):


						'''simple docstring'''






						return catalan_number(__UpperCamelCase    ) * factorial(__UpperCamelCase    )


if __name__ == "__main__":
					__lowerCAmelCase       :					Optional[Any]      					=					int(input('''Enter the number of nodes: ''').strip() or 0)
					if node_count <= 0:
										raise ValueError('''We need some nodes to work with.''')
					print(
					    F'''Given {node_count} nodes, there are {binary_tree_count(node_count)} '''
					    F'''binary trees and {catalan_number(node_count)} binary search trees.'''
					)

