


"""simple docstring"""

from operator import delitem, getitem, setitem

import pytest

from data_structures.hashing.hash_map import HashMap


def lowerCAmelCase_      (				UpperCamelCase__	: Any ):






 """simple docstring"""







 return getitem, k


def lowerCAmelCase_      (				UpperCamelCase__	: List[str]				,   UpperCamelCase__	: Any ):






 """simple docstring"""







 return setitem, k, v


def lowerCAmelCase_      (				UpperCamelCase__	: int ):






 """simple docstring"""







 return delitem, k


def lowerCAmelCase_      (				UpperCamelCase__	: Optional[int]				,   UpperCamelCase__	: Optional[Any]				,   *UpperCamelCase__	: str ):






 """simple docstring"""







 try:
  return fun(UpperCamelCase__				,   *UpperCamelCase__ ), None
 except Exception as e:
  return None, e


UpperCAmelCase__  							=(
    _set("key_a", "val_a"),
    _set("key_b", "val_b"),
)

UpperCAmelCase__  							=[
    _set("key_a", "val_a"),
    _set("key_a", "val_b"),
]

UpperCAmelCase__  							=[
    _set("key_a", "val_a"),
    _set("key_b", "val_b"),
    _del("key_a"),
    _del("key_b"),
    _set("key_a", "val_a"),
    _del("key_a"),
]

UpperCAmelCase__  							=[
    _get("key_a"),
    _del("key_a"),
    _set("key_a", "val_a"),
    _del("key_a"),
    _del("key_a"),
    _get("key_a"),
]

UpperCAmelCase__  							=[
    *[_set(x, x) for x in range(5)],  # guaranteed upsize
]

UpperCAmelCase__  							=[
    *[_set(x, x) for x in range(5)],  # guaranteed upsize
    *[_del(x) for x in range(5)],
    _set("key_a", "val_b"),
]


@pytest.mark.parametrize(
    """operations"""				,   (
        pytest.param(_add_items				,   id="""add items""" ),
        pytest.param(_overwrite_items				,   id="""overwrite items""" ),
        pytest.param(_delete_items				,   id="""delete items""" ),
        pytest.param(_access_absent_items				,   id="""access absent items""" ),
        pytest.param(_add_with_resize_up				,   id="""add with resize up""" ),
        pytest.param(_add_with_resize_down				,   id="""add with resize down""" ),
    )				,   )
def lowerCAmelCase_      (				UpperCamelCase__	: Optional[int] ):






 """simple docstring"""







 __lowercase									=	HashMap(initial_block_size=4 )
 __lowercase									=	{}
 for _, (fun, *args) in enumerate(UpperCamelCase__ ):
  __lowercase							,		__lowercase									=	_run_operation(UpperCamelCase__				,   UpperCamelCase__				,   *UpperCamelCase__ )
  __lowercase							,		__lowercase									=	_run_operation(UpperCamelCase__				,   UpperCamelCase__				,   *UpperCamelCase__ )
  assert my_res == py_res
  assert str(UpperCamelCase__ ) == str(UpperCamelCase__ )
  assert set(UpperCamelCase__ ) == set(UpperCamelCase__ )
  assert len(UpperCamelCase__ ) == len(UpperCamelCase__ )
  assert set(my.items() ) == set(py.items() )


def lowerCAmelCase_      (				):






 """simple docstring"""







 def is_public(UpperCamelCase__	: str ) -> bool:
  return not name.startswith("""_""" )

 __lowercase									=	{name for name in dir({} ) if is_public(UpperCamelCase__ )}
 __lowercase									=	{name for name in dir(HashMap() ) if is_public(UpperCamelCase__ )}

 assert dict_public_names > hash_public_names




"""simple docstring"""

import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.text import TextDatasetReader

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases


def lowerCAmelCase_      (				UpperCamelCase__	: List[str]				,   UpperCamelCase__	: Any ):






 """simple docstring"""







 assert isinstance(UpperCamelCase__				,   UpperCamelCase__ )
 assert dataset.num_rows == 4
 assert dataset.num_columns == 1
 assert dataset.column_names == ["text"]
 for feature, expected_dtype in expected_features.items():
  assert dataset.features[feature].dtype == expected_dtype


@pytest.mark.parametrize("""keep_in_memory"""				,   [False, True] )
def lowerCAmelCase_      (				UpperCamelCase__	: Dict				,   UpperCamelCase__	: Optional[int]				,   UpperCamelCase__	: List[str] ):






 """simple docstring"""







 __lowercase									=	tmp_path / """cache"""
 __lowercase									=	{"""text""": """string"""}
 with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
  __lowercase									=	TextDatasetReader(UpperCamelCase__				,   cache_dir=UpperCamelCase__				,   keep_in_memory=UpperCamelCase__ ).read()
 _check_text_dataset(UpperCamelCase__				,   UpperCamelCase__ )


@pytest.mark.parametrize(
    """features"""				,   [
        None,
        {"""text""": """string"""},
        {"""text""": """int32"""},
        {"""text""": """float32"""},
    ]				,   )
