


import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
       from PIL import Image
else:

       class       __magic_name__	:


            @staticmethod
            def      UpperCAmelCase__	(      *lowerCamelCase__							:     int							,	**lowerCamelCase__							:     str			)  ->      Dict:





             '''simple docstring'''






             pass

@is_pipeline_test
@require_vision
@require_torch
class       __magic_name__	(     unittest.TestCase):
     A:		str			=      MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING


     def      UpperCAmelCase__	(      self							:     List[str]							,	lowerCamelCase__							:     Union[str, Any]							,	lowerCamelCase__							:     Any							,	lowerCamelCase__							:     Optional[Any]			)  ->      List[Any]:





      '''simple docstring'''






      UpperCamelCase__					:    str          =   pipeline(
          '''zero-shot-object-detection'''							,	model='''hf-internal-testing/tiny-random-owlvit-object-detection'''			)

      UpperCamelCase__					:    Optional[int]          =   [
          {
              '''image''': '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
              '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
          }
      ]
      return object_detector, examples


     def      UpperCAmelCase__	(      self							:     List[Any]							,	lowerCamelCase__							:     str							,	lowerCamelCase__							:     str			)  ->      Union[str, Any]:





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   object_detector(examples[0]							,	threshold=0.0			)

      UpperCamelCase__					:    List[Any]          =   len(lowerCamelCase__			)
      self.assertGreater(lowerCamelCase__							,	0			)
      self.assertEqual(
          lowerCamelCase__							,	[
              {
                  '''score''': ANY(lowerCamelCase__			),
                  '''label''': ANY(lowerCamelCase__			),
                  '''box''': {'''xmin''': ANY(lowerCamelCase__			), '''ymin''': ANY(lowerCamelCase__			), '''xmax''': ANY(lowerCamelCase__			), '''ymax''': ANY(lowerCamelCase__			)},
              }
              for i in range(lowerCamelCase__			)
          ]							,	)


     @require_tf
     @unittest.skip('''Zero Shot Object Detection not implemented in TF'''			)
     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      str:





      '''simple docstring'''






      pass


     @require_torch
     def      UpperCAmelCase__	(      self							:     str			)  ->      Any:





      '''simple docstring'''






      UpperCamelCase__					:    Tuple          =   pipeline(
          '''zero-shot-object-detection'''							,	model='''hf-internal-testing/tiny-random-owlvit-object-detection'''			)

      UpperCamelCase__					:    Union[str, Any]          =   object_detector(
          '''./tests/fixtures/tests_samples/COCO/000000039769.png'''							,	candidate_labels=['''cat''', '''remote''', '''couch''']							,	threshold=0.64							,	)

      self.assertEqual(
          nested_simplify(lowerCamelCase__							,	decimals=4			)							,	[
              {'''score''': 0.7235, '''label''': '''cat''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
              {'''score''': 0.7218, '''label''': '''remote''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
              {'''score''': 0.7184, '''label''': '''couch''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
              {'''score''': 0.6748, '''label''': '''remote''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
              {'''score''': 0.6656, '''label''': '''cat''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
              {'''score''': 0.6614, '''label''': '''couch''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
              {'''score''': 0.6456, '''label''': '''remote''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
              {'''score''': 0.642, '''label''': '''remote''', '''box''': {'''xmin''': 67, '''ymin''': 274, '''xmax''': 93, '''ymax''': 297}},
              {'''score''': 0.6419, '''label''': '''cat''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
          ]							,	)

      UpperCamelCase__					:    Union[str, Any]          =   object_detector(
          [
              {
                  '''image''': '''./tests/fixtures/tests_samples/COCO/000000039769.png''',
                  '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
              }
          ]							,	threshold=0.64							,	)

      self.assertEqual(
          nested_simplify(lowerCamelCase__							,	decimals=4			)							,	[
              [
                  {'''score''': 0.7235, '''label''': '''cat''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
                  {'''score''': 0.7218, '''label''': '''remote''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
                  {'''score''': 0.7184, '''label''': '''couch''', '''box''': {'''xmin''': 204, '''ymin''': 167, '''xmax''': 232, '''ymax''': 190}},
                  {'''score''': 0.6748, '''label''': '''remote''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
                  {'''score''': 0.6656, '''label''': '''cat''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
                  {'''score''': 0.6614, '''label''': '''couch''', '''box''': {'''xmin''': 571, '''ymin''': 83, '''xmax''': 598, '''ymax''': 103}},
                  {'''score''': 0.6456, '''label''': '''remote''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
                  {'''score''': 0.642, '''label''': '''remote''', '''box''': {'''xmin''': 67, '''ymin''': 274, '''xmax''': 93, '''ymax''': 297}},
                  {'''score''': 0.6419, '''label''': '''cat''', '''box''': {'''xmin''': 494, '''ymin''': 105, '''xmax''': 521, '''ymax''': 127}},
              ]
          ]							,	)


     @require_torch
     @slow
     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      List[str]:





      '''simple docstring'''






      UpperCamelCase__					:    int          =   pipeline('''zero-shot-object-detection'''			)

      UpperCamelCase__					:    Tuple          =   object_detector(
          '''http://images.cocodataset.org/val2017/000000039769.jpg'''							,	candidate_labels=['''cat''', '''remote''', '''couch''']							,	)
      self.assertEqual(
          nested_simplify(lowerCamelCase__							,	decimals=4			)							,	[
              {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
              {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
              {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
              {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
              {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
          ]							,	)

      UpperCamelCase__					:    str          =   object_detector(
          [
              {
                  '''image''': '''http://images.cocodataset.org/val2017/000000039769.jpg''',
                  '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
              },
              {
                  '''image''': '''http://images.cocodataset.org/val2017/000000039769.jpg''',
                  '''candidate_labels''': ['''cat''', '''remote''', '''couch'''],
              },
          ]							,	)
      self.assertEqual(
          nested_simplify(lowerCamelCase__							,	decimals=4			)							,	[
              [
                  {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
                  {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
                  {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
                  {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
                  {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
              ],
              [
                  {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
                  {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
                  {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
                  {'''score''': 0.1474, '''label''': '''remote''', '''box''': {'''xmin''': 335, '''ymin''': 74, '''xmax''': 371, '''ymax''': 187}},
                  {'''score''': 0.1208, '''label''': '''couch''', '''box''': {'''xmin''': 4, '''ymin''': 0, '''xmax''': 642, '''ymax''': 476}},
              ],
          ]							,	)


     @require_tf
     @unittest.skip('''Zero Shot Object Detection not implemented in TF'''			)
     def      UpperCAmelCase__	(      self							:     Tuple			)  ->      Optional[int]:





      '''simple docstring'''






      pass


     @require_torch
     @slow
     def      UpperCAmelCase__	(      self							:     Optional[int]			)  ->      str:





      '''simple docstring'''






      UpperCamelCase__					:    Union[str, Any]          =   0.2
      UpperCamelCase__					:    Optional[Any]          =   pipeline('''zero-shot-object-detection'''			)

      UpperCamelCase__					:    Tuple          =   object_detector(
          '''http://images.cocodataset.org/val2017/000000039769.jpg'''							,	candidate_labels=['''cat''', '''remote''', '''couch''']							,	threshold=lowerCamelCase__							,	)
      self.assertEqual(
          nested_simplify(lowerCamelCase__							,	decimals=4			)							,	[
              {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
              {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
              {'''score''': 0.2537, '''label''': '''cat''', '''box''': {'''xmin''': 1, '''ymin''': 55, '''xmax''': 315, '''ymax''': 472}},
          ]							,	)


     @require_torch
     @slow
     def      UpperCAmelCase__	(      self							:     Any			)  ->      int:





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   2
      UpperCamelCase__					:    int          =   pipeline('''zero-shot-object-detection'''			)

      UpperCamelCase__					:    List[str]          =   object_detector(
          '''http://images.cocodataset.org/val2017/000000039769.jpg'''							,	candidate_labels=['''cat''', '''remote''', '''couch''']							,	top_k=lowerCamelCase__							,	)
      self.assertEqual(
          nested_simplify(lowerCamelCase__							,	decimals=4			)							,	[
              {'''score''': 0.2868, '''label''': '''cat''', '''box''': {'''xmin''': 324, '''ymin''': 20, '''xmax''': 640, '''ymax''': 373}},
              {'''score''': 0.277, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 72, '''xmax''': 177, '''ymax''': 115}},
          ]							,	)






__UpperCamelCase       :       List[Any]						       =				256
# Modulus to hash a string
__UpperCamelCase       :       Union[str, Any]						       =				100_0003

def 			_a  (				SCREAMING_SNAKE_CASE	:				str    , SCREAMING_SNAKE_CASE	:				str     ):







 """simple docstring"""



 UpperCamelCase__					:    Optional[int]          =   len(SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    List[Any]          =   len(SCREAMING_SNAKE_CASE     )
 if p_len > t_len:
  return False

 UpperCamelCase__					:    Any          =   0
 UpperCamelCase__					:    str          =   0
 UpperCamelCase__					:    List[Any]          =   1

 # Calculating the hash of pattern and substring of text
 for i in range(SCREAMING_SNAKE_CASE     ):
  UpperCamelCase__					:    Any          =   (ord(pattern[i]     ) + p_hash * alphabet_size) % modulus
  UpperCamelCase__					:    List[str]          =   (ord(text[i]     ) + text_hash * alphabet_size) % modulus
  if i == p_len - 1:
   continue
  UpperCamelCase__					:    Dict          =   (modulus_power * alphabet_size) % modulus

 for i in range(0    , t_len - p_len + 1     ):
  if text_hash == p_hash and text[i : i + p_len] == pattern:
   return True
  if i == t_len - p_len:
   continue
  # Calculate the https://en.wikipedia.org/wiki/Rolling_hash
  UpperCamelCase__					:    Optional[int]          =   (
      (text_hash - ord(text[i]     ) * modulus_power) * alphabet_size
      + ord(text[i + p_len]     )
  ) % modulus
 return False

def 			_a  (				):







 """simple docstring"""



 UpperCamelCase__					:    Tuple          =   '''abc1abc12'''
 UpperCamelCase__					:    Dict          =   '''alskfjaldsabc1abc1abc12k23adsfabcabc'''
 UpperCamelCase__					:    List[str]          =   '''alskfjaldsk23adsfabcabc'''
 assert rabin_karp(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     ) and not rabin_karp(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )

 # Test 2)
 UpperCamelCase__					:    Optional[int]          =   '''ABABX'''
 UpperCamelCase__					:    int          =   '''ABABZABABYABABX'''
 assert rabin_karp(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )

 # Test 3)
 UpperCamelCase__					:    int          =   '''AAAB'''
 UpperCamelCase__					:    str          =   '''ABAAAAAB'''
 assert rabin_karp(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )

 # Test 4)
 UpperCamelCase__					:    Union[str, Any]          =   '''abcdabcy'''
 UpperCamelCase__					:    List[str]          =   '''abcxabcdabxabcdabcdabcy'''
 assert rabin_karp(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )

 # Test 5)
 UpperCamelCase__					:    Tuple          =   '''Lü'''
 UpperCamelCase__					:    Any          =   '''Lüsai'''
 assert rabin_karp(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    Dict          =   '''Lue'''
 assert not rabin_karp(SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE     )
 print('''Success.'''     )


if __name__ == "__main__":
       test_rabin_karp()


