





from typing import Any



class 							_UpperCamelCase					:

							def __init__(		self: Any					,   _SCREAMING_SNAKE_CASE: Tuple		)       -> List[str]:




														"""simple docstring"""


														UpperCamelCase_          =  data
														UpperCamelCase_          =  None



							def __repr__(		self: Optional[Any]		)       -> str:




														"""simple docstring"""


														return f'''Node({self.data})'''



class 							_UpperCamelCase					:

							def __init__(		self: Optional[int]		)       -> Optional[Any]:




														"""simple docstring"""


														UpperCamelCase_          =  None

							def __iter__(		self: str		)       -> Any:




														"""simple docstring"""


														UpperCamelCase_          =  self.head
														while node:
																					yield node.data
																					UpperCamelCase_          =  node.next

							def __len__(		self: Tuple		)       -> int:




														"""simple docstring"""


														return sum(1 for _ in self		)

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




														"""simple docstring"""


														return "->".join([str(_SCREAMING_SNAKE_CASE		) for item in self]		)

							def __getitem__(		self: Dict					,   _SCREAMING_SNAKE_CASE: Dict		)       -> Any:




														"""simple docstring"""


														if not 0 <= index < len(self		):
																					raise ValueError("list index out of range."		)
														for i, node in enumerate(self		):
																					if i == index:
																												return node
														return None

							def __setitem__(		self: Any					,   _SCREAMING_SNAKE_CASE: str					,   _SCREAMING_SNAKE_CASE: Tuple		)       -> None:




														"""simple docstring"""


														if not 0 <= index < len(self		):
																					raise ValueError("list index out of range."		)
														UpperCamelCase_          =  self.head
														for _ in range(_SCREAMING_SNAKE_CASE		):
																					UpperCamelCase_          =  current.next
														UpperCamelCase_          =  data

							def lowercase (		self: str					,   _SCREAMING_SNAKE_CASE: Dict		)       -> None:




														"""simple docstring"""


														self.insert_nth(len(self		)					,   _SCREAMING_SNAKE_CASE		)

							def lowercase (		self: Any					,   _SCREAMING_SNAKE_CASE: List[str]		)       -> None:




														"""simple docstring"""


														self.insert_nth(0					,   _SCREAMING_SNAKE_CASE		)

							def lowercase (		self: int					,   _SCREAMING_SNAKE_CASE: List[Any]					,   _SCREAMING_SNAKE_CASE: Optional[Any]		)       -> None:




														"""simple docstring"""


														if not 0 <= index <= len(self		):
																					raise IndexError("list index out of range"		)
														UpperCamelCase_          =  Node(_SCREAMING_SNAKE_CASE		)
														if self.head is None:
																					UpperCamelCase_          =  new_node
														elif index == 0:
																					UpperCamelCase_          =  self.head  # link new_node to head
																					UpperCamelCase_          =  new_node
														else:
																					UpperCamelCase_          =  self.head
																					for _ in range(index - 1		):
																												UpperCamelCase_          =  temp.next
																					UpperCamelCase_          =  temp.next
																					UpperCamelCase_          =  new_node

							def lowercase (		self: List[Any]		)       -> None:  # print every node data




														"""simple docstring"""


														print(self		)

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




														"""simple docstring"""


														return self.delete_nth(0		)

							def lowercase (		self: str		)       -> Any:  # delete from tail




														"""simple docstring"""


														return self.delete_nth(len(self		) - 1		)

							def lowercase (		self: List[Any]					,   _SCREAMING_SNAKE_CASE: Any = 0		)       -> Any:




														"""simple docstring"""


														if not 0 <= index <= len(self		) - 1:  # test if index is valid
																					raise IndexError("List index out of range."		)
														UpperCamelCase_          =  self.head  # default first node
														if index == 0:
																					UpperCamelCase_          =  self.head.next
														else:
																					UpperCamelCase_          =  self.head
																					for _ in range(index - 1		):
																												UpperCamelCase_          =  temp.next
																					UpperCamelCase_          =  temp.next
																					UpperCamelCase_          =  temp.next.next
														return delete_node.data

							def lowercase (		self: Union[str, Any]		)       -> bool:




														"""simple docstring"""


														return self.head is None



							def lowercase (		self: int		)       -> None:




														"""simple docstring"""


														UpperCamelCase_          =  None
														UpperCamelCase_          =  self.head

														while current:
																					# Store the current node's next node.
																					UpperCamelCase_          =  current.next
																					# Make the current node's next point backwards
																					UpperCamelCase_          =  prev
																					# Make the previous node be the current node
																					UpperCamelCase_          =  current
																					# Make the current node the next node (to progress iteration)
																					UpperCamelCase_          =  next_node
														# Return prev in order to put the head at the end
														UpperCamelCase_          =  prev




