



'''simple docstring'''





class 	lowerCamelCase_    :






						'''simple docstring'''







						def __init__(	self      :			Tuple )      ->				Optional[Any]:
									A							:					str              =						{}







						def 			SCREAMING_SNAKE_CASE__		(	self      :			int )      ->				None:
									print(self.vertex )
									for i in self.vertex:
												print(lowercase_	,	" -> "	,	" -> ".join([str(lowercase_ ) for j in self.vertex[i]] ) )







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Any	,	__lowerCamelCase      :			int	,	__lowerCamelCase      :			int )      ->				None:







									if from_vertex in self.vertex:
												self.vertex[from_vertex].append(lowercase_ )
									else:
												# else make a new vertex
												A							:					Optional[Any]              =						[to_vertex]







						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[str] )      ->				None:
									A							:					Dict              =						[False] * len(self.vertex )

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[str]	,	__lowerCamelCase      :			int	,	__lowerCamelCase      :			list )      ->				None:
									A							:					List[str]              =						True

									print(lowercase_	,	end=" " )

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


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




from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Sequence, Value
from .base import TaskTemplate

@dataclass(frozen=_A						)
class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''
						# `task` is not a ClassVar since we want it to be part of the `asdict` output for JSON serialization
						a__   =  field(default="question-answering-extractive"						,metadata={"include_in_asdict_even_if_is_default": True}						)
						a__   =  Features({"question": Value("string"						), "context": Value("string"						)}						)
						a__   =  Features(
						    {
						        "answers": Sequence(
						            {
						                "text": Value("string"						),
						                "answer_start": Value("int32"						),
						            }						)
						    }						)
						a__   =  "question"
						a__   =  "context"
						a__   =  "answers"







						@property
						def 			SCREAMING_SNAKE_CASE__		(	self      :			Union[str, Any] )      ->				Dict[str, str]:
									return {self.question_column: "question", self.context_column: "context", self.answers_column: "answers"}