






'''simple docstring'''







from __future__ import annotations

import unittest
from collections.abc import Iterator






class 					a__    :
     '''simple docstring'''







     def __init__(self    :	Union[str, Any]				,				lowercase__    :	int				,				lowercase__    :	Node | None					)  ->       Optional[int]:
           __A		   =      label
           __A		   =      parent
           __A		   =      None
           __A		   =      None







class 					a__    :
     '''simple docstring'''







     def __init__(self    :	Dict					)  ->       str:
           __A		   =      None






     def     _UpperCamelCase   (self    :	str					)  ->       int:
           __A		   =      None






     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       List[str]:
           return self.root is None






     def     _UpperCamelCase   (self    :	Optional[Any]				,				lowercase__    :	int					)  ->       Union[str, Any]:
           __A		   =      self._put(self.root				,				lowercase__					)






     def     _UpperCamelCase   (self    :	Optional[Any]				,				lowercase__    :	Node | None				,				lowercase__    :	int				,				lowercase__    :	Node | None = None					)  ->       Union[str, Any]:







           if node is None:
                 __A		   =      Node(lowercase__				,				lowercase__					)
           else:
                 if label < node.label:
                       __A		   =      self._put(node.left				,				lowercase__				,				lowercase__					)
                 elif label > node.label:
                       __A		   =      self._put(node.right				,				lowercase__				,				lowercase__					)
                 else:
                       __A		   =      f"Node with label {label} already exists"
                       raise Exception(lowercase__					)

           return node






     def     _UpperCamelCase   (self    :	Tuple				,				lowercase__    :	int					)  ->       Optional[int]:
           return self._search(self.root				,				lowercase__					)






     def     _UpperCamelCase   (self    :	List[str]				,				lowercase__    :	Node | None				,				lowercase__    :	int					)  ->       Dict:







           if node is None:
                 __A		   =      f"Node with label {label} does not exist"
                 raise Exception(lowercase__					)
           else:
                 if label < node.label:
                       __A		   =      self._search(node.left				,				lowercase__					)
                 elif label > node.label:
                       __A		   =      self._search(node.right				,				lowercase__					)

           return node






     def     _UpperCamelCase   (self    :	Any				,				lowercase__    :	int					)  ->       Optional[int]:
           __A		   =      self.search(lowercase__					)
           if node.right and node.left:
                 __A		   =      self._get_lowest_node(node.right					)
                 __A		   =      node.left
                 __A		   =      node.right
                 __A		   =      lowest_node
                 if node.right:
                       __A		   =      lowest_node
                 self._reassign_nodes(lowercase__				,				lowercase__					)
           elif not node.right and node.left:
                 self._reassign_nodes(lowercase__				,				node.left					)
           elif node.right and not node.left:
                 self._reassign_nodes(lowercase__				,				node.right					)
           else:
                 self._reassign_nodes(lowercase__				,				lowercase__					)






     def     _UpperCamelCase   (self    :	Tuple				,				lowercase__    :	Node				,				lowercase__    :	Node | None					)  ->       str:







           if new_children:
                 __A		   =      node.parent

           if node.parent:
                 if node.parent.right == node:
                       __A		   =      new_children
                 else:
                       __A		   =      new_children
           else:
                 __A		   =      new_children






     def     _UpperCamelCase   (self    :	int				,				lowercase__    :	Node					)  ->       Optional[Any]:







           if node.left:
                 __A		   =      self._get_lowest_node(node.left					)
           else:
                 __A		   =      node
                 self._reassign_nodes(lowercase__				,				node.right					)

           return lowest_node






     def     _UpperCamelCase   (self    :	int				,				lowercase__    :	int					)  ->       str:







           try:
                 self.search(lowercase__					)
                 return True
           except Exception:
                 return False






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







           if self.root is None:
                 raise Exception("Binary search tree is empty"					)

           __A		   =      self.root
           while node.right is not None:
                 __A		   =      node.right

           return node.label






     def     _UpperCamelCase   (self    :	Union[str, Any]					)  ->       Tuple:







           if self.root is None:
                 raise Exception("Binary search tree is empty"					)

           __A		   =      self.root
           while node.left is not None:
                 __A		   =      node.left

           return node.label






     def     _UpperCamelCase   (self    :	List[Any]					)  ->       List[str]:
           return self._inorder_traversal(self.root					)






     def     _UpperCamelCase   (self    :	str				,				lowercase__    :	Node | None					)  ->       Tuple:







           if node is not None:
                 yield from self._inorder_traversal(node.left					)
                 yield node
                 yield from self._inorder_traversal(node.right					)






     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       Tuple:
           return self._preorder_traversal(self.root					)






     def     _UpperCamelCase   (self    :	Any				,				lowercase__    :	Node | None					)  ->       Optional[Any]:







           if node is not None:
                 yield node
                 yield from self._preorder_traversal(node.left					)
                 yield from self._preorder_traversal(node.right					)







