




'''simple docstring'''



import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
UpperCAmelCase_							:	List[Any]	     =		sys.version_info >= (3, 1_0)







def       _UpperCamelCase			(_lowerCamelCase				:  Optional[int]=None ,						_lowerCamelCase				:  str=None						)-> List[str]:




     '''simple docstring'''





     return field(default_factory=lambda: default ,						metadata=_lowerCamelCase						)





@dataclass
class      lowerCAmelCase :
       __lowercase	:   int
       __lowercase	:   float
       __lowercase	:   str
       __lowercase	:   bool





@dataclass
class      lowerCAmelCase :
       __lowercase	:   int										=      42
       __lowercase	:   str										=      field(default='''toto'''					, metadata={'''help''': '''help message'''})





@dataclass
class      lowerCAmelCase :
       __lowercase	:   bool										=      False
       __lowercase	:   bool										=      True
       __lowercase	:   Optional[bool]										=      None





class      lowerCAmelCase (			__lowerCAmelCase):
       __lowercase	:   Tuple										=      '''titi'''
       __lowercase	:   Any										=      '''toto'''





class      lowerCAmelCase (			__lowerCAmelCase):
       __lowercase	:   Union[str, Any]										=      '''titi'''
       __lowercase	:   Dict										=      '''toto'''
       __lowercase	:   str										=      42





@dataclass
class      lowerCAmelCase :
       __lowercase	:   BasicEnum										=      "toto"


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	BasicEnum(self.foo	)





@dataclass
class      lowerCAmelCase :
       __lowercase	:   MixedTypeEnum										=      "toto"


       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	MixedTypeEnum(self.foo	)





@dataclass
class      lowerCAmelCase :
       __lowercase	:   Optional[int]										=      None
       __lowercase	:   Optional[float]										=      field(default=__lowerCAmelCase					, metadata={'''help''': '''help message'''})
       __lowercase	:   Optional[str]										=      None
       __lowercase	:   Optional[List[str]]										=      list_field(default=[])
       __lowercase	:   Optional[List[int]]										=      list_field(default=[])





@dataclass
class      lowerCAmelCase :
       __lowercase	:   List[int]										=      list_field(default=[])
       __lowercase	:   List[int]										=      list_field(default=[1, 2, 3])
       __lowercase	:   List[str]										=      list_field(default=['''Hallo''', '''Bonjour''', '''Hello'''])
       __lowercase	:   List[float]										=      list_field(default=[0.1, 0.2, 0.3])





@dataclass
class      lowerCAmelCase :
       __lowercase	:   List[int]										=      field()
       __lowercase	:   str										=      field()
       __lowercase	:   BasicEnum										=      field()


       def    lowerCAmelCase   ( self	)   ->	List[str]:



            '''simple docstring'''




            __snake_case            =	BasicEnum(self.required_enum	)





@dataclass
class      lowerCAmelCase :
       __lowercase	:   int
       __lowercase	:   "BasicEnum"										=      field()
       __lowercase	:   "Optional[bool]"										=      None
       __lowercase	:   "str"										=      field(default='''toto'''					, metadata={'''help''': '''help message'''})
       __lowercase	:   "List[str]"										=      list_field(default=['''Hallo''', '''Bonjour''', '''Hello'''])


if is_python_no_less_than_3_10:





     @dataclass
     class      lowerCAmelCase :
            __lowercase	:   bool										=      False
            __lowercase	:   bool										=      True
            __lowercase	:   bool | None										=      None





     @dataclass
     class      lowerCAmelCase :
            __lowercase	:   int | None										=      None
            __lowercase	:   float | None										=      field(default=__lowerCAmelCase					, metadata={'''help''': '''help message'''})
            __lowercase	:   str | None										=      None
            __lowercase	:   list[str] | None										=      list_field(default=[])
            __lowercase	:   list[int] | None										=      list_field(default=[])







