
'''simple docstring'''
from typing import Any






class 	snake_case__       :







		"""simple docstring"""

		def __init__(      self				:			Any  ,	UpperCamelCase__				:			Any      )						->			List[Any]:






				"""simple docstring"""







				snake_case  :       int     			=						data
				snake_case  :       Optional[int]     			=						None



		def __repr__(      self				:			str      )						->			str:






				"""simple docstring"""







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







class 	snake_case__       :







		"""simple docstring"""

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






				"""simple docstring"""







				snake_case  :       Tuple     			=						None



		def __iter__(      self				:			Tuple      )						->			Any:






				"""simple docstring"""







				snake_case  :       str     			=						self.head
				while node:
						yield node.data
						snake_case  :       Optional[Any]     			=						node.next



		def __len__(      self				:			Union[str, Any]      )						->			int:






				"""simple docstring"""







				return sum(1 for _ in self      )



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






				"""simple docstring"""







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



		def __getitem__(      self				:			str  ,	UpperCamelCase__				:			int      )						->			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				:			List[Any]  ,	UpperCamelCase__				:			int  ,	UpperCamelCase__				:			Any      )						->			None:






				"""simple docstring"""







				if not 0 <= index < len(self      ):
						raise ValueError('''list index out of range.'''      )
				snake_case  :       Optional[Any]     			=						self.head
				for _ in range(UpperCamelCase__      ):
						snake_case  :       Optional[int]     			=						current.next
				snake_case  :       str     			=						data



		def       lowerCAmelCase				(      self				:			Dict  ,	UpperCamelCase__				:			Any      )						->			None:






				"""simple docstring"""







				self.insert_nth(len(self      )  ,	UpperCamelCase__      )



		def       lowerCAmelCase				(      self				:			str  ,	UpperCamelCase__				:			Any      )						->			None:






				"""simple docstring"""







				self.insert_nth(0  ,	UpperCamelCase__      )



		def       lowerCAmelCase				(      self				:			Optional[Any]  ,	UpperCamelCase__				:			int  ,	UpperCamelCase__				:			Any      )						->			None:






				"""simple docstring"""







				if not 0 <= index <= len(self      ):
						raise IndexError('''list index out of range'''      )
				snake_case  :       str     			=						Node(UpperCamelCase__      )
				if self.head is None:
						snake_case  :       Tuple     			=						new_node
				elif index == 0:
						snake_case  :       Union[str, Any]     			=						self.head  # link new_node to head
						snake_case  :       Union[str, Any]     			=						new_node
				else:
						snake_case  :       Tuple     			=						self.head
						for _ in range(index - 1      ):
								snake_case  :       int     			=						temp.next
						snake_case  :       int     			=						temp.next
						snake_case  :       Tuple     			=						new_node



		def       lowerCAmelCase				(      self				:			Optional[int]      )						->			None:  # print every node data






				"""simple docstring"""







				print(self      )



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






				"""simple docstring"""







				return self.delete_nth(0      )



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






				"""simple docstring"""







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



		def       lowerCAmelCase				(      self				:			Optional[int]  ,	UpperCamelCase__				:			int = 0      )						->			Any:






				"""simple docstring"""







				if not 0 <= index <= len(self      ) - 1:  # test if index is valid
						raise IndexError('''List index out of range.'''      )
				snake_case  :       Union[str, Any]     			=						self.head  # default first node
				if index == 0:
						snake_case  :       Tuple     			=						self.head.next
				else:
						snake_case  :       Tuple     			=						self.head
						for _ in range(index - 1      ):
								snake_case  :       List[str]     			=						temp.next
						snake_case  :       Optional[int]     			=						temp.next
						snake_case  :       Any     			=						temp.next.next
				return delete_node.data



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






				"""simple docstring"""







				return self.head is None



		def       lowerCAmelCase				(      self				:			Dict      )						->			None:






				"""simple docstring"""







				snake_case  :       Any     			=						None
				snake_case  :       Any     			=						self.head

				while current:
						# Store the current node's next node.
						snake_case  :       Any     			=						current.next
						# Make the current node's next point backwards
						snake_case  :       Union[str, Any]     			=						prev
						# Make the previous node be the current node
						snake_case  :       Dict     			=						current
						# Make the current node the next node (to progress iteration)
						snake_case  :       Tuple     			=						next_node
				# Return prev in order to put the head at the end
				snake_case  :       Tuple     			=						prev







