



from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCAmelCase__	:  Dict 		=logging.get_logger(__name__)

lowerCAmelCase__	:  str 		={
    '''squeezebert/squeezebert-uncased''': (
        '''https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/config.json'''
    ),
    '''squeezebert/squeezebert-mnli''': '''https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/config.json''',
    '''squeezebert/squeezebert-mnli-headless''': (
        '''https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/config.json'''
    ),
}

class      UpperCAmelCase_						(     UpperCamelCase_ ):

						'''simple docstring'''




						UpperCamelCase__    :				str       						=						SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP
						UpperCamelCase__    :				Union[str, Any]       						=						'''squeezebert'''






						def __init__(					self   ,							_A=30_522   ,							_A=768   ,							_A=12   ,							_A=12   ,							_A=3_072   ,							_A="gelu"   ,							_A=0.1   ,							_A=0.1   ,							_A=512   ,							_A=2   ,							_A=0.0_2   ,							_A=1e-12   ,							_A=0   ,							_A=768   ,							_A=4   ,							_A=4   ,							_A=4   ,							_A=1   ,							_A=4   ,							_A=4   ,							**_A   ,							):







													'''simple docstring'''

													super().__init__(pad_token_id=_A   ,							**_A	)

													__SCREAMING_SNAKE_CASE								=      vocab_size
													__SCREAMING_SNAKE_CASE								=      hidden_size
													__SCREAMING_SNAKE_CASE								=      num_hidden_layers
													__SCREAMING_SNAKE_CASE								=      num_attention_heads
													__SCREAMING_SNAKE_CASE								=      hidden_act
													__SCREAMING_SNAKE_CASE								=      intermediate_size
													__SCREAMING_SNAKE_CASE								=      hidden_dropout_prob
													__SCREAMING_SNAKE_CASE								=      attention_probs_dropout_prob
													__SCREAMING_SNAKE_CASE								=      max_position_embeddings
													__SCREAMING_SNAKE_CASE								=      type_vocab_size
													__SCREAMING_SNAKE_CASE								=      initializer_range
													__SCREAMING_SNAKE_CASE								=      layer_norm_eps
													__SCREAMING_SNAKE_CASE								=      embedding_size
													__SCREAMING_SNAKE_CASE								=      q_groups
													__SCREAMING_SNAKE_CASE								=      k_groups
													__SCREAMING_SNAKE_CASE								=      v_groups
													__SCREAMING_SNAKE_CASE								=      post_attention_groups
													__SCREAMING_SNAKE_CASE								=      intermediate_groups
													__SCREAMING_SNAKE_CASE								=      output_groups







class      UpperCAmelCase_						(     UpperCamelCase_ ):

						'''simple docstring'''




						@property
						def  _A			(					self	):







													'''simple docstring'''

													if self.task == "multiple-choice":
																				__SCREAMING_SNAKE_CASE								=      {0: 'batch', 1: 'choice', 2: 'sequence'}
													else:
																				__SCREAMING_SNAKE_CASE								=      {0: 'batch', 1: 'sequence'}
													return OrderedDict(
													    [
													        ('input_ids', dynamic_axis),
													        ('attention_mask', dynamic_axis),
													        ('token_type_ids', dynamic_axis),
													    ]	)











from __future__ import annotations

from collections.abc import Iterable
from dataclasses import dataclass
from typing import Any