class      lowerCAmelCase (			unittest.TestCase):


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	str:



            '''simple docstring'''




            self.assertEqual(len(a._actions	)     ,	len(b._actions	)	)
            for x, y in zip(a._actions     ,	b._actions	):
                 __snake_case            =	{k: v for k, v in vars(__SCREAMING_SNAKE_CASE	).items() if k != '''container'''}
                 __snake_case            =	{k: v for k, v in vars(__SCREAMING_SNAKE_CASE	).items() if k != '''container'''}

                 # Choices with mixed type have custom function as "type"
                 # So we need to compare results directly for equality
                 if xx.get('''choices'''     ,	__SCREAMING_SNAKE_CASE	) and yy.get('''choices'''     ,	__SCREAMING_SNAKE_CASE	):
                      for expected_choice in yy["choices"] + xx["choices"]:
                           self.assertEqual(xx['''type'''](__SCREAMING_SNAKE_CASE	)     ,	yy['''type'''](__SCREAMING_SNAKE_CASE	)	)
                      del xx["type"], yy["type"]

                 self.assertEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''     ,	type=__SCREAMING_SNAKE_CASE     ,	required=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--bar'''     ,	type=__SCREAMING_SNAKE_CASE     ,	required=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--baz'''     ,	type=__SCREAMING_SNAKE_CASE     ,	required=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--flag'''     ,	type=__SCREAMING_SNAKE_CASE     ,	default=__SCREAMING_SNAKE_CASE     ,	const=__SCREAMING_SNAKE_CASE     ,	nargs='''?'''	)
            self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	['''--foo''', '''1''', '''--baz''', '''quux''', '''--bar''', '''0.5''']
            ((__snake_case)       ,     )            =	parser.parse_args_into_dataclasses(__SCREAMING_SNAKE_CASE     ,	look_for_args_file=__SCREAMING_SNAKE_CASE	)
            self.assertFalse(example.flag	)


       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''     ,	default=42     ,	type=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--baz'''     ,	default='''toto'''     ,	type=__SCREAMING_SNAKE_CASE     ,	help='''help message'''	)
            self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''     ,	type=__SCREAMING_SNAKE_CASE     ,	default=__SCREAMING_SNAKE_CASE     ,	const=__SCREAMING_SNAKE_CASE     ,	nargs='''?'''	)
            expected.add_argument('''--baz'''     ,	type=__SCREAMING_SNAKE_CASE     ,	default=__SCREAMING_SNAKE_CASE     ,	const=__SCREAMING_SNAKE_CASE     ,	nargs='''?'''	)
            # A boolean no_* argument always has to come after its "default: True" regular counter-part
            # and its default must be set to False
            expected.add_argument('''--no_baz'''     ,	action='''store_false'''     ,	default=__SCREAMING_SNAKE_CASE     ,	dest='''baz'''	)
            expected.add_argument('''--opt'''     ,	type=__SCREAMING_SNAKE_CASE     ,	default=__SCREAMING_SNAKE_CASE	)

            __snake_case            =	[WithDefaultBoolExample]
            if is_python_no_less_than_3_10:
                 dataclass_types.append(__SCREAMING_SNAKE_CASE	)

            for dataclass_type in dataclass_types:
                 __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)
                 self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

                 __snake_case            =	parser.parse_args([]	)
                 self.assertEqual(__SCREAMING_SNAKE_CASE     ,	Namespace(foo=__SCREAMING_SNAKE_CASE     ,	baz=__SCREAMING_SNAKE_CASE     ,	opt=__SCREAMING_SNAKE_CASE	)	)

                 __snake_case            =	parser.parse_args(['''--foo''', '''--no_baz''']	)
                 self.assertEqual(__SCREAMING_SNAKE_CASE     ,	Namespace(foo=__SCREAMING_SNAKE_CASE     ,	baz=__SCREAMING_SNAKE_CASE     ,	opt=__SCREAMING_SNAKE_CASE	)	)

                 __snake_case            =	parser.parse_args(['''--foo''', '''--baz''']	)
                 self.assertEqual(__SCREAMING_SNAKE_CASE     ,	Namespace(foo=__SCREAMING_SNAKE_CASE     ,	baz=__SCREAMING_SNAKE_CASE     ,	opt=__SCREAMING_SNAKE_CASE	)	)

                 __snake_case            =	parser.parse_args(['''--foo''', '''True''', '''--baz''', '''True''', '''--opt''', '''True''']	)
                 self.assertEqual(__SCREAMING_SNAKE_CASE     ,	Namespace(foo=__SCREAMING_SNAKE_CASE     ,	baz=__SCREAMING_SNAKE_CASE     ,	opt=__SCREAMING_SNAKE_CASE	)	)

                 __snake_case            =	parser.parse_args(['''--foo''', '''False''', '''--baz''', '''False''', '''--opt''', '''False''']	)
                 self.assertEqual(__SCREAMING_SNAKE_CASE     ,	Namespace(foo=__SCREAMING_SNAKE_CASE     ,	baz=__SCREAMING_SNAKE_CASE     ,	opt=__SCREAMING_SNAKE_CASE	)	)


       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument(
                '''--foo'''     ,	default='''toto'''     ,	choices=['''titi''', '''toto''', 42]     ,	type=make_choice_type_function(['''titi''', '''toto''', 42]	)     ,	)
            self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	parser.parse_args([]	)
            self.assertEqual(args.foo     ,	'''toto'''	)
            __snake_case            =	parser.parse_args_into_dataclasses([]	)[0]
            self.assertEqual(enum_ex.foo     ,	MixedTypeEnum.toto	)

            __snake_case            =	parser.parse_args(['''--foo''', '''titi''']	)
            self.assertEqual(args.foo     ,	'''titi'''	)
            __snake_case            =	parser.parse_args_into_dataclasses(['''--foo''', '''titi''']	)[0]
            self.assertEqual(enum_ex.foo     ,	MixedTypeEnum.titi	)

            __snake_case            =	parser.parse_args(['''--foo''', '''42''']	)
            self.assertEqual(args.foo     ,	42	)
            __snake_case            =	parser.parse_args_into_dataclasses(['''--foo''', '''42''']	)[0]
            self.assertEqual(enum_ex.foo     ,	MixedTypeEnum.fourtytwo	)


       def    lowerCAmelCase   ( self	)   ->	Optional[Any]:



            '''simple docstring'''




            @dataclass
            class      lowerCAmelCase :
                   __lowercase	:   Literal["titi", "toto", 42]										=      "toto"





            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument(
                '''--foo'''     ,	default='''toto'''     ,	choices=('''titi''', '''toto''', 42)     ,	type=make_choice_type_function(['''titi''', '''toto''', 42]	)     ,	)
            self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	parser.parse_args([]	)
            self.assertEqual(args.foo     ,	'''toto'''	)

            __snake_case            =	parser.parse_args(['''--foo''', '''titi''']	)
            self.assertEqual(args.foo     ,	'''titi'''	)

            __snake_case            =	parser.parse_args(['''--foo''', '''42''']	)
            self.assertEqual(args.foo     ,	42	)


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument('''--foo_int'''     ,	nargs='''+'''     ,	default=[]     ,	type=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--bar_int'''     ,	nargs='''+'''     ,	default=[1, 2, 3]     ,	type=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--foo_str'''     ,	nargs='''+'''     ,	default=['''Hallo''', '''Bonjour''', '''Hello''']     ,	type=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--foo_float'''     ,	nargs='''+'''     ,	default=[0.1, 0.2, 0.3]     ,	type=__SCREAMING_SNAKE_CASE	)

            self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	parser.parse_args([]	)
            self.assertEqual(
                __SCREAMING_SNAKE_CASE     ,	Namespace(foo_int=[]     ,	bar_int=[1, 2, 3]     ,	foo_str=['''Hallo''', '''Bonjour''', '''Hello''']     ,	foo_float=[0.1, 0.2, 0.3]	)     ,	)

            __snake_case            =	parser.parse_args('''--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7'''.split()	)
            self.assertEqual(__SCREAMING_SNAKE_CASE     ,	Namespace(foo_int=[1]     ,	bar_int=[2, 3]     ,	foo_str=['''a''', '''b''', '''c''']     ,	foo_float=[0.1, 0.7]	)	)


       def    lowerCAmelCase   ( self	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''     ,	default=__SCREAMING_SNAKE_CASE     ,	type=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--bar'''     ,	default=__SCREAMING_SNAKE_CASE     ,	type=__SCREAMING_SNAKE_CASE     ,	help='''help message'''	)
            expected.add_argument('''--baz'''     ,	default=__SCREAMING_SNAKE_CASE     ,	type=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--ces'''     ,	nargs='''+'''     ,	default=[]     ,	type=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--des'''     ,	nargs='''+'''     ,	default=[]     ,	type=__SCREAMING_SNAKE_CASE	)

            __snake_case            =	[OptionalExample]
            if is_python_no_less_than_3_10:
                 dataclass_types.append(__SCREAMING_SNAKE_CASE	)

            for dataclass_type in dataclass_types:
                 __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

                 self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)

                 __snake_case            =	parser.parse_args([]	)
                 self.assertEqual(__SCREAMING_SNAKE_CASE     ,	Namespace(foo=__SCREAMING_SNAKE_CASE     ,	bar=__SCREAMING_SNAKE_CASE     ,	baz=__SCREAMING_SNAKE_CASE     ,	ces=[]     ,	des=[]	)	)

                 __snake_case            =	parser.parse_args('''--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3'''.split()	)
                 self.assertEqual(__SCREAMING_SNAKE_CASE     ,	Namespace(foo=12     ,	bar=3.14     ,	baz='''42'''     ,	ces=['''a''', '''b''', '''c''']     ,	des=[1, 2, 3]	)	)


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument('''--required_list'''     ,	nargs='''+'''     ,	type=__SCREAMING_SNAKE_CASE     ,	required=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--required_str'''     ,	type=__SCREAMING_SNAKE_CASE     ,	required=__SCREAMING_SNAKE_CASE	)
            expected.add_argument(
                '''--required_enum'''     ,	type=make_choice_type_function(['''titi''', '''toto''']	)     ,	choices=['''titi''', '''toto''']     ,	required=__SCREAMING_SNAKE_CASE     ,	)
            self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	argparse.ArgumentParser()
            expected.add_argument('''--foo'''     ,	type=__SCREAMING_SNAKE_CASE     ,	required=__SCREAMING_SNAKE_CASE	)
            expected.add_argument(
                '''--required_enum'''     ,	type=make_choice_type_function(['''titi''', '''toto''']	)     ,	choices=['''titi''', '''toto''']     ,	required=__SCREAMING_SNAKE_CASE     ,	)
            expected.add_argument('''--opt'''     ,	type=__SCREAMING_SNAKE_CASE     ,	default=__SCREAMING_SNAKE_CASE	)
            expected.add_argument('''--baz'''     ,	default='''toto'''     ,	type=__SCREAMING_SNAKE_CASE     ,	help='''help message'''	)
            expected.add_argument('''--foo_str'''     ,	nargs='''+'''     ,	default=['''Hallo''', '''Bonjour''', '''Hello''']     ,	type=__SCREAMING_SNAKE_CASE	)
            self.argparsersEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }

            __snake_case            =	parser.parse_dict(__SCREAMING_SNAKE_CASE	)[0]
            __snake_case            =	BasicExample(**__SCREAMING_SNAKE_CASE	)
            self.assertEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
                '''extra''': 42,
            }

            self.assertRaises(__SCREAMING_SNAKE_CASE     ,	parser.parse_dict     ,	__SCREAMING_SNAKE_CASE     ,	allow_extra_keys=__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }
            with tempfile.TemporaryDirectory() as tmp_dir:
                 __snake_case            =	os.path.join(__SCREAMING_SNAKE_CASE     ,	'''temp_json'''	)
                 os.mkdir(__SCREAMING_SNAKE_CASE	)
                 with open(temp_local_path + '''.json'''     ,	'''w+'''	) as f:
                      json.dump(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	parser.parse_yaml_file(Path(temp_local_path + '''.json'''	)	)[0]

            __snake_case            =	BasicExample(**__SCREAMING_SNAKE_CASE	)
            self.assertEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	{
                '''foo''': 12,
                '''bar''': 3.14,
                '''baz''': '''42''',
                '''flag''': True,
            }
            with tempfile.TemporaryDirectory() as tmp_dir:
                 __snake_case            =	os.path.join(__SCREAMING_SNAKE_CASE     ,	'''temp_yaml'''	)
                 os.mkdir(__SCREAMING_SNAKE_CASE	)
                 with open(temp_local_path + '''.yaml'''     ,	'''w+'''	) as f:
                      yaml.dump(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	parser.parse_yaml_file(Path(temp_local_path + '''.yaml'''	)	)[0]
            __snake_case            =	BasicExample(**__SCREAMING_SNAKE_CASE	)
            self.assertEqual(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)




       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	HfArgumentParser(__SCREAMING_SNAKE_CASE	)
            self.assertIsNotNone(__SCREAMING_SNAKE_CASE	)














class 					SCREAMING_SNAKE_CASE_  :
       """simple docstring"""


       def __init__(				self	:List[Any]):



          """simple docstring"""

          _lowercase              ={}





       def 				UpperCamelCase__						(				self	:str):



          """simple docstring"""

          print(self.vertex)
          for i in self.vertex:
             print(snake_case,      ' -> ',      ' -> '.join([str(snake_case) for j in self.vertex[i]]))





       def 				UpperCamelCase__						(				self	:Any,      snake_case	:int,      snake_case	:int):



          """simple docstring"""

          if from_vertex in self.vertex:
             self.vertex[from_vertex].append(snake_case)
          else:
             # else make a new vertex
             _lowercase              =[to_vertex]





       def 				UpperCamelCase__						(				self	:Union[str, Any]):



          """simple docstring"""

          _lowercase              =[False] * len(self.vertex)

          # call the recursive helper function
          for i in range(len(self.vertex)):
             if not visited[i]:
                self.dfs_recursive(snake_case,      snake_case)





       def 				UpperCamelCase__						(				self	:List[str],      snake_case	:int,      snake_case	:list):



          """simple docstring"""

          _lowercase              =True

          print(snake_case,      end=' ')

          # Recur for all the vertices that are adjacent to this node
          for i in self.vertex:
             if not visited[i]:
                self.dfs_recursive(snake_case,      snake_case)


if __name__ == "__main__":
    _SCREAMING_SNAKE_CASE   =  Graph()
    g.add_edge(0, 1)
    g.add_edge(0, 2)
    g.add_edge(1, 2)
    g.add_edge(2, 0)
    g.add_edge(2, 3)
    g.add_edge(3, 3)

    g.print_graph()
    print("DFS:")
    g.dfs()

    # OUTPUT:
    # 0  ->  1 -> 2
    # 1  ->  2
    # 2  ->  0 -> 3
    # 3  ->  3
    # DFS:
    #  0 1 2 3