class 					a__    (			unittest.TestCase						):
     '''simple docstring'''







     @staticmethod
     def     _UpperCamelCase   ()  ->       Dict:
           __A		   =      BinarySearchTree()
           t.put(8					)
           t.put(3					)
           t.put(6					)
           t.put(1					)
           t.put(10					)
           t.put(14					)
           t.put(13					)
           t.put(4					)
           t.put(7					)
           t.put(5					)

           return t






     def     _UpperCamelCase   (self    :	Dict					)  ->       Optional[int]:
           __A		   =      BinarySearchTree()
           assert t.is_empty()

           t.put(8					)
           assert t.root is not None
           assert t.root.parent is None
           assert t.root.label == 8

           t.put(10					)
           assert t.root.right is not None
           assert t.root.right.parent == t.root
           assert t.root.right.label == 10

           t.put(3					)
           assert t.root.left is not None
           assert t.root.left.parent == t.root
           assert t.root.left.label == 3

           t.put(6					)
           assert t.root.left.right is not None
           assert t.root.left.right.parent == t.root.left
           assert t.root.left.right.label == 6

           t.put(1					)
           assert t.root.left.left is not None
           assert t.root.left.left.parent == t.root.left
           assert t.root.left.left.label == 1

           with self.assertRaises(lowercase__					):  # noqa: B017
                 t.put(1					)






     def     _UpperCamelCase   (self    :	Tuple					)  ->       Any:
           __A		   =      self._get_binary_search_tree()

           __A		   =      t.search(6					)
           assert node.label == 6

           __A		   =      t.search(13					)
           assert node.label == 13

           with self.assertRaises(lowercase__					):  # noqa: B017
                 t.search(2					)






     def     _UpperCamelCase   (self    :	Any					)  ->       List[Any]:
           __A		   =      self._get_binary_search_tree()

           t.remove(13					)
           assert t.root is not None
           assert t.root.right is not None
           assert t.root.right.right is not None
           assert t.root.right.right.right is None
           assert t.root.right.right.left is None

           t.remove(7					)
           assert t.root.left is not None
           assert t.root.left.right is not None
           assert t.root.left.right.left is not None
           assert t.root.left.right.right is None
           assert t.root.left.right.left.label == 4

           t.remove(6					)
           assert t.root.left.left is not None
           assert t.root.left.right.right is not None
           assert t.root.left.left.label == 1
           assert t.root.left.right.label == 4
           assert t.root.left.right.right.label == 5
           assert t.root.left.right.left is None
           assert t.root.left.left.parent == t.root.left
           assert t.root.left.right.parent == t.root.left

           t.remove(3					)
           assert t.root is not None
           assert t.root.left.label == 4
           assert t.root.left.right.label == 5
           assert t.root.left.left.label == 1
           assert t.root.left.parent == t.root
           assert t.root.left.left.parent == t.root.left
           assert t.root.left.right.parent == t.root.left

           t.remove(4					)
           assert t.root.left is not None
           assert t.root.left.left is not None
           assert t.root.left.label == 5
           assert t.root.left.right is None
           assert t.root.left.left.label == 1
           assert t.root.left.parent == t.root
           assert t.root.left.left.parent == t.root.left






     def     _UpperCamelCase   (self    :	int					)  ->       Any:
           __A		   =      self._get_binary_search_tree()

           t.remove(3					)
           assert t.root is not None
           assert t.root.left is not None
           assert t.root.left.left is not None
           assert t.root.left.right is not None
           assert t.root.left.right.left is not None
           assert t.root.left.right.right is not None
           assert t.root.left.label == 4
           assert t.root.left.right.label == 6
           assert t.root.left.left.label == 1
           assert t.root.left.right.right.label == 7
           assert t.root.left.right.left.label == 5
           assert t.root.left.parent == t.root
           assert t.root.left.right.parent == t.root.left
           assert t.root.left.left.parent == t.root.left
           assert t.root.left.right.left.parent == t.root.left.right






     def     _UpperCamelCase   (self    :	int					)  ->       int:
           __A		   =      self._get_binary_search_tree()
           t.empty()
           assert t.root is None






     def     _UpperCamelCase   (self    :	str					)  ->       Optional[int]:
           __A		   =      self._get_binary_search_tree()
           assert not t.is_empty()

           t.empty()
           assert t.is_empty()






     def     _UpperCamelCase   (self    :	Any					)  ->       Dict:
           __A		   =      self._get_binary_search_tree()

           assert t.exists(6					)
           assert not t.exists(-1					)






     def     _UpperCamelCase   (self    :	List[str]					)  ->       List[str]:
           __A		   =      self._get_binary_search_tree()

           assert t.get_max_label() == 14

           t.empty()
           with self.assertRaises(lowercase__					):  # noqa: B017
                 t.get_max_label()






     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       List[str]:
           __A		   =      self._get_binary_search_tree()

           assert t.get_min_label() == 1

           t.empty()
           with self.assertRaises(lowercase__					):  # noqa: B017
                 t.get_min_label()






     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       List[str]:
           __A		   =      self._get_binary_search_tree()

           __A		   =      [i.label for i in t.inorder_traversal()]
           assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 10, 13, 14]






     def     _UpperCamelCase   (self    :	List[Any]					)  ->       str:
           __A		   =      self._get_binary_search_tree()

           __A		   =      [i.label for i in t.preorder_traversal()]
           assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 10, 14, 13]