def  lowerCAmelCase_ (							)     ->		None:
							UpperCamelCase_          =  LinkedList()
							assert linked_list.is_empty() is True
							assert str(__snake_case  ) == ""

							try:
														linked_list.delete_head()
														raise AssertionError  # This should not happen.
							except IndexError:
														assert True  # This should happen.

							try:
														linked_list.delete_tail()
														raise AssertionError  # This should not happen.
							except IndexError:
														assert True  # This should happen.

							for i in range(10  ):
														assert len(__snake_case  ) == i
														linked_list.insert_nth(__snake_case					,		i + 1  )
							assert str(__snake_case  ) == "->".join(str(__snake_case  ) for i in range(1					,		11  )  )

							linked_list.insert_head(0  )
							linked_list.insert_tail(11  )
							assert str(__snake_case  ) == "->".join(str(__snake_case  ) for i in range(0					,		12  )  )

							assert linked_list.delete_head() == 0
							assert linked_list.delete_nth(9  ) == 10
							assert linked_list.delete_tail() == 11
							assert len(__snake_case  ) == 9
							assert str(__snake_case  ) == "->".join(str(__snake_case  ) for i in range(1					,		10  )  )

							assert all(linked_list[i] == i + 1 for i in range(0					,		9  )  ) is True

							for i in range(0					,		9  ):
														UpperCamelCase_          =  -i
							assert all(linked_list[i] == -i for i in range(0					,		9  )  ) is True

							linked_list.reverse()
							assert str(__snake_case  ) == "->".join(str(__snake_case  ) for i in range(-8					,		1  )  )




