


'''simple docstring'''




from typing import TYPE_CHECKING

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


_a   :   Tuple												=   {
    "configuration_owlvit": [
        "OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "OwlViTConfig",
        "OwlViTOnnxConfig",
        "OwlViTTextConfig",
        "OwlViTVisionConfig",
    ],
    "processing_owlvit": ["OwlViTProcessor"],
}


try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _a   :   Optional[Any]												=   ["OwlViTFeatureExtractor"]
       _a   :   Union[str, Any]												=   ["OwlViTImageProcessor"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _a   :   Dict												=   [
           "OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST",
           "OwlViTModel",
           "OwlViTPreTrainedModel",
           "OwlViTTextModel",
           "OwlViTVisionModel",
           "OwlViTForObjectDetection",
       ]

if TYPE_CHECKING:
       from .configuration_owlvit import (
           OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP,
           OwlViTConfig,
           OwlViTOnnxConfig,
           OwlViTTextConfig,
           OwlViTVisionConfig,
       )
       from .processing_owlvit import OwlViTProcessor

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_owlvit import OwlViTFeatureExtractor
              from .image_processing_owlvit import OwlViTImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_owlvit import (
                  OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  OwlViTForObjectDetection,
                  OwlViTModel,
                  OwlViTPreTrainedModel,
                  OwlViTTextModel,
                  OwlViTVisionModel,
              )

else:
       import sys

       _a   :   int												=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)








class   SCREAMING_SNAKE_CASE_			:




       '''simple docstring'''



       def __init__(						self				:				List[Any]							)					->Tuple:
          lowerCamelCase_						:   Optional[Any]		= """"""
          lowerCamelCase_						:   Dict		= """"""
          lowerCamelCase_						:   Optional[Any]		= []



       def 				_lowerCAmelCase							(						self				:				Optional[Any]		,				__a				:				int		,				__a				:				int							)					->int:
          if m == -1:
             return n + 1
          elif n == -1:
             return m + 1
          elif self.dp[m][n] > -1:
             return self.dp[m][n]
          else:
             if self.worda[m] == self.worda[n]:
                lowerCamelCase_						:   Optional[Any]		= self.__min_dist_top_down_dp(m - 1		,				n - 1							)
             else:
                lowerCamelCase_						:   List[Any]		= self.__min_dist_top_down_dp(__a		,				n - 1							)
                lowerCamelCase_						:   Union[str, Any]		= self.__min_dist_top_down_dp(m - 1		,				__a							)
                lowerCamelCase_						:   Any		= self.__min_dist_top_down_dp(m - 1		,				n - 1							)
                lowerCamelCase_						:   Tuple		= 1 + min(__a		,				__a		,				__a							)

             return self.dp[m][n]



       def 				_lowerCAmelCase							(						self				:				Any		,				__a				:				str		,				__a				:				str							)					->int:
          lowerCamelCase_						:   Dict		= worda
          lowerCamelCase_						:   str		= worda
          lowerCamelCase_						:   Union[str, Any]		= [[-1 for _ in range(len(__a							)							)] for _ in range(len(__a							)							)]

          return self.__min_dist_top_down_dp(len(__a							) - 1		,				len(__a							) - 1							)




       def 				_lowerCAmelCase							(						self				:				int		,				__a				:				str		,				__a				:				str							)					->int:
          lowerCamelCase_						:   Tuple		= worda
          lowerCamelCase_						:   Optional[Any]		= worda
          lowerCamelCase_						:   Tuple		= len(__a							)
          lowerCamelCase_						:   Optional[Any]		= len(__a							)
          lowerCamelCase_						:   List[Any]		= [[0 for _ in range(n + 1							)] for _ in range(m + 1							)]

          for i in range(m + 1							):
             for j in range(n + 1							):
                if i == 0:  # first string is empty
                   lowerCamelCase_						:   Optional[Any]		= j
                elif j == 0:  # second string is empty
                   lowerCamelCase_						:   Any		= i
                elif worda[i - 1] == worda[j - 1]:  # last characters are equal
                   lowerCamelCase_						:   Tuple		= self.dp[i - 1][j - 1]
                else:
                   lowerCamelCase_						:   Dict		= self.dp[i][j - 1]
                   lowerCamelCase_						:   Union[str, Any]		= self.dp[i - 1][j]
                   lowerCamelCase_						:   Any		= self.dp[i - 1][j - 1]
                   lowerCamelCase_						:   Optional[int]		= 1 + min(__a		,				__a		,				__a							)
          return self.dp[m][n]


if __name__ == "__main__":
      snake_case__				:	Optional[Any]					       =					EditDistance()

      print('****************** Testing Edit Distance DP Algorithm ******************')
      print()

      snake_case__				:	Union[str, Any]					       =					input('Enter the first string: ').strip()
      snake_case__				:	List[Any]					       =					input('Enter the second string: ').strip()

      print()
      print(F'The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}')
      print(F'The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}')
      print()
      print('*************** End of Testing Edit Distance DP Algorithm ***************')





