

"""simple docstring"""
from __future__ import annotations

import unittest
from collections.abc import Iterator

class 			lowerCamelCase  :


  '''simple docstring'''







  def __init__(self       ,					_lowerCamelCase       ,					_lowerCamelCase  ):


        """simple docstring"""

        UpperCAmelCase__ :       List[Any]						=						label
        UpperCAmelCase__ :       Any						=						parent
        UpperCAmelCase__ :       Node | None						=						None
        UpperCAmelCase__ :       Node | None						=						None




class 			lowerCamelCase  :


  '''simple docstring'''







  def __init__(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       Node | None						=						None



  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       str						=						None



  def    _a			(self  ):


        """simple docstring"""

        return self.root is None



  def    _a			(self       ,					_lowerCamelCase  ):


        """simple docstring"""

        UpperCAmelCase__ :       int						=						self._put(self.root       ,					_lowerCamelCase  )



  def    _a			(self       ,					_lowerCamelCase       ,					_lowerCamelCase       ,					_lowerCamelCase = None  ):


        """simple docstring"""

        if node is None:
              UpperCAmelCase__ :       Any						=						Node(_lowerCamelCase       ,					_lowerCamelCase  )
        else:
              if label < node.label:
                    UpperCAmelCase__ :       Dict						=						self._put(node.left       ,					_lowerCamelCase       ,					_lowerCamelCase  )
              elif label > node.label:
                    UpperCAmelCase__ :       Union[str, Any]						=						self._put(node.right       ,					_lowerCamelCase       ,					_lowerCamelCase  )
              else:
                    UpperCAmelCase__ :       Optional[Any]						=						F"""Node with label {label} already exists"""
                    raise Exception(_lowerCamelCase  )

        return node



  def    _a			(self       ,					_lowerCamelCase  ):


        """simple docstring"""

        return self._search(self.root       ,					_lowerCamelCase  )



  def    _a			(self       ,					_lowerCamelCase       ,					_lowerCamelCase  ):


        """simple docstring"""

        if node is None:
              UpperCAmelCase__ :       Union[str, Any]						=						F"""Node with label {label} does not exist"""
              raise Exception(_lowerCamelCase  )
        else:
              if label < node.label:
                    UpperCAmelCase__ :       Dict						=						self._search(node.left       ,					_lowerCamelCase  )
              elif label > node.label:
                    UpperCAmelCase__ :       Dict						=						self._search(node.right       ,					_lowerCamelCase  )

        return node



  def    _a			(self       ,					_lowerCamelCase  ):


        """simple docstring"""

        UpperCAmelCase__ :       Dict						=						self.search(_lowerCamelCase  )
        if node.right and node.left:
              UpperCAmelCase__ :       List[Any]						=						self._get_lowest_node(node.right  )
              UpperCAmelCase__ :       List[Any]						=						node.left
              UpperCAmelCase__ :       int						=						node.right
              UpperCAmelCase__ :       Optional[Any]						=						lowest_node
              if node.right:
                    UpperCAmelCase__ :       str						=						lowest_node
              self._reassign_nodes(_lowerCamelCase       ,					_lowerCamelCase  )
        elif not node.right and node.left:
              self._reassign_nodes(_lowerCamelCase       ,					node.left  )
        elif node.right and not node.left:
              self._reassign_nodes(_lowerCamelCase       ,					node.right  )
        else:
              self._reassign_nodes(_lowerCamelCase       ,					_lowerCamelCase  )



  def    _a			(self       ,					_lowerCamelCase       ,					_lowerCamelCase  ):


        """simple docstring"""

        if new_children:
              UpperCAmelCase__ :       Tuple						=						node.parent

        if node.parent:
              if node.parent.right == node:
                    UpperCAmelCase__ :       Union[str, Any]						=						new_children
              else:
                    UpperCAmelCase__ :       Tuple						=						new_children
        else:
              UpperCAmelCase__ :       Any						=						new_children



  def    _a			(self       ,					_lowerCamelCase  ):


        """simple docstring"""

        if node.left:
              UpperCAmelCase__ :       Union[str, Any]						=						self._get_lowest_node(node.left  )
        else:
              UpperCAmelCase__ :       Dict						=						node
              self._reassign_nodes(_lowerCamelCase       ,					node.right  )

        return lowest_node



  def    _a			(self       ,					_lowerCamelCase  ):


        """simple docstring"""

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



  def    _a			(self  ):


        """simple docstring"""

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

        UpperCAmelCase__ :       Dict						=						self.root
        while node.right is not None:
              UpperCAmelCase__ :       Any						=						node.right

        return node.label



  def    _a			(self  ):


        """simple docstring"""

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

        UpperCAmelCase__ :       Optional[Any]						=						self.root
        while node.left is not None:
              UpperCAmelCase__ :       List[str]						=						node.left

        return node.label



  def    _a			(self  ):


        """simple docstring"""

        return self._inorder_traversal(self.root  )



  def    _a			(self       ,					_lowerCamelCase  ):


        """simple docstring"""

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



  def    _a			(self  ):


        """simple docstring"""

        return self._preorder_traversal(self.root  )




  def    _a			(self       ,					_lowerCamelCase  ):


        """simple docstring"""

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




class 			lowerCamelCase  (					unittest.TestCase      ):


  '''simple docstring'''







  @staticmethod
  def    _a			():


        """simple docstring"""

        UpperCAmelCase__ :       Any						=						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    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       List[Any]						=						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(_lowerCamelCase  ):  # noqa: B017
              t.put(1  )



  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       Optional[int]						=						self._get_binary_search_tree()

        UpperCAmelCase__ :       str						=						t.search(6  )
        assert node.label == 6

        UpperCAmelCase__ :       Any						=						t.search(13  )
        assert node.label == 13

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



  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       int						=						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    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       Any						=						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    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       int						=						self._get_binary_search_tree()
        t.empty()
        assert t.root is None



  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       str						=						self._get_binary_search_tree()
        assert not t.is_empty()

        t.empty()
        assert t.is_empty()



  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       Any						=						self._get_binary_search_tree()

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



  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       Optional[int]						=						self._get_binary_search_tree()

        assert t.get_max_label() == 14

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



  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       int						=						self._get_binary_search_tree()

        assert t.get_min_label() == 1

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



  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       Union[str, Any]						=						self._get_binary_search_tree()

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




  def    _a			(self  ):


        """simple docstring"""

        UpperCAmelCase__ :       Tuple						=						self._get_binary_search_tree()

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




def 				a__	(	)  ->   None:
      UpperCAmelCase__ :       Optional[int]						=						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(
          """
            8
           / \\
          3   10
         / \\    \\
        1   6    14
           / \\   /
          4   7 13
           \\
            5
        """						)

      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
      UpperCAmelCase__ :       Optional[Any]						=						[i.label for i in t.inorder_traversal()]
      print("""Inorder traversal:""" ,  lowerCAmelCase						)

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

      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(
          """
          4
         / \\
        1   7
             \\
              5
        """						)
      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
      UpperCAmelCase__ :       Dict						=						[i.label for i in t.inorder_traversal()]
      print("""Inorder traversal after delete:""" ,  lowerCAmelCase						)

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

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


if __name__ == "__main__":
    binary_search_tree_example()




"""simple docstring"""
import requests

try:
    from django.contrib.auth import authenticate, login
    from django.shortcuts import redirect, render
except ImportError:
    _A						=     _A						=     _A						=     _A						=     print




def 				a__	(	lowerCAmelCase						)  ->   str:
      # Enter your recaptcha secret key here
      UpperCAmelCase__ :       int						=						"""secretKey"""
      UpperCAmelCase__ :       Any						=						"""https://www.google.com/recaptcha/api/siteverify"""

      # when method is not POST, direct user to login page
      if request.method != "POST":
            return render(lowerCAmelCase ,  """login.html"""						)

      # from the frontend, get username, password, and client_key
      UpperCAmelCase__ :       List[Any]						=						request.POST.get("""username"""						)
      UpperCAmelCase__ :       Optional[Any]						=						request.POST.get("""password"""						)
      UpperCAmelCase__ :       List[str]						=						request.POST.get("""g-recaptcha-response"""						)

      # post recaptcha response to Google's recaptcha api
      UpperCAmelCase__ :       Any						=						requests.post(lowerCAmelCase ,  data={"""secret""": secret_key, """response""": client_key}						)
      # if the recaptcha api verified our keys
      if response.json().get("""success""" ,  lowerCAmelCase						):
            # authenticate the user
            UpperCAmelCase__ :       List[str]						=						authenticate(lowerCAmelCase ,  username=lowerCAmelCase ,  password=lowerCAmelCase						)
            if user_in_database:
                  login(lowerCAmelCase ,  lowerCAmelCase						)
                  return redirect("""/your-webpage"""						)
      return render(lowerCAmelCase ,  """login.html"""						)

