
"""simple docstring"""




def 							a__ (				lowerCAmelCase	:       List[str]		):
     return [
         {
             0: [1, 2],
             1: [0, 2],
             2: [0, 1, 3, 5],
             3: [2, 4],
             4: [3],
             5: [2, 6, 8],
             6: [5, 7],
             7: [6, 8],
             8: [5, 7],
         },
         {
             0: [6],
             1: [9],
             2: [4, 5],
             3: [4],
             4: [2, 3],
             5: [2],
             6: [0, 7],
             7: [6],
             8: [],
             9: [1],
         },
         {
             0: [4],
             1: [6],
             2: [],
             3: [5, 6, 7],
             4: [0, 6],
             5: [3, 8, 9],
             6: [1, 3, 4, 7],
             7: [3, 6, 8, 9],
             8: [5, 7],
             9: [5, 7],
         },
         {
             0: [1, 3],
             1: [0, 2, 4],
             2: [1, 3, 4],
             3: [0, 2, 4],
             4: [1, 2, 3],
         },
     ][index]



def 							a__ (				lowerCAmelCase	:       dict[int, list[int]]		):
     UpperCAmelCase__							: Optional[int] 							=						0
     UpperCAmelCase__							: Dict 							=						len(lowerCAmelCase		)  # No of vertices in graph
     UpperCAmelCase__							: str 							=						[0] * n
     UpperCAmelCase__							: Optional[Any] 							=						[False] * n

     def dfs(lowerCAmelCase	:       Optional[int]       ,    lowerCAmelCase	:       Optional[Any]       ,    lowerCAmelCase	:       str       ,    lowerCAmelCase	:       List[str]		):
          UpperCAmelCase__							: int 							=						True
          UpperCAmelCase__							: List[Any] 							=						id_
          id_ += 1
          for to in graph[at]:
               if to == parent:
                    pass
               elif not visited[to]:
                    dfs(lowerCAmelCase       ,    lowerCAmelCase       ,    lowerCAmelCase       ,    id_		)
                    UpperCAmelCase__							: Any 							=						min(low[at]       ,    low[to]		)
                    if id_ <= low[to]:
                         bridges.append((at, to) if at < to else (to, at)		)
               else:
                    # This edge is a back edge and cannot be a bridge
                    UpperCAmelCase__							: int 							=						min(low[at]       ,    low[to]		)

     UpperCAmelCase__							: list[tuple[int, int]] 							=						[]
     for i in range(lowerCAmelCase		):
          if not visited[i]:
               dfs(lowerCAmelCase       ,    -1       ,    lowerCAmelCase       ,    id_		)
     return bridges


if __name__ == "__main__":
    import doctest

    doctest.testmod()





"""simple docstring"""




import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin







class   _lowercase						(       unittest.TestCase	,   lowerCAmelCase_				):


     '''simple docstring'''





     def  lowerCAmelCase__       (      self  )->					Dict:
          UpperCAmelCase__							: Optional[Any] 							=						load_tool("text-classification"  )
          self.tool.setup()
          UpperCAmelCase__							: List[str] 							=						load_tool("text-classification" ,			remote=__UpperCamelCase  )



     def  lowerCAmelCase__       (      self  )->					Union[str, Any]:
          UpperCAmelCase__							: Dict 							=						self.tool("That's quite cool" ,			["positive", "negative"]  )
          self.assertEqual(__UpperCamelCase ,			"positive"  )



     def  lowerCAmelCase__       (      self  )->					str:
          UpperCAmelCase__							: List[Any] 							=						self.remote_tool("That's quite cool" ,			["positive", "negative"]  )
          self.assertEqual(__UpperCamelCase ,			"positive"  )



     def  lowerCAmelCase__       (      self  )->					Optional[int]:
          UpperCAmelCase__							: Any 							=						self.tool(text="That's quite cool" ,			labels=["positive", "negative"]  )
          self.assertEqual(__UpperCamelCase ,			"positive"  )



     def  lowerCAmelCase__       (      self  )->					str:
          UpperCAmelCase__							: str 							=						self.remote_tool(text="That's quite cool" ,			labels=["positive", "negative"]  )
          self.assertEqual(__UpperCamelCase ,			"positive"  )