def lowerCAmelCase_      (				UpperCamelCase__	: List[Any]				,   UpperCamelCase__	: List[str]				,   UpperCamelCase__	: Union[str, Any] ):






 """simple docstring"""







 __lowercase									=	tmp_path / """cache"""
 __lowercase									=	{"""text""": """string"""}
 __lowercase									=	features.copy() if features else default_expected_features
 __lowercase									=	(
     Features({feature: Value(UpperCamelCase__ ) for feature, dtype in features.items()} ) if features is not None else None
 )
 __lowercase									=	TextDatasetReader(UpperCamelCase__				,   features=UpperCamelCase__				,   cache_dir=UpperCamelCase__ ).read()
 _check_text_dataset(UpperCamelCase__				,   UpperCamelCase__ )


@pytest.mark.parametrize("""split"""				,   [None, NamedSplit("""train""" ), """train""", """test"""] )
def lowerCAmelCase_      (				UpperCamelCase__	: Union[str, Any]				,   UpperCamelCase__	: str				,   UpperCamelCase__	: Tuple ):






 """simple docstring"""







 __lowercase									=	tmp_path / """cache"""
 __lowercase									=	{"""text""": """string"""}
 __lowercase									=	TextDatasetReader(UpperCamelCase__				,   cache_dir=UpperCamelCase__				,   split=UpperCamelCase__ ).read()
 _check_text_dataset(UpperCamelCase__				,   UpperCamelCase__ )
 assert dataset.split == split if split else "train"


@pytest.mark.parametrize("""path_type"""				,   [str, list] )
def lowerCAmelCase_      (				UpperCamelCase__	: Union[str, Any]				,   UpperCamelCase__	: List[str]				,   UpperCamelCase__	: Any ):






 """simple docstring"""







 if issubclass(UpperCamelCase__				,   UpperCamelCase__ ):
  __lowercase									=	text_path
 elif issubclass(UpperCamelCase__				,   UpperCamelCase__ ):
  __lowercase									=	[text_path]
 __lowercase									=	tmp_path / """cache"""
 __lowercase									=	{"""text""": """string"""}
 __lowercase									=	TextDatasetReader(UpperCamelCase__				,   cache_dir=UpperCamelCase__ ).read()
 _check_text_dataset(UpperCamelCase__				,   UpperCamelCase__ )


def lowerCAmelCase_      (				UpperCamelCase__	: str				,   UpperCamelCase__	: str				,   UpperCamelCase__	: Any=("train",) ):






 """simple docstring"""







 assert isinstance(UpperCamelCase__				,   UpperCamelCase__ )
 for split in splits:
  __lowercase									=	dataset_dict[split]
  assert dataset.num_rows == 4
  assert dataset.num_columns == 1
  assert dataset.column_names == ["text"]
  for feature, expected_dtype in expected_features.items():
   assert dataset.features[feature].dtype == expected_dtype


@pytest.mark.parametrize("""keep_in_memory"""				,   [False, True] )
def lowerCAmelCase_      (				UpperCamelCase__	: int				,   UpperCamelCase__	: List[str]				,   UpperCamelCase__	: List[Any] ):






 """simple docstring"""







 __lowercase									=	tmp_path / """cache"""
 __lowercase									=	{"""text""": """string"""}
 with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
  __lowercase									=	TextDatasetReader({"""train""": text_path}				,   cache_dir=UpperCamelCase__				,   keep_in_memory=UpperCamelCase__ ).read()
 _check_text_datasetdict(UpperCamelCase__				,   UpperCamelCase__ )


@pytest.mark.parametrize(
    """features"""				,   [
        None,
        {"""text""": """string"""},
        {"""text""": """int32"""},
        {"""text""": """float32"""},
    ]				,   )
def lowerCAmelCase_      (				UpperCamelCase__	: Optional[Any]				,   UpperCamelCase__	: Dict				,   UpperCamelCase__	: Union[str, Any] ):






 """simple docstring"""







 __lowercase									=	tmp_path / """cache"""
 # CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
 __lowercase									=	{"""text""": """string"""}
 __lowercase									=	features.copy() if features else default_expected_features
 __lowercase									=	(
     Features({feature: Value(UpperCamelCase__ ) for feature, dtype in features.items()} ) if features is not None else None
 )
 __lowercase									=	TextDatasetReader({"""train""": text_path}				,   features=UpperCamelCase__				,   cache_dir=UpperCamelCase__ ).read()
 _check_text_datasetdict(UpperCamelCase__				,   UpperCamelCase__ )


@pytest.mark.parametrize("""split"""				,   [None, NamedSplit("""train""" ), """train""", """test"""] )
def lowerCAmelCase_      (				UpperCamelCase__	: Dict				,   UpperCamelCase__	: int				,   UpperCamelCase__	: int ):






 """simple docstring"""







 if split:
  __lowercase									=	{split: text_path}
 else:
  __lowercase									=	"""train"""
  __lowercase									=	{"""train""": text_path, """test""": text_path}
 __lowercase									=	tmp_path / """cache"""
 __lowercase									=	{"""text""": """string"""}
 __lowercase									=	TextDatasetReader(UpperCamelCase__				,   cache_dir=UpperCamelCase__ ).read()
 _check_text_datasetdict(UpperCamelCase__				,   UpperCamelCase__				,   splits=list(path.keys() ) )
 assert all(dataset[split].split == split for split in path.keys() )
