




from __future__ import annotations

from math import pi, pow




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						float:

    """simple docstring"""


    if side_length < 0:
        raise ValueError('''vol_cube() only accepts non-negative values'''   )
    return pow(lowercase_       ,  3   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if height < 0 or radius < 0:
        raise ValueError('''vol_spherical_cap() only accepts non-negative values'''   )
    # Volume is 1/3 pi * height squared * (3 * radius - height)
    return 1 / 3 * pi * pow(lowercase_       ,  2   ) * (3 * radius - height)




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if radius_a < 0 or radius_a < 0 or centers_distance < 0:
        raise ValueError('''vol_spheres_intersect() only accepts non-negative values'''   )
    if centers_distance == 0:
        return vol_sphere(min(lowercase_       ,  lowercase_   )   )

    __UpperCamelCase			=    (
        (radius_a - radius_a + centers_distance)
        * (radius_a + radius_a - centers_distance)
        / (2 * centers_distance)
    )
    __UpperCamelCase			=    (
        (radius_a - radius_a + centers_distance)
        * (radius_a + radius_a - centers_distance)
        / (2 * centers_distance)
    )

    return vol_spherical_cap(lowercase_       ,  lowercase_   ) + vol_spherical_cap(lowercase_       ,  lowercase_   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
        raise ValueError(
            '''vol_spheres_union() only accepts non-negative values, non-zero radius'''   )

    if centers_distance == 0:
        return vol_sphere(max(lowercase_       ,  lowercase_   )   )

    return (
        vol_sphere(lowercase_   )
        + vol_sphere(lowercase_   )
        - vol_spheres_intersect(lowercase_       ,  lowercase_       ,  lowercase_   )
    )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if width < 0 or height < 0 or length < 0:
        raise ValueError('''vol_cuboid() only accepts non-negative values'''   )
    return float(width * height * length   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if height < 0 or area_of_base < 0:
        raise ValueError('''vol_cone() only accepts non-negative values'''   )
    return area_of_base * height / 3.0




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if height < 0 or radius < 0:
        raise ValueError('''vol_right_circ_cone() only accepts non-negative values'''   )
    return pi * pow(lowercase_       ,  2   ) * height / 3.0




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if height < 0 or area_of_base < 0:
        raise ValueError('''vol_prism() only accepts non-negative values'''   )
    return float(area_of_base * height   )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if height < 0 or area_of_base < 0:
        raise ValueError('''vol_pyramid() only accepts non-negative values'''   )
    return area_of_base * height / 3.0




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						float:

    """simple docstring"""


    if radius < 0:
        raise ValueError('''vol_sphere() only accepts non-negative values'''   )
    # Volume is 4/3 * pi * radius cubed
    return 4 / 3 * pi * pow(lowercase_       ,  3   )




def        __SCREAMING_SNAKE_CASE (	lowercase_   )							->						float:

    """simple docstring"""


    if radius < 0:
        raise ValueError('''vol_hemisphere() only accepts non-negative values'''   )
    # Volume is radius cubed * pi * 2/3
    return pow(lowercase_       ,  3   ) * pi * 2 / 3




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if height < 0 or radius < 0:
        raise ValueError('''vol_circular_cylinder() only accepts non-negative values'''   )
    # Volume is radius squared * height * pi
    return pow(lowercase_       ,  2   ) * height * pi




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if inner_radius < 0 or outer_radius < 0 or height < 0:
        raise ValueError(
            '''vol_hollow_circular_cylinder() only accepts non-negative values'''   )
    if outer_radius <= inner_radius:
        raise ValueError('''outer_radius must be greater than inner_radius'''   )
    return pi * (pow(lowercase_       ,  2   ) - pow(lowercase_       ,  2   )) * height




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if radius_a < 0 or radius_a < 0 or height < 0:
        raise ValueError('''vol_conical_frustum() only accepts non-negative values'''   )
    return (
        1
        / 3
        * pi
        * height
        * (pow(lowercase_       ,  2   ) + pow(lowercase_       ,  2   ) + radius_a * radius_a)
    )




def        __SCREAMING_SNAKE_CASE (	lowercase_       ,  lowercase_   )							->						float:

    """simple docstring"""


    if torus_radius < 0 or tube_radius < 0:
        raise ValueError('''vol_torus() only accepts non-negative values'''   )
    return 2 * pow(lowercase_       ,  2   ) * torus_radius * pow(lowercase_       ,  2   )




def        __SCREAMING_SNAKE_CASE (	)							->						Optional[Any]:

    """simple docstring"""


    print('''Volumes:'''   )
    print(F"Cube: {vol_cube(2   ) = }"   )  # = 8
    print(F"Cuboid: {vol_cuboid(2       ,  2       ,  2   ) = }"   )  # = 8
    print(F"Cone: {vol_cone(2       ,  2   ) = }"   )  # ~= 1.33
    print(F"Right Circular Cone: {vol_right_circ_cone(2       ,  2   ) = }"   )  # ~= 8.38
    print(F"Prism: {vol_prism(2       ,  2   ) = }"   )  # = 4
    print(F"Pyramid: {vol_pyramid(2       ,  2   ) = }"   )  # ~= 1.33
    print(F"Sphere: {vol_sphere(2   ) = }"   )  # ~= 33.5
    print(F"Hemisphere: {vol_hemisphere(2   ) = }"   )  # ~= 16.75
    print(F"Circular Cylinder: {vol_circular_cylinder(2       ,  2   ) = }"   )  # ~= 25.1
    print(F"Torus: {vol_torus(2       ,  2   ) = }"   )  # ~= 157.9
    print(F"Conical Frustum: {vol_conical_frustum(2       ,  2       ,  4   ) = }"   )  # ~= 58.6
    print(F"Spherical cap: {vol_spherical_cap(1       ,  2   ) = }"   )  # ~= 5.24
    print(F"Spheres intersetion: {vol_spheres_intersect(2       ,  2       ,  1   ) = }"   )  # ~= 21.21
    print(F"Spheres union: {vol_spheres_union(2       ,  2       ,  1   ) = }"   )  # ~= 45.81
    print(
        F"Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1       ,  2       ,  3   ) = }"   )  # ~= 28.3


if __name__ == "__main__":
 main()










'''simple docstring'''




import requests

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





def 				a_							(    lowercase     )      ->Any:






				'''simple docstring'''

				__lowerCamelCase		:   str           =       "secretKey"
				__lowerCamelCase		:   Optional[Any]           =       "https://www.google.com/recaptcha/api/siteverify"

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

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

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





