




"""simple docstring"""
from collections import defaultdict





def 						UpperCAmelCase				(			A__:    str							,				A__:    str     )  ->     bool:
			__lowerCamelCase					:	str	       =				first_str.lower().strip()
			__lowerCamelCase					:	Optional[int]	       =				second_str.lower().strip()

			# Remove whitespace
			__lowerCamelCase					:	Optional[Any]	       =				first_str.replace(' '							,				''     )
			__lowerCamelCase					:	Optional[Any]	       =				second_str.replace(' '							,				''     )

			# Strings of different lengths are not anagrams
			if len(A__     ) != len(A__     ):
						return False

			# Default values for count should be 0
			__lowerCamelCase					:	defaultdict[str, int]	       =				defaultdict(A__     )

			# For each character in input strings,
			# increment count in the corresponding
			for i in range(len(A__     )     ):
						count[first_str[i]] += 1
						count[second_str[i]] -= 1

			return all(_count == 0 for _count in count.values()     )


if __name__ == "__main__":
					from doctest import testmod

					testmod()
					a_				:    List[str]										=     input('''Enter the first string ''').strip()
					a_				:    Optional[Any]										=     input('''Enter the second string ''').strip()

					a_				:    Tuple										=     check_anagrams(input_a, input_b)
					print(F"""{input_a} and {input_b} are {'' if status else 'not '}anagrams.""")









"""simple docstring"""
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin

class __lowercase(      lowercase__				):




					'''simple docstring'''


					__a						:						List[str]     		= 'Speech2TextFeatureExtractor'
					__a						:						Optional[int]     		= 'Speech2TextTokenizer'
					def __init__(    self						,	__a						,	__a     ):
								super().__init__(__a						,	__a     )
								__lowerCamelCase					:	Union[str, Any]	       =				self.feature_extractor
								__lowerCamelCase					:	List[str]	       =				False
					def __call__(    self						,	*__a						,	**__a     ):
								# For backward compatibility
								if self._in_target_context_manager:
											return self.current_processor(*__a						,	**__a     )

								if "raw_speech" in kwargs:
											warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'     )
											__lowerCamelCase					:	str	       =				kwargs.pop('raw_speech'     )
								else:
											__lowerCamelCase					:	Optional[Any]	       =				kwargs.pop('audio'						,	__a     )
								__lowerCamelCase					:	Optional[Any]	       =				kwargs.pop('sampling_rate'						,	__a     )
								__lowerCamelCase					:	Optional[int]	       =				kwargs.pop('text'						,	__a     )
								if len(__a     ) > 0:
											__lowerCamelCase					:	Optional[int]	       =				args[0]
											__lowerCamelCase					:	str	       =				args[1:]

								if audio is None and text is None:
											raise ValueError('You need to specify either an `audio` or `text` input to process.'     )

								if audio is not None:
											__lowerCamelCase					:	Dict	       =				self.feature_extractor(__a						,	*__a						,	sampling_rate=__a						,	**__a     )
								if text is not None:
											__lowerCamelCase					:	Optional[int]	       =				self.tokenizer(__a						,	**__a     )

								if text is None:
											return inputs
								elif audio is None:
											return encodings
								else:
											__lowerCamelCase					:	Any	       =				encodings['input_ids']
											return inputs
					def     snake_case_				(    self						,	*__a						,	**__a     ):
								return self.tokenizer.batch_decode(*__a						,	**__a     )
					def     snake_case_				(    self						,	*__a						,	**__a     ):
								return self.tokenizer.decode(*__a						,	**__a     )





					@contextmanager
					def     snake_case_				(    self     ):
								warnings.warn(
								    '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
								    'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
								    'your audio inputs, or in a separate call.'     )
								__lowerCamelCase					:	int	       =				True
								__lowerCamelCase					:	Union[str, Any]	       =				self.tokenizer
								yield
								__lowerCamelCase					:	Tuple	       =				self.feature_extractor
								__lowerCamelCase					:	List[str]	       =				False