def    _UpperCamelCase						(       )  ->							None:


		'''simple docstring'''


		snake_case  :       Any     			=						LinkedList()
		assert linked_list.is_empty() is True
		assert str(SCREAMING_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(SCREAMING_SNAKE_CASE__			) == i
				linked_list.insert_nth(SCREAMING_SNAKE_CASE__ ,       i + 1			)
		assert str(SCREAMING_SNAKE_CASE__			) == "->".join(str(SCREAMING_SNAKE_CASE__			) for i in range(1 ,       11			)			)

		linked_list.insert_head(0			)
		linked_list.insert_tail(11			)
		assert str(SCREAMING_SNAKE_CASE__			) == "->".join(str(SCREAMING_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(SCREAMING_SNAKE_CASE__			) == 9
		assert str(SCREAMING_SNAKE_CASE__			) == "->".join(str(SCREAMING_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			):
				snake_case  :       Dict     			=						-i
		assert all(linked_list[i] == -i for i in range(0 ,       9			)			) is True

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




def    _UpperCamelCase						(       )  ->							None:


		'''simple docstring'''


		snake_case  :       Dict     			=						[
		    -9,
		    100,
		    Node(7734_5112			),
		    '''dlrow olleH''',
		    7,
		    5555,
		    0,
		    -192.5_5555,
		    '''Hello, world!''',
		    77.9,
		    Node(10			),
		    None,
		    None,
		    12.20,
		]
		snake_case  :       Tuple     			=						LinkedList()

		for i in test_input:
				linked_list.insert_tail(SCREAMING_SNAKE_CASE__			)

		# Check if it's empty or not
		assert linked_list.is_empty() is False
		assert (
		    str(SCREAMING_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
		snake_case  :       Any     			=						linked_list.delete_head()
		assert result == -9
		assert (
		    str(SCREAMING_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
		snake_case  :       str     			=						linked_list.delete_tail()
		assert result == 12.2
		assert (
		    str(SCREAMING_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
		snake_case  :       Optional[Any]     			=						linked_list.delete_nth(10			)
		assert result is None
		assert (
		    str(SCREAMING_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(SCREAMING_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(SCREAMING_SNAKE_CASE__			)
		assert (
		    str(SCREAMING_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(SCREAMING_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    _UpperCamelCase						(       )  ->							str:


		'''simple docstring'''


		from doctest import testmod

		testmod()

		snake_case  :       Union[str, Any]     			=						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(SCREAMING_SNAKE_CASE__			)
		print('''\nReading/changing Node data using indexing:'''			)
		print(F'Element at Position 1: {linked_list[1]}'			)
		snake_case  :       Union[str, Any]     			=						input('''Enter New Value: '''			).strip()
		print('''New list:'''			)
		print(SCREAMING_SNAKE_CASE__			)
		print(F'length of linked_list is : {len(SCREAMING_SNAKE_CASE__			)}'			)


if __name__ == "__main__":
						main()




'''simple docstring'''
import os
from collections.abc import Iterator




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ = "."			)  ->							Iterator[str]:


		'''simple docstring'''


		for dir_path, dir_names, filenames in os.walk(SCREAMING_SNAKE_CASE__			):
				snake_case  :       Optional[Any]     			=						[d for d in dir_names if d != '''scripts''' and d[0] not in '''._''']
				for filename in filenames:
						if filename == "__init__.py":
								continue
						if os.path.splitext(SCREAMING_SNAKE_CASE__			)[1] in (".py", ".ipynb"):
								yield os.path.join(SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__			).lstrip('''./'''			)




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__			)  ->							List[str]:


		'''simple docstring'''


		return F'{i * "  "}*' if i else "\n##"




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__			)  ->							str:


		'''simple docstring'''


		snake_case  :       Union[str, Any]     			=						old_path.split(os.sep			)
		for i, new_part in enumerate(new_path.split(os.sep			)			):
				if (i + 1 > len(SCREAMING_SNAKE_CASE__			) or old_parts[i] != new_part) and new_part:
						print(F'{md_prefix(SCREAMING_SNAKE_CASE__			)} {new_part.replace("_" ,       " "			).title()}'			)
		return new_path




def    _UpperCamelCase						(       SCREAMING_SNAKE_CASE__ = "."			)  ->							None:


		'''simple docstring'''


		snake_case  :       List[Any]     			=						''''''
		for filepath in sorted(good_file_paths(SCREAMING_SNAKE_CASE__			)			):
				snake_case			,snake_case  :       Optional[Any]     			=						os.path.split(SCREAMING_SNAKE_CASE__			)
				if filepath != old_path:
						snake_case  :       Dict     			=						print_path(SCREAMING_SNAKE_CASE__ ,       SCREAMING_SNAKE_CASE__			)
				snake_case  :       int     			=						(filepath.count(os.sep			) + 1) if filepath else 0
				snake_case  :       int     			=						F'{filepath}/{filename}'.replace(''' ''' ,       '''%20'''			)
				snake_case  :       int     			=						os.path.splitext(filename.replace('''_''' ,       ''' '''			).title()			)[0]
				print(F'{md_prefix(SCREAMING_SNAKE_CASE__			)} [{filename}]({url})'			)


if __name__ == "__main__":
						print_directory_md(".")