class      UpperCAmelCase_						:

						'''simple docstring'''




						UpperCamelCase__    :				List[str]       						=						('''_front''', '''_back''', '''_len''')

						@dataclass
						class      UpperCAmelCase_						:

												'''simple docstring'''




												UpperCamelCase__    :				Any       						=						None
												UpperCamelCase__    :				Deque._Node | None       						=						None
												UpperCamelCase__    :				Deque._Node | None       						=						None







						class      UpperCAmelCase_						:

												'''simple docstring'''




												UpperCamelCase__    :				Optional[int]       						=						('''_cur''',)






												def __init__(					self   ,							_A	):







																			'''simple docstring'''

																			__SCREAMING_SNAKE_CASE								=      cur






												def __iter__(					self	):







																			'''simple docstring'''

																			return self






												def  _A			(					self	):







																			'''simple docstring'''

																			if self._cur is None:
																										# finished iterating
																										raise StopIteration
																			__SCREAMING_SNAKE_CASE								=      self._cur.val
																			__SCREAMING_SNAKE_CASE								=      self._cur.next_node

																			return val







						def __init__(					self   ,							_A = None	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      None
													__SCREAMING_SNAKE_CASE								=      None
													__SCREAMING_SNAKE_CASE								=      0

													if iterable is not None:
																				# append every value to the deque
																				for val in iterable:
																											self.append(_A	)






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self._Node(_A   ,							_A   ,							_A	)
													if self.is_empty():
																				# front = back
																				__SCREAMING_SNAKE_CASE								=      __SCREAMING_SNAKE_CASE								=      node
																				__SCREAMING_SNAKE_CASE								=      1
													else:
																				# connect nodes
																				__SCREAMING_SNAKE_CASE								=      node
																				__SCREAMING_SNAKE_CASE								=      self._back
																				__SCREAMING_SNAKE_CASE								=      node  # assign new back to the new node

																				self._len += 1

																				# make sure there were no errors
																				assert not self.is_empty(), "Error on appending value."






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self._Node(_A   ,							_A   ,							_A	)
													if self.is_empty():
																				# front = back
																				__SCREAMING_SNAKE_CASE								=      __SCREAMING_SNAKE_CASE								=      node
																				__SCREAMING_SNAKE_CASE								=      1
													else:
																				# connect nodes
																				__SCREAMING_SNAKE_CASE								=      self._front
																				__SCREAMING_SNAKE_CASE								=      node
																				__SCREAMING_SNAKE_CASE								=      node  # assign new front to the new node

																				self._len += 1

																				# make sure there were no errors
																				assert not self.is_empty(), "Error on appending value."






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													for val in iterable:
																				self.append(_A	)






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													for val in iterable:
																				self.appendleft(_A	)






						def  _A			(					self	):







													'''simple docstring'''

													assert not self.is_empty(), "Deque is empty."

													__SCREAMING_SNAKE_CASE								=      self._back
													__SCREAMING_SNAKE_CASE								=      self._back.prev_node  # set new back
													# drop the last node - python will deallocate memory automatically
													__SCREAMING_SNAKE_CASE								=      None

													self._len -= 1

													return topop.val






						def  _A			(					self	):







													'''simple docstring'''

													assert not self.is_empty(), "Deque is empty."

													__SCREAMING_SNAKE_CASE								=      self._front
													__SCREAMING_SNAKE_CASE								=      self._front.next_node  # set new front and drop the first node
													__SCREAMING_SNAKE_CASE								=      None

													self._len -= 1

													return topop.val






						def  _A			(					self	):







													'''simple docstring'''

													return self._front is None






						def __len__(					self	):







													'''simple docstring'''

													return self._len






						def __eq__(					self   ,							_A	):







													'''simple docstring'''

													if not isinstance(_A   ,							_A	):
																				return NotImplemented

													__SCREAMING_SNAKE_CASE								=      self._front
													__SCREAMING_SNAKE_CASE								=      other._front

													# if the length of the dequeues are not the same, they are not equal
													if len(self	) != len(_A	):
																				return False

													while me is not None and oth is not None:
																				# compare every value
																				if me.val != oth.val:
																											return False
																				__SCREAMING_SNAKE_CASE								=      me.next_node
																				__SCREAMING_SNAKE_CASE								=      oth.next_node

													return True






						def __iter__(					self	):







													'''simple docstring'''

													return Deque._Iterator(self._front	)






						def __repr__(					self	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      []
													__SCREAMING_SNAKE_CASE								=      self._front
													while aux is not None:
																				# append the values in a list to display
																				values_list.append(aux.val	)
																				__SCREAMING_SNAKE_CASE								=      aux.next_node

													return f"""[{", ".join(repr(_A	) for val in values_list	)}]"""


if __name__ == "__main__":
			import doctest

			doctest.testmod()