def  lowerCAmelCase_ (							)     ->		None:
							UpperCamelCase_          =  [
							    -9,
							    100,
							    Node(77345112  ),
							    "dlrow olleH",
							    7,
							    5555,
							    0,
							    -192.55555,
							    "Hello, world!",
							    77.9,
							    Node(10  ),
							    None,
							    None,
							    12.20,
							]
							UpperCamelCase_          =  LinkedList()

							for i in test_input:
														linked_list.insert_tail(__snake_case  )

							# Check if it's empty or not
							assert linked_list.is_empty() is False
							assert (
							    str(__snake_case  ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
							    "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
							)

							# Delete the head
							UpperCamelCase_          =  linked_list.delete_head()
							assert result == -9
							assert (
							    str(__snake_case  ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
							    "Hello, world!->77.9->Node(10)->None->None->12.2"
							)

							# Delete the tail
							UpperCamelCase_          =  linked_list.delete_tail()
							assert result == 12.2
							assert (
							    str(__snake_case  ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
							    "Hello, world!->77.9->Node(10)->None->None"
							)

							# Delete a node in specific location in linked list
							UpperCamelCase_          =  linked_list.delete_nth(10  )
							assert result is None
							assert (
							    str(__snake_case  ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
							    "Hello, world!->77.9->Node(10)->None"
							)

							# Add a Node instance to its head
							linked_list.insert_head(Node("Hello again, world!"  )  )
							assert (
							    str(__snake_case  )
							    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
							    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
							)

							# Add None to its tail
							linked_list.insert_tail(__snake_case  )
							assert (
							    str(__snake_case  )
							    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
							    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
							)

							# Reverse the linked list
							linked_list.reverse()
							assert (
							    str(__snake_case  )
							    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
							    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
							)




def  lowerCAmelCase_ (							)     ->		List[str]:
							from doctest import testmod

							testmod()

							UpperCamelCase_          =  LinkedList()
							linked_list.insert_head(input("Inserting 1st at head "  ).strip()  )
							linked_list.insert_head(input("Inserting 2nd at head "  ).strip()  )
							print("\nPrint list:"  )
							linked_list.print_list()
							linked_list.insert_tail(input("\nInserting 1st at tail "  ).strip()  )
							linked_list.insert_tail(input("Inserting 2nd at tail "  ).strip()  )
							print("\nPrint list:"  )
							linked_list.print_list()
							print("\nDelete head"  )
							linked_list.delete_head()
							print("Delete tail"  )
							linked_list.delete_tail()
							print("\nPrint list:"  )
							linked_list.print_list()
							print("\nReverse linked list"  )
							linked_list.reverse()
							print("\nPrint list:"  )
							linked_list.print_list()
							print("\nString representation of linked list:"  )
							print(__snake_case  )
							print("\nReading/changing Node data using indexing:"  )
							print(F'''Element at Position 1: {linked_list[1]}'''  )
							UpperCamelCase_          =  input("Enter New Value: "  ).strip()
							print("New list:"  )
							print(__snake_case  )
							print(F'''length of linked_list is : {len(__snake_case  )}'''  )


if __name__ == "__main__":
					main()








import json
import os
import subprocess
import unittest
from ast import literal_eval

import pytest
from parameterized import parameterized, parameterized_class

from . import is_sagemaker_available


if is_sagemaker_available():
     from sagemaker import Session, TrainingJobAnalytics
     from sagemaker.huggingface import HuggingFace



@pytest.mark.skipif(
    literal_eval(os.getenv('''TEST_SAGEMAKER'''  ,						'''False'''     )     ) is not True  ,						reason='''Skipping test because should only be run when releasing minor transformers version'''  ,						)
@pytest.mark.usefixtures('''sm_env'''     )
@parameterized_class(
    [
        {
            '''framework''': '''pytorch''',
            '''script''': '''run_glue.py''',
            '''model_name_or_path''': '''distilbert-base-cased''',
            '''instance_type''': '''ml.p3.16xlarge''',
            '''results''': {'''train_runtime''': 6_5_0, '''eval_accuracy''': 0.7, '''eval_loss''': 0.6},
        },
        {
            '''framework''': '''pytorch''',
            '''script''': '''run_ddp.py''',
            '''model_name_or_path''': '''distilbert-base-cased''',
            '''instance_type''': '''ml.p3.16xlarge''',
            '''results''': {'''train_runtime''': 6_0_0, '''eval_accuracy''': 0.7, '''eval_loss''': 0.6},
        },
        {
            '''framework''': '''tensorflow''',
            '''script''': '''run_tf_dist.py''',
            '''model_name_or_path''': '''distilbert-base-cased''',
            '''instance_type''': '''ml.p3.16xlarge''',
            '''results''': {'''train_runtime''': 6_0_0, '''eval_accuracy''': 0.6, '''eval_loss''': 0.7},
        },
    ]     )
class 							_UpperCamelCase					(	unittest.TestCase     ):

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




              """simple docstring"""


              if self.framework == "pytorch":
                     subprocess.run(
                         f'''cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py'''.split()					,   encoding="utf-8"					,   check=_SCREAMING_SNAKE_CASE					,   )
              assert hasattr(self					,   "env"		)

       def lowercase (		self: List[str]					,   _SCREAMING_SNAKE_CASE: Dict		)       -> str:




              """simple docstring"""


              UpperCamelCase_          =  f'''{self.env.base_job_name}-{instance_count}-{"ddp" if "ddp" in self.script else "smd"}'''
              # distributed data settings
              UpperCamelCase_          =  {"smdistributed": {"dataparallel": {"enabled": True}}} if self.script != "run_ddp.py" else None

              # creates estimator
              return HuggingFace(
                  entry_point=self.script					,   source_dir=self.env.test_path					,   role=self.env.role					,   image_uri=self.env.image_uri					,   base_job_name=_SCREAMING_SNAKE_CASE					,   instance_count=_SCREAMING_SNAKE_CASE					,   instance_type=self.instance_type					,   debugger_hook_config=_SCREAMING_SNAKE_CASE					,   hyperparameters={**self.env.distributed_hyperparameters, "model_name_or_path": self.model_name_or_path}					,   metric_definitions=self.env.metric_definitions					,   distribution=_SCREAMING_SNAKE_CASE					,   py_version="py36"					,   )

       def lowercase (		self: List[str]					,   _SCREAMING_SNAKE_CASE: Any		)       -> List[Any]:




              """simple docstring"""


              TrainingJobAnalytics(_SCREAMING_SNAKE_CASE		).export_csv(f'''{self.env.test_path}/{job_name}_metrics.csv'''		)



       @parameterized.expand([(2,)]		)
       def lowercase (		self: str					,   _SCREAMING_SNAKE_CASE: Tuple		)       -> Optional[Any]:




              """simple docstring"""


              UpperCamelCase_          =  self.create_estimator(_SCREAMING_SNAKE_CASE		)

              # run training
              estimator.fit()

              # result dataframe
              UpperCamelCase_          =  TrainingJobAnalytics(estimator.latest_training_job.name		).dataframe()

              # extract kpis
              UpperCamelCase_          =  list(result_metrics_df[result_metrics_df.metric_name == "eval_accuracy"]["value"]		)
              UpperCamelCase_          =  list(result_metrics_df[result_metrics_df.metric_name == "eval_loss"]["value"]		)
              # get train time from SageMaker job, this includes starting, preprocessing, stopping
              UpperCamelCase_          =  (
                  Session().describe_training_job(estimator.latest_training_job.name		).get("TrainingTimeInSeconds"					,   999999		)
              )

              # assert kpis
              assert train_runtime <= self.results["train_runtime"]
              assert all(t >= self.results["eval_accuracy"] for t in eval_accuracy		)
              assert all(t <= self.results["eval_loss"] for t in eval_loss		)

              # dump tests result into json file to share in PR
              with open(f'''{estimator.latest_training_job.name}.json'''					,   "w"		) as outfile:
                     json.dump({"train_time": train_runtime, "eval_accuracy": eval_accuracy, "eval_loss": eval_loss}					,   _SCREAMING_SNAKE_CASE		)

