




from timeit import timeit

a__		     =     {
    '''MALAYALAM''': True,
    '''String''': False,
    '''rotor''': True,
    '''level''': True,
    '''A''': True,
    '''BB''': True,
    '''ABC''': False,
    '''amanaplanacanalpanama''': True,  # "a man a plan a canal panama"
}
# Ensure our test data is valid
assert all((key == key[::-1]) is value for key, value in test_data.items())





def 				A__ (snake_case   :		str				)     ->						bool:
					__UpperCamelCase					:	Union[str, Any]             =      0
					__UpperCamelCase					:	List[Any]             =      len(snake_case				) - 1
					while start_i < end_i:
										if s[start_i] == s[end_i]:
															start_i += 1
															end_i -= 1
										else:
															return False
					return True





def 				A__ (snake_case   :		str				)     ->						bool:
					__UpperCamelCase					:	Any             =      len(snake_case				) // 2
					__UpperCamelCase					:	Optional[Any]             =      len(snake_case				)

					# We need to traverse till half of the length of string
					# as we can get access of the i'th last element from
					# i'th index.
					# eg: [0,1,2,3,4,5] => 4th index can be accessed
					# with the help of 1st index (i==n-i-1)
					# where n is length of string
					return all(s[i] == s[n - i - 1] for i in range(snake_case				)				)





def 				A__ (snake_case   :		str				)     ->						bool:
					if len(snake_case				) <= 2:
										return True
					if s[0] == s[len(snake_case				) - 1]:
										return is_palindrome_recursive(s[1:-1]				)
					else:
										return False





def 				A__ (snake_case   :		str				)     ->						bool:
					return s == s[::-1]





def 				A__ (snake_case   :		str				)     ->						None:
					__UpperCamelCase					:	str             =      F'''all({name}(key) is value for key, value in test_data.items())'''
					__UpperCamelCase					:	Tuple             =      F'''from __main__ import test_data, {name}'''
					__UpperCamelCase					:	Optional[int]             =      50_00_00
					__UpperCamelCase					:	Dict             =      timeit(stmt=snake_case		,	setup=snake_case		,	number=snake_case				)
					print(F'''{name:<35} finished {number:,} runs in {result:.5f} seconds'''				)


if __name__ == "__main__":
	for key, value in test_data.items():
		assert is_palindrome(key) is is_palindrome_recursive(key)
		assert is_palindrome(key) is is_palindrome_slice(key)
		print(f"{key:21} {value}")
	print('''a man a plan a canal panama''')

	# finished 500,000 runs in 0.46793 seconds
	benchmark_function('''is_palindrome_slice''')
	# finished 500,000 runs in 0.85234 seconds
	benchmark_function('''is_palindrome''')
	# finished 500,000 runs in 1.32028 seconds
	benchmark_function('''is_palindrome_recursive''')
	# finished 500,000 runs in 2.08679 seconds
	benchmark_function('''is_palindrome_traversal''')












import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import ClassLabel, Features, Image
from .base import TaskTemplate


@dataclass(frozen=_UpperCamelCase   )
class    SCREAMING_SNAKE_CASE_				(       _UpperCamelCase   ):



	"""simple docstring"""


	__magic_name__   :       str      	=		field(default='image-classification'	,  metadata={'include_in_asdict_even_if_is_default': True}   )
	__magic_name__   :       ClassVar[Features]      	=		Features({'image': Image()}   )
	__magic_name__   :       ClassVar[Features]      	=		Features({'labels': ClassLabel}   )
	__magic_name__   :       str      	=		"image"
	__magic_name__   :       str      	=		"labels"






	def 					lowerCamelCase__     (					self		:						Any					,     lowerCAmelCase		:						Optional[Any]	)	->       Union[str, Any]:







						"""simple docstring"""







						if self.label_column not in features:
											raise ValueError(F'''Column {self.label_column} is not present in features.'''	)
						if not isinstance(features[self.label_column]					,     lowerCAmelCase	):
											raise ValueError(F'''Column {self.label_column} is not a ClassLabel.'''	)
						__UpperCamelCase					:	List[str]             =      copy.deepcopy(self	)
						__UpperCamelCase					:	List[Any]             =      self.label_schema.copy()
						__UpperCamelCase					:	List[str]             =      features[self.label_column]
						__UpperCamelCase					:	List[str]             =      label_schema
						return task_template






	@property
	def 					lowerCamelCase__     (					self		:						List[Any]	)	->       Dict[str, str]:







						"""simple docstring"""







						return {
						    self.image_column: "image",
						    self.label_column: "labels",
						}






