






import unittest

from transformers import is_vision_available
from transformers.pipelines import 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 					SCREAMING_SNAKE_CASE_  :
           """simple docstring"""


           @staticmethod
           def 				UpperCamelCase__						(				*snake_case	:Union[str, Any],      **snake_case	:Tuple):



              """simple docstring"""

              pass






@is_pipeline_test
@require_vision
class 					SCREAMING_SNAKE_CASE_  (       unittest.TestCase ):
       """simple docstring"""


       @require_torch
       def 				UpperCamelCase__						(				self	:List[str]):



          """simple docstring"""

          _lowercase              =pipeline(
              model='hf-internal-testing/tiny-random-clip-zero-shot-image-classification',      )
          _lowercase              =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
          _lowercase              =image_classifier(snake_case,      candidate_labels=['a', 'b', 'c'])

          # The floating scores are so close, we enter floating error approximation and the order is not guaranteed across
          # python and torch versions.
          self.assertIn(
              nested_simplify(snake_case),      [
                  [{'score': 0.3_3_3, 'label': 'a'}, {'score': 0.3_3_3, 'label': 'b'}, {'score': 0.3_3_3, 'label': 'c'}],
                  [{'score': 0.3_3_3, 'label': 'a'}, {'score': 0.3_3_3, 'label': 'c'}, {'score': 0.3_3_3, 'label': 'b'}],
              ],      )

          _lowercase              =image_classifier([image] * 5,      candidate_labels=['A', 'B', 'C'],      batch_size=2)
          self.assertEqual(
              nested_simplify(snake_case),      [
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
              ],      )





       @require_tf
       def 				UpperCamelCase__						(				self	:Tuple):



          """simple docstring"""

          _lowercase              =pipeline(
              model='hf-internal-testing/tiny-random-clip-zero-shot-image-classification',      framework='tf')
          _lowercase              =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
          _lowercase              =image_classifier(snake_case,      candidate_labels=['a', 'b', 'c'])

          self.assertEqual(
              nested_simplify(snake_case),      [{'score': 0.3_3_3, 'label': 'a'}, {'score': 0.3_3_3, 'label': 'b'}, {'score': 0.3_3_3, 'label': 'c'}],      )

          _lowercase              =image_classifier([image] * 5,      candidate_labels=['A', 'B', 'C'],      batch_size=2)
          self.assertEqual(
              nested_simplify(snake_case),      [
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
                  [
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                      {'score': 0.3_3_3, 'label': ANY(snake_case)},
                  ],
              ],      )





       @slow
       @require_torch
       def 				UpperCamelCase__						(				self	:Optional[Any]):



          """simple docstring"""

          _lowercase              =pipeline(
              task='zero-shot-image-classification',      model='openai/clip-vit-base-patch32',      )
          # This is an image of 2 cats with remotes and no planes
          _lowercase              =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
          _lowercase              =image_classifier(snake_case,      candidate_labels=['cat', 'plane', 'remote'])

          self.assertEqual(
              nested_simplify(snake_case),      [
                  {'score': 0.5_1_1, 'label': 'remote'},
                  {'score': 0.4_8_5, 'label': 'cat'},
                  {'score': 0.0_0_4, 'label': 'plane'},
              ],      )

          _lowercase              =image_classifier([image] * 5,      candidate_labels=['cat', 'plane', 'remote'],      batch_size=2)
          self.assertEqual(
              nested_simplify(snake_case),      [
                  [
                      {'score': 0.5_1_1, 'label': 'remote'},
                      {'score': 0.4_8_5, 'label': 'cat'},
                      {'score': 0.0_0_4, 'label': 'plane'},
                  ],
              ]
              * 5,      )





       @slow
       @require_tf
       def 				UpperCamelCase__						(				self	:Dict):



          """simple docstring"""

          _lowercase              =pipeline(
              task='zero-shot-image-classification',      model='openai/clip-vit-base-patch32',      framework='tf')
          # This is an image of 2 cats with remotes and no planes
          _lowercase              =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
          _lowercase              =image_classifier(snake_case,      candidate_labels=['cat', 'plane', 'remote'])
          self.assertEqual(
              nested_simplify(snake_case),      [
                  {'score': 0.5_1_1, 'label': 'remote'},
                  {'score': 0.4_8_5, 'label': 'cat'},
                  {'score': 0.0_0_4, 'label': 'plane'},
              ],      )

          _lowercase              =image_classifier([image] * 5,      candidate_labels=['cat', 'plane', 'remote'],      batch_size=2)
          self.assertEqual(
              nested_simplify(snake_case),      [
                  [
                      {'score': 0.5_1_1, 'label': 'remote'},
                      {'score': 0.4_8_5, 'label': 'cat'},
                      {'score': 0.0_0_4, 'label': 'plane'},
                  ],
              ]
              * 5,      )










# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

_SCREAMING_SNAKE_CASE   =  TypeVar("T")






class 					SCREAMING_SNAKE_CASE_  (       Generic[T] ):
       """simple docstring"""


       def __init__(				self	:List[Any],      snake_case	:bool = True):



          """simple docstring"""

          _lowercase              ={}  # dictionary of lists
          _lowercase              =directed





       def 				UpperCamelCase__						(				self	:Optional[Any],      snake_case	:T,      snake_case	:T):



          """simple docstring"""

          if not self.directed:  # For undirected graphs
             # if both source vertex and destination vertex are both present in the
             # adjacency list, add destination vertex to source vertex list of adjacent
             # vertices and add source vertex to destination vertex list of adjacent
             # vertices.
             if source_vertex in self.adj_list and destination_vertex in self.adj_list:
                self.adj_list[source_vertex].append(snake_case)
                self.adj_list[destination_vertex].append(snake_case)
             # if only source vertex is present in adjacency list, add destination vertex
             # to source vertex list of adjacent vertices, then create a new vertex with
             # destination vertex as key and assign a list containing the source vertex
             # as it's first adjacent vertex.
             elif source_vertex in self.adj_list:
                self.adj_list[source_vertex].append(snake_case)
                _lowercase              =[source_vertex]
             # if only destination vertex is present in adjacency list, add source vertex
             # to destination vertex list of adjacent vertices, then create a new vertex
             # with source vertex as key and assign a list containing the source vertex
             # as it's first adjacent vertex.
             elif destination_vertex in self.adj_list:
                self.adj_list[destination_vertex].append(snake_case)
                _lowercase              =[destination_vertex]
             # if both source vertex and destination vertex are not present in adjacency
             # list, create a new vertex with source vertex as key and assign a list
             # containing the destination vertex as it's first adjacent vertex also
             # create a new vertex with destination vertex as key and assign a list
             # containing the source vertex as it's first adjacent vertex.
             else:
                _lowercase              =[destination_vertex]
                _lowercase              =[source_vertex]
          else:  # For directed graphs
             # if both source vertex and destination vertex are present in adjacency
             # list, add destination vertex to source vertex list of adjacent vertices.
             if source_vertex in self.adj_list and destination_vertex in self.adj_list:
                self.adj_list[source_vertex].append(snake_case)
             # if only source vertex is present in adjacency list, add destination
             # vertex to source vertex list of adjacent vertices and create a new vertex
             # with destination vertex as key, which has no adjacent vertex
             elif source_vertex in self.adj_list:
                self.adj_list[source_vertex].append(snake_case)
                _lowercase              =[]
             # if only destination vertex is present in adjacency list, create a new
             # vertex with source vertex as key and assign a list containing destination
             # vertex as first adjacent vertex
             elif destination_vertex in self.adj_list:
                _lowercase              =[destination_vertex]
             # if both source vertex and destination vertex are not present in adjacency
             # list, create a new vertex with source vertex as key and a list containing
             # destination vertex as it's first adjacent vertex. Then create a new vertex
             # with destination vertex as key, which has no adjacent vertex
             else:
                _lowercase              =[destination_vertex]
                _lowercase              =[]

          return self





       def __repr__(				self	:Optional[int]):



          """simple docstring"""

          return pformat(self.adj_list)


