




'''simple docstring'''




from typing import Any


class   __UpperCamelCase       :






       def __init__(							self,		lowerCAmelCase  ):



              """simple docstring"""







              lowerCamelCase_							=data
              lowerCamelCase_							=None






       def __repr__(							self  ):



              """simple docstring"""







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





class   __UpperCamelCase       :






       def __init__(							self  ):



              """simple docstring"""







              lowerCamelCase_							=None






       def __iter__(							self  ):



              """simple docstring"""







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






       def __len__(							self  ):



              """simple docstring"""







              return sum(1 for _ in self  )






       def __repr__(							self  ):



              """simple docstring"""







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






       def __getitem__(							self,		lowerCAmelCase  ):



              """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,		lowerCAmelCase,		lowerCAmelCase  ):



              """simple docstring"""







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






       def      lowercase__     (							self,		lowerCAmelCase  ):



              """simple docstring"""







              self.insert_nth(len(self  ),		lowerCAmelCase  )






       def      lowercase__     (							self,		lowerCAmelCase  ):



              """simple docstring"""







              self.insert_nth(0,		lowerCAmelCase  )






       def      lowercase__     (							self,		lowerCAmelCase,		lowerCAmelCase  ):



              """simple docstring"""







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






       def      lowercase__     (							self  ):  # print every node data



              """simple docstring"""







              print(self  )






       def      lowercase__     (							self  ):



              """simple docstring"""







              return self.delete_nth(0  )






       def      lowercase__     (							self  ):  # delete from tail



              """simple docstring"""







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






       def      lowercase__     (							self,		lowerCAmelCase = 0  ):



              """simple docstring"""







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






       def      lowercase__     (							self  ):



              """simple docstring"""







              return self.head is None






       def      lowercase__     (							self  ):



              """simple docstring"""







              lowerCamelCase_							=None
              lowerCamelCase_							=self.head

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





def      a_							(      )							->						None:



       """simple docstring"""
       lowerCamelCase_							=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   ):
              lowerCamelCase_							=-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      a_							(      )							->						None:



       """simple docstring"""
       lowerCamelCase_							=[
           -9,
           100,
           Node(7734_5112   ),
           '''dlrow olleH''',
           7,
           5555,
           0,
           -1_9_2.5_5_5_5_5,
           '''Hello, world!''',
           7_7.9,
           Node(10   ),
           None,
           None,
           1_2.2_0,
       ]
       lowerCamelCase_							=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
       lowerCamelCase_							=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
       lowerCamelCase_							=linked_list.delete_tail()
       assert result == 1_2.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
       lowerCamelCase_							=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      a_							(      )							->						Tuple:



       """simple docstring"""
       from doctest import testmod

       testmod()

       lowerCamelCase_							=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]}'''   )
       lowerCamelCase_							=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()









"""simple docstring"""
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_model_parallelism.py""",
            """model_name_or_path""": """roberta-large""",
            """instance_type""": """ml.p3dn.24xlarge""",
            """results""": {"""train_runtime""": 1_6_0_0, """eval_accuracy""": 0.3, """eval_loss""": 1.2},
        },
        {
            """framework""": """pytorch""",
            """script""": """run_glue.py""",
            """model_name_or_path""": """roberta-large""",
            """instance_type""": """ml.p3dn.24xlarge""",
            """results""": {"""train_runtime""": 1_6_0_0, """eval_accuracy""": 0.3, """eval_loss""": 1.2},
        },
    ]				)
class 				lowerCamelCase  (			unittest.TestCase				):






					'''simple docstring'''





					def    lowerCAmelCase_				(       self:							Any						)   ->	str:
											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=snake_case						,     )
											assert hasattr(self						,     """env"""						)






					def    lowerCAmelCase_				(       self:							int						,     snake_case:							Dict						)   ->	List[Any]:
											# configuration for running training on smdistributed Model Parallel
											snake_case_ :Tuple						=			{
											    """enabled""": True,
											    """processes_per_host""": 8,
											}
											snake_case_ :List[Any]						=			{
											    """enabled""": True,
											    """parameters""": {
											        """microbatches""": 4,
											        """placement_strategy""": """spread""",
											        """pipeline""": """interleaved""",
											        """optimize""": """speed""",
											        """partitions""": 4,
											        """ddp""": True,
											    },
											}

											snake_case_ :Tuple						=			{"""smdistributed""": {"""modelparallel""": smp_options}, """mpi""": mpi_options}

											snake_case_ :Any						=			"""trainer""" if self.script == """run_glue.py""" else """smtrainer"""
											# 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=f"""{self.env.base_job_name}-{instance_count}-smp-{name_extension}"""						,     instance_count=snake_case						,     instance_type=self.instance_type						,     debugger_hook_config=snake_case						,     hyperparameters={
											        **self.env.hyperparameters,
											        """model_name_or_path""": self.model_name_or_path,
											        """max_steps""": 500,
											    }						,     metric_definitions=self.env.metric_definitions						,     distribution=snake_case						,     py_version="""py36"""						,     )






					def    lowerCAmelCase_				(       self:							Any						,     snake_case:							Tuple						)   ->	List[str]:
											TrainingJobAnalytics(snake_case						).export_csv(f"""{self.env.test_path}/{job_name}_metrics.csv"""						)






					@parameterized.expand([(1,)]						)
					def    lowerCAmelCase_				(       self:							Dict						,     snake_case:							Dict						)   ->	List[Any]:
											# create estimator
											snake_case_ :List[Any]						=			self.create_estimator(snake_case						)

											# run training
											estimator.fit()

											# result dataframe
											snake_case_ :Any						=			TrainingJobAnalytics(estimator.latest_training_job.name						).dataframe()

											# extract kpis
											snake_case_ :Tuple						=			list(result_metrics_df[result_metrics_df.metric_name == """eval_accuracy"""]["""value"""]						)
											snake_case_ :Dict						=			list(result_metrics_df[result_metrics_df.metric_name == """eval_loss"""]["""value"""]						)
											# get train time from SageMaker job, this includes starting, preprocessing, stopping
											snake_case_ :int						=			(
											    Session().describe_training_job(estimator.latest_training_job.name						).get("""TrainingTimeInSeconds"""						,     999_999						)
											)

											# 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}						,     snake_case						)