def 						_UpperCamelCase							(     ):
      __A		   =      BinarySearchTree()
      t.put(8							)
      t.put(3							)
      t.put(6							)
      t.put(1							)
      t.put(10							)
      t.put(14							)
      t.put(13							)
      t.put(4							)
      t.put(7							)
      t.put(5							)

      print(
          "\n            8\n           / \\\n          3   10\n         / \\    \\\n        1   6    14\n           / \\   /\n          4   7 13\n           \\\n            5\n        "							)

      print("Label 6 exists:"							,			t.exists(6							)							)
      print("Label 13 exists:"							,			t.exists(13							)							)
      print("Label -1 exists:"							,			t.exists(-1							)							)
      print("Label 12 exists:"							,			t.exists(12							)							)

      # Prints all the elements of the list in inorder traversal
      __A		   =      [i.label for i in t.inorder_traversal()]
      print("Inorder traversal:"							,			snake_case__							)

      # Prints all the elements of the list in preorder traversal
      __A		   =      [i.label for i in t.preorder_traversal()]
      print("Preorder traversal:"							,			snake_case__							)

      print("Max. label:"							,			t.get_max_label()							)
      print("Min. label:"							,			t.get_min_label()							)

      # Delete elements
      print("\nDeleting elements 13, 10, 8, 3, 6, 14"							)
      print(
          "\n          4\n         / \\\n        1   7\n             \\\n              5\n        "							)
      t.remove(13							)
      t.remove(10							)
      t.remove(8							)
      t.remove(3							)
      t.remove(6							)
      t.remove(14							)

      # Prints all the elements of the list in inorder traversal after delete
      __A		   =      [i.label for i in t.inorder_traversal()]
      print("Inorder traversal after delete:"							,			snake_case__							)

      # Prints all the elements of the list in preorder traversal after delete
      __A		   =      [i.label for i in t.preorder_traversal()]
      print("Preorder traversal after delete:"							,			snake_case__							)

      print("Max. label:"							,			t.get_max_label()							)
      print("Min. label:"							,			t.get_min_label()							)


if __name__ == "__main__":
      binary_search_tree_example()










'''simple docstring'''







from cva import destroyAllWindows, imread, imshow, waitKey


def 						_UpperCamelCase							(     snake_case__							,			snake_case__							):
      __A   ,				__A		   =      img.shape[0], img.shape[1]

      def to_grayscale(snake_case__							,			snake_case__							,			snake_case__							):
            return 0.2126 * red + 0.587 * green + 0.114 * blue

      def normalize(snake_case__							):
            return min(snake_case__							,			255							)

      for i in range(snake_case__							):
            for j in range(snake_case__							):
                  __A		   =      int(to_grayscale(*img[i][j]							)							)
                  __A		   =      [
                      normalize(snake_case__							),
                      normalize(greyscale + factor							),
                      normalize(greyscale + 2 * factor							),
                  ]

      return img


if __name__ == "__main__":
       # read original image
       __A      :       Dict      =	{
           percentage: imread('image_data/lena.jpg', 1) for percentage in (1_0, 2_0, 3_0, 4_0)
       }

       for percentage, img in images.items():
              make_sepia(img, percentage)

       for percentage, img in images.items():
              imshow(F"""Original image with sepia (factor: {percentage})""", img)

       waitKey(0)
       destroyAllWindows()


