




class 		lowercase_       :




					def __init__(   self:		Optional[Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  []
									__lowerCAmelCase					=  0
									__lowerCAmelCase					=  0




					def __str__(   self:		List[str]):


									'''simple docstring'''


									__lowerCAmelCase					=  """<""" + str(self.entries)[1:-1] + """>"""
									return printed




					def     _lowercase						(   self:		List[Any],     _lowercase:		Any):


									'''simple docstring'''


									self.entries.append(_lowercase)
									__lowerCAmelCase					=  self.length + 1




					def     _lowercase						(   self:		Optional[Any]):


									'''simple docstring'''


									__lowerCAmelCase					=  self.length - 1
									__lowerCAmelCase					=  self.entries[self.front]
									# self.front-=1
									# self.entries = self.entries[self.front:]
									__lowerCAmelCase					=  self.entries[1:]
									return dequeued




					def     _lowercase						(   self:		Union[str, Any],     _lowercase:		str):


									'''simple docstring'''


									for _ in range(_lowercase):
													self.put(self.get())




					def     _lowercase						(   self:		Optional[Any]):


									'''simple docstring'''


									return self.entries[0]




					def     _lowercase						(   self:		Dict):


									'''simple docstring'''


									return self.length






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


UpperCAmelCase				 =   {
    """configuration_gptsan_japanese""": ["""GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTSanJapaneseConfig"""],
    """tokenization_gptsan_japanese""": ["""GPTSanJapaneseTokenizer"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase				 =   [
      """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """GPTSanJapaneseForConditionalGeneration""",
      """GPTSanJapaneseModel""",
      """GPTSanJapanesePreTrainedModel""",
  ]
  UpperCAmelCase				 =   [
      """GPTSanJapaneseTokenizer""",
  ]


if TYPE_CHECKING:
  from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
  from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_gptsan_japanese import (
        GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
        GPTSanJapaneseForConditionalGeneration,
        GPTSanJapaneseModel,
        GPTSanJapanesePreTrainedModel,
    )
    from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
  import sys

  UpperCAmelCase				 =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)