



'''simple docstring'''






from collections import Counter
from timeit import timeit


def 				snake_case_  (      _lowerCAmelCase						:		str = ""     ,   )   ->     bool:
							return sum(c % 2 for c in Counter(input_str.replace(''' '''     ,   ''''''						).lower()						).values()						) < 2


def 				snake_case_  (      _lowerCAmelCase						:		str = ""						)   ->     bool:
							if len(_lowerCAmelCase						) == 0:
														return True
							UpperCAmelCase				: Any											=	input_str.replace(''' '''     ,   ''''''						).lower()
							# character_freq_dict: Stores the frequency of every character in the input string
							UpperCAmelCase				: dict[str, int]											=	{}

							for character in lower_case_input_str:
														UpperCAmelCase				: Optional[Any]											=	character_freq_dict.get(_lowerCAmelCase     ,   0						) + 1
							UpperCAmelCase				: Any											=	0

							for character_count in character_freq_dict.values():
														if character_count % 2:
																					odd_char += 1
							if odd_char > 1:
														return False
							return True


def 				snake_case_  (      _lowerCAmelCase						:		str = ""						)   ->     None:
							print('''\nFor string = '''     ,   _lowerCAmelCase     ,   ''':'''						)
							print(
							    '''> can_string_be_rearranged_as_palindrome_counter()'''     ,   '''\tans ='''     ,   can_string_be_rearranged_as_palindrome_counter(_lowerCAmelCase						)     ,   '''\ttime ='''     ,   timeit(
							        '''z.can_string_be_rearranged_as_palindrome_counter(z.check_str)'''     ,   setup='''import __main__ as z'''     ,   )     ,   '''seconds'''     ,   )
							print(
							    '''> can_string_be_rearranged_as_palindrome()'''     ,   '''\tans ='''     ,   can_string_be_rearranged_as_palindrome(_lowerCAmelCase						)     ,   '''\ttime ='''     ,   timeit(
							        '''z.can_string_be_rearranged_as_palindrome(z.check_str)'''     ,   setup='''import __main__ as z'''     ,   )     ,   '''seconds'''     ,   )


if __name__ == "__main__":
						UpperCamelCase__:     Optional[int]										=    input(
						    "Enter string to determine if it can be rearranged as a palindrome or not: "
						).strip()
						benchmark(check_str)
						UpperCamelCase__:     str										=    can_string_be_rearranged_as_palindrome_counter(check_str)
						print(F"{check_str} can {'' if status else 'not '}be rearranged as a palindrome")










'''simple docstring'''






import contextlib
import os
import sqlitea

import pytest

from datasets import Dataset, Features, Value
from datasets.io.sql import SqlDatasetReader, SqlDatasetWriter

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases, require_sqlalchemy


def 				snake_case_  (      _lowerCAmelCase						:		int     ,   _lowerCAmelCase						:		Tuple						)   ->     str:
							assert isinstance(_lowerCAmelCase     ,   _lowerCAmelCase						)
							assert dataset.num_rows == 4
							assert dataset.num_columns == 3
							assert dataset.column_names == ["col_1", "col_2", "col_3"]
							for feature, expected_dtype in expected_features.items():
														assert dataset.features[feature].dtype == expected_dtype


