






from __future__ import annotations

from typing import Any




class       snake_case__ :

       '''simple docstring'''



       def __init__(				self      ,    a__ = 6     )			->   None:






            '''simple docstring'''





            __snake_case      :Node | None 							=    None
            __snake_case      :Node | None 							=    None
            self.create_linked_list(a__     )



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            __snake_case      :List[Any] 							=    Node()
            __snake_case      :Optional[int] 							=    current_node
            __snake_case      :Any 							=    current_node
            __snake_case      :Tuple 							=    current_node
            for _ in range(1      ,    a__     ):
                 __snake_case      :Optional[int] 							=    Node()
                 __snake_case      :Tuple 							=    current_node
                 __snake_case      :Optional[Any] 							=    previous_node
                 __snake_case      :Optional[int] 							=    current_node
            __snake_case      :Union[str, Any] 							=    self.front
            __snake_case      :List[Any] 							=    previous_node



       def        __lowercase    (				self     )			->   bool:






            '''simple docstring'''





            return (
                self.front == self.rear
                and self.front is not None
                and self.front.data is None
            )



       def        __lowercase    (				self     )			->   Any | None:






            '''simple docstring'''





            self.check_can_perform_operation()
            return self.front.data if self.front else None



       def        __lowercase    (				self      ,    a__     )			->   None:






            '''simple docstring'''





            if self.rear is None:
                 return

            self.check_is_full()
            if not self.is_empty():
                 __snake_case      :Optional[int] 							=    self.rear.next
            if self.rear:
                 __snake_case      :str 							=    data



       def        __lowercase    (				self     )			->   Any:






            '''simple docstring'''





            self.check_can_perform_operation()
            if self.rear is None or self.front is None:
                 return None
            if self.front == self.rear:
                 __snake_case      :Optional[int] 							=    self.front.data
                 __snake_case      :int 							=    None
                 return data

            __snake_case      :Optional[Any] 							=    self.front
            __snake_case      :Tuple 							=    old_front.next
            __snake_case      :Optional[Any] 							=    old_front.data
            __snake_case      :List[Any] 							=    None
            return data



       def        __lowercase    (				self     )			->   None:






            '''simple docstring'''





            if self.is_empty():
                 raise Exception("""Empty Queue"""     )



       def        __lowercase    (				self     )			->   None:






            '''simple docstring'''





            if self.rear and self.rear.next == self.front:
                 raise Exception("""Full Queue"""     )




class       snake_case__ :

       '''simple docstring'''



       def __init__(				self     )			->   None:






            '''simple docstring'''





            __snake_case      :Any | None 							=    None
            __snake_case      :Node | None 							=    None
            __snake_case      :Node | None 							=    None


if __name__ == "__main__":
     import doctest

     doctest.testmod()










from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


lowerCamelCase__       		=  logging.get_logger(__name__)

lowerCamelCase__       		=  {
    """microsoft/focalnet-tiny""": """https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json""",
}




class       snake_case__ (				lowercase_						,     lowercase_):

       '''simple docstring'''
       lowerCamelCase				:					List[Any]								=			"focalnet"



       def __init__(				self      ,    a__=2_24      ,    a__=4      ,    a__=3      ,    a__=96      ,    a__=False      ,    a__=[1_92, 3_84, 7_68, 7_68]      ,    a__=[2, 2, 6, 2]      ,    a__=[2, 2, 2, 2]      ,    a__=[3, 3, 3, 3]      ,    a__="gelu"      ,    a__=4.0      ,    a__=0.0      ,    a__=0.1      ,    a__=False      ,    a__=1e-4      ,    a__=False      ,    a__=False      ,    a__=False      ,    a__=0.02      ,    a__=1e-5      ,    a__=32      ,    a__=None      ,    a__=None      ,    **a__      ,    )			->   Tuple:






            '''simple docstring'''





            super().__init__(**a__     )

            __snake_case      :Optional[Any] 							=    image_size
            __snake_case      :Dict 							=    patch_size
            __snake_case      :Tuple 							=    num_channels
            __snake_case      :List[str] 							=    embed_dim
            __snake_case      :Any 							=    use_conv_embed
            __snake_case      :List[Any] 							=    hidden_sizes
            __snake_case      :str 							=    depths
            __snake_case      :List[Any] 							=    focal_levels
            __snake_case      :int 							=    focal_windows
            __snake_case      :Any 							=    hidden_act
            __snake_case      :List[str] 							=    mlp_ratio
            __snake_case      :str 							=    hidden_dropout_prob
            __snake_case      :List[str] 							=    drop_path_rate
            __snake_case      :int 							=    use_layerscale
            __snake_case      :int 							=    layerscale_value
            __snake_case      :Tuple 							=    use_post_layernorm
            __snake_case      :Dict 							=    use_post_layernorm_in_modulation
            __snake_case      :Union[str, Any] 							=    normalize_modulator
            __snake_case      :List[str] 							=    initializer_range
            __snake_case      :Optional[Any] 							=    layer_norm_eps
            __snake_case      :Tuple 							=    encoder_stride
            __snake_case      :List[str] 							=    ["""stem"""] + [F'''stage{idx}''' for idx in range(1      ,    len(self.depths     ) + 1     )]
            __snake_case							,			__snake_case      :str 							=    get_aligned_output_features_output_indices(
                out_features=a__      ,    out_indices=a__      ,    stage_names=self.stage_names     )


