






from __future__ import annotations

from enum import Enum
class 					a					(				lowercase__     ):



      """simple docstring"""


      a						:				Optional[Any]							 =			24
      a						:				Tuple							 =			21
      a						:				str							 =			18
      a						:				Optional[Any]							 =			15
      a						:				Optional[int]							 =			12
      a						:				List[str]							 =			9
      a						:				Dict							 =			6
      a						:				int							 =			3
      a						:				Any							 =			2
      a						:				Optional[Any]							 =			1
      a						:				List[Any]							 =			-1
      a						:				str							 =			-2
      a						:				str							 =			-3
      a						:				List[str]							 =			-6
      a						:				Any							 =			-9
      a						:				Dict							 =			-12
      a						:				List[Any]							 =			-15
      a						:				List[str]							 =			-18
      a						:				Dict							 =			-21
      a						:				Optional[int]							 =			-24


class 					a					(				lowercase__     ):



      """simple docstring"""


      a						:				List[str]							 =			8
      a						:				Optional[int]							 =			7
      a						:				Optional[Any]							 =			6
      a						:				str							 =			5
      a						:				int							 =			4
      a						:				str							 =			3
      a						:				List[Any]							 =			2
      a						:				List[str]							 =			1






def        lowerCamelCase__   (					__lowerCamelCase    :  float						,	__lowerCamelCase    :  str | SIUnit						,	__lowerCamelCase    :  str | SIUnit						,	)     ->   int:
  if isinstance(__lowerCamelCase						,	__lowerCamelCase	):
    __UpperCAmelCase							:			Optional[int]     =						SIUnit[known_prefix.lower()]
  if isinstance(__lowerCamelCase						,	__lowerCamelCase	):
    __UpperCAmelCase							:			List[Any]     =						SIUnit[unknown_prefix.lower()]
  __UpperCAmelCase							:			float     =						known_amount * (
      10 ** (known_prefix.value - unknown_prefix.value)
  )
  return unknown_amount






def        lowerCamelCase__   (					__lowerCamelCase    :  float						,	__lowerCamelCase    :  str | BinaryUnit						,	__lowerCamelCase    :  str | BinaryUnit						,	)     ->   Tuple:
  if isinstance(__lowerCamelCase						,	__lowerCamelCase	):
    __UpperCAmelCase							:			str     =						BinaryUnit[known_prefix.lower()]
  if isinstance(__lowerCamelCase						,	__lowerCamelCase	):
    __UpperCAmelCase							:			Tuple     =						BinaryUnit[unknown_prefix.lower()]
  __UpperCAmelCase							:			float     =						known_amount * (
      2 ** ((known_prefix.value - unknown_prefix.value) * 10)
  )
  return unknown_amount


if __name__ == "__main__":
       import doctest

       doctest.testmod()










from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


a	: Optional[int]      =				{
    "configuration_deformable_detr": ["DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP", "DeformableDetrConfig"],
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: Optional[int]      =				["DeformableDetrFeatureExtractor"]
       a	: List[str]      =				["DeformableDetrImageProcessor"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a	: List[Any]      =				[
           "DEFORMABLE_DETR_PRETRAINED_MODEL_ARCHIVE_LIST",
           "DeformableDetrForObjectDetection",
           "DeformableDetrModel",
           "DeformableDetrPreTrainedModel",
       ]


if TYPE_CHECKING:
       from .configuration_deformable_detr import DEFORMABLE_DETR_PRETRAINED_CONFIG_ARCHIVE_MAP, DeformableDetrConfig

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_deformable_detr import DeformableDetrFeatureExtractor
              from .image_processing_deformable_detr import DeformableDetrImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_deformable_detr import (
                  DEFORMABLE_DETR_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DeformableDetrForObjectDetection,
                  DeformableDetrModel,
                  DeformableDetrPreTrainedModel,
              )

else:
       import sys

       a	: List[Any]      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


