# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_lowerCamelCase					:   Tuple							=		{
    '''configuration_efficientnet''': [
        '''EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''EfficientNetConfig''',
        '''EfficientNetOnnxConfig''',
    ]
}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_lowerCamelCase					:   Union[str, Any]							=		['''EfficientNetImageProcessor''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_lowerCamelCase					:   List[Any]							=		[
					    '''EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''EfficientNetForImageClassification''',
					    '''EfficientNetModel''',
					    '''EfficientNetPreTrainedModel''',
					]

if TYPE_CHECKING:
					from .configuration_efficientnet import (
					    EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    EfficientNetConfig,
					    EfficientNetOnnxConfig,
					)

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .image_processing_efficientnet import EfficientNetImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_efficientnet import (
										    EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST,
										    EfficientNetForImageClassification,
										    EfficientNetModel,
										    EfficientNetPreTrainedModel,
										)

else:
					import sys

					_lowerCamelCase					:   Union[str, Any]							=		_LazyModule(__name__, globals()['''__file__'''], _import_structure)





from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

_lowerCamelCase					:   Optional[Any]							=		TypeVar('''T''')


class 						lowercase    (     Generic[T]     ):




							def __init__(						self   :					Any	,							_UpperCamelCase   :					T      )					->				Any:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       data
												SCREAMING_SNAKE_CASE    			=       None





							def __str__(						self   :					Union[str, Any]      )					->				str:



												'''simple docstring'''

												return F"{self.data}"



class 						lowercase    (     Generic[T]     ):




							def __init__(						self   :					Optional[int]      )					->				None:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       None




							def __iter__(						self   :					str      )					->				Iterator[T]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.top
												while node:
																	yield node.data
																	SCREAMING_SNAKE_CASE    			=       node.next




							def __str__(						self   :					int      )					->				str:



												'''simple docstring'''

												return "->".join([str(_UpperCamelCase      ) for item in self]      )




							def __len__(						self   :					Tuple      )					->				int:



												'''simple docstring'''

												return len(tuple(iter(self      )      )      )




							def 	__snake_case(						self   :					Union[str, Any]      )					->				bool:



												'''simple docstring'''

												return self.top is None




							def 	__snake_case(						self   :					str	,							_UpperCamelCase   :					T      )					->				None:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       Node(_UpperCamelCase      )
												if not self.is_empty():
																	SCREAMING_SNAKE_CASE    			=       self.top
												SCREAMING_SNAKE_CASE    			=       node




							def 	__snake_case(						self   :					Union[str, Any]      )					->				T:



												'''simple docstring'''

												if self.is_empty():
																	raise IndexError("pop from empty stack"      )
												assert isinstance(self.top	,							_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       self.top
												SCREAMING_SNAKE_CASE    			=       self.top.next
												return pop_node.data




							def 	__snake_case(						self   :					Union[str, Any]      )					->				T:



												'''simple docstring'''

												if self.is_empty():
																	raise IndexError("peek from empty stack"      )

												assert self.top is not None
												return self.top.data





							def 	__snake_case(						self   :					Dict      )					->				None:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       None


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

							testmod()