@require_sqlalchemy
@pytest.mark.parametrize('''keep_in_memory'''     ,   [False, True]						)
def 				snake_case_  (      _lowerCAmelCase						:		Union[str, Any]     ,   _lowerCAmelCase						:		List[str]     ,   _lowerCAmelCase						:		Any     ,   _lowerCAmelCase						:		Optional[Any]						)   ->     List[str]:
							UpperCAmelCase				: int											=	tmp_path / '''cache'''
							UpperCAmelCase				: Dict											=	{'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
							with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
														UpperCAmelCase				: Any											=	SqlDatasetReader(
														    '''dataset'''     ,   '''sqlite:///''' + sqlite_path     ,   cache_dir=_lowerCAmelCase     ,   keep_in_memory=_lowerCAmelCase						).read()
							_check_sql_dataset(_lowerCAmelCase     ,   _lowerCAmelCase						)


@require_sqlalchemy
@pytest.mark.parametrize(
    '''features'''     ,   [
        None,
        {'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''},
        {'''col_1''': '''string''', '''col_2''': '''string''', '''col_3''': '''string'''},
        {'''col_1''': '''int32''', '''col_2''': '''int32''', '''col_3''': '''int32'''},
        {'''col_1''': '''float32''', '''col_2''': '''float32''', '''col_3''': '''float32'''},
    ]     ,   )
def 				snake_case_  (      _lowerCAmelCase						:		int     ,   _lowerCAmelCase						:		Any     ,   _lowerCAmelCase						:		Optional[int]     ,   _lowerCAmelCase						:		str						)   ->     Optional[int]:
							UpperCAmelCase				: Union[str, Any]											=	tmp_path / '''cache'''
							UpperCAmelCase				: Union[str, Any]											=	{'''col_1''': '''string''', '''col_2''': '''int64''', '''col_3''': '''float64'''}
							UpperCAmelCase				: str											=	features.copy() if features else default_expected_features
							UpperCAmelCase				: Optional[Any]											=	(
							    Features({feature: Value(_lowerCAmelCase						) for feature, dtype in features.items()}						) if features is not None else None
							)
							UpperCAmelCase				: Tuple											=	SqlDatasetReader('''dataset'''     ,   '''sqlite:///''' + sqlite_path     ,   features=_lowerCAmelCase     ,   cache_dir=_lowerCAmelCase						).read()
							_check_sql_dataset(_lowerCAmelCase     ,   _lowerCAmelCase						)


def 				snake_case_  (      _lowerCAmelCase						:		List[Any]						)   ->     Dict:
							with contextlib.closing(sqlitea.connect(_lowerCAmelCase						)						) as con:
														UpperCAmelCase				: Any											=	con.cursor()
														cur.execute('''SELECT * FROM dataset'''						)
														for row in cur:
																					yield row


@require_sqlalchemy
def 				snake_case_  (      _lowerCAmelCase						:		Union[str, Any]     ,   _lowerCAmelCase						:		str     ,   _lowerCAmelCase						:		Any						)   ->     Optional[int]:
							UpperCAmelCase				: Optional[int]											=	tmp_path / '''cache'''
							UpperCAmelCase				: int											=	os.path.join(_lowerCAmelCase     ,   '''tmp.sql'''						)
							UpperCAmelCase				: Any											=	SqlDatasetReader('''dataset'''     ,   '''sqlite:///''' + sqlite_path     ,   cache_dir=_lowerCAmelCase						).read()
							SqlDatasetWriter(_lowerCAmelCase     ,   '''dataset'''     ,   '''sqlite:///''' + output_sqlite_path     ,   num_proc=1						).write()

							UpperCAmelCase				: List[Any]											=	iter_sql_file(_lowerCAmelCase						)
							UpperCAmelCase				: List[Any]											=	iter_sql_file(_lowerCAmelCase						)

							for rowa, rowa in zip(_lowerCAmelCase     ,   _lowerCAmelCase						):
														assert rowa == rowa


@require_sqlalchemy
def 				snake_case_  (      _lowerCAmelCase						:		int     ,   _lowerCAmelCase						:		Optional[Any]     ,   _lowerCAmelCase						:		Union[str, Any]						)   ->     int:
							UpperCAmelCase				: Optional[Any]											=	tmp_path / '''cache'''
							UpperCAmelCase				: Any											=	os.path.join(_lowerCAmelCase     ,   '''tmp.sql'''						)
							UpperCAmelCase				: List[str]											=	SqlDatasetReader('''dataset'''     ,   '''sqlite:///''' + sqlite_path     ,   cache_dir=_lowerCAmelCase						).read()
							SqlDatasetWriter(_lowerCAmelCase     ,   '''dataset'''     ,   '''sqlite:///''' + output_sqlite_path     ,   num_proc=2						).write()

							UpperCAmelCase				: List[str]											=	iter_sql_file(_lowerCAmelCase						)
							UpperCAmelCase				: Any											=	iter_sql_file(_lowerCAmelCase						)

							for rowa, rowa in zip(_lowerCAmelCase     ,   _lowerCAmelCase						):
														assert rowa == rowa




@require_sqlalchemy
def 				snake_case_  (      _lowerCAmelCase						:		Union[str, Any]     ,   _lowerCAmelCase						:		Any     ,   _lowerCAmelCase						:		Optional[Any]						)   ->     List[Any]:
							UpperCAmelCase				: Union[str, Any]											=	tmp_path / '''cache'''
							UpperCAmelCase				: Tuple											=	os.path.join(_lowerCAmelCase     ,   '''tmp.sql'''						)
							UpperCAmelCase				: Optional[int]											=	SqlDatasetReader('''dataset'''     ,   '''sqlite:///''' + sqlite_path     ,   cache_dir=_lowerCAmelCase						).read()
							with pytest.raises(_lowerCAmelCase						):
														SqlDatasetWriter(_lowerCAmelCase     ,   '''dataset'''     ,   '''sqlite:///''' + output_sqlite_path     ,   num_proc=0						).write()





