Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de Flask

Curso de Flask

Bernardo Cassina

Bernardo Cassina

Configurar páginas de error

14/36
Recursos

Códigos de error:

100: no son errores sino mensajes informativos. Como usuario nunca los verás, sino que entre bambalinas indica que la petición se ha recibido y se continúa el proceso.

200: estos códigos también indican que todo ha ido correctamente. La petición se ha recibido, se ha procesado y se ha devuelto satisfactoriamente. Por tanto, nunca los verás en tu navegador, pues significan que todo ha ido bien.

300: están relacionados con redirecciones. Los servidores usan estos códigos para indicar al navegador que la página o recurso que han pedido se ha movido de sitio. Como usuario, no verás estos códigos, aunque gracias a ellos una página te podría redirigir automáticamente a otra.

400: corresponden a errores del cliente y con frecuencia sí los verás. Es el caso del conocido error 404, que aparece cuando la página que has intentado buscar no existe. Es, por tanto, un error del cliente (la dirección web estaba mal).

500: mientras que los códigos de estado 400 implican errores por parte del cliente (es decir, de parte tuya, tu navegador o tu conexión), los errores 500 son errores desde la parte del servidor. Es posible que el servidor tenga algún problema temporal y no hay mucho que puedas hacer salvo probar de nuevo más tarde.

Aportes 74

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

El código en Python lo haría algo así:

@app.errorhandler(500)
def internal_server_error(error):
  return render_template('500.html')

Y el HTML me quedaría algo así:

{% extends 'base.html' %}

{% block title %}
{{ super() }}
Internal Server Error
{% endblock %}

{% block content %}
<h1>Lo sentimos</h1>
<p>Ocurrió un error, estamos trabajando en ello</p>
{% endblock %}

Hola, como puedo “provocar” un error 500?

Y este decorador puede recibir no solo el número de un error, sino propiamente un error (pudiendo así definir nuestros propios errores) o también podríamos crear una función que maneje cualquier tipo de error de esta manera:

@app.errorhandler(Exception)
def error_handler(e):
	return 'Error!!!'
@app.errorhandler(500)
def internal_server_error(error):
    return render_template('500.html', error=error)

#Html
{% extends 'base.html' %}
{%  import 'macros.html' as macros %}
{% block title %}{{ super() }}Error Interno 500{% endblock %}

{% block content %}
<img id='sheldon' src="https://k30.kn3.net/5CE944069.jpg" >
<h1 id='er5'>Lo sentimos :( Tenemos un error Interno</h1>
<h2>Estamos trabajando para solucionarlo</h2>      
<h3>{{ error }}</h3>
   
{% endblock %}

Hola si quieren provocar un error de tipo Internal Error Server 500, sólo tienes que desactivar el debuger cambiando el valor de la variable FLASK_DEBUG de 1 a 0, una vez hecho esto no corras aun el servidor, provoca un error de código en cualquier parte del código es decir no termines un bloque de código, ejemplo:

 {% for todo in to_do %}
            {{macros.render_todo(todo)}}
        {% en %}

Esto provocara un error interno de tipo 500.
Ahora si puedes encender el servidor con el comando flask run
Aqui les dejo un link en donde se explica que es este error. Error 500

En el archivo main.py

@app.errorhandler(500)
def not_found(error):
    return render_template('500.html',error=error)

Así intercepto el Error 500:

@app.errorhandler(500)
def internal_error(error):
   return "Error 500 {}".format(error)

Así emulo un error 500

@app.route('/error')
def error_server():
	return 1 / 0

En consola retiro el modo debug y vuelvo a correr el servidor:

export FLASK_DEBUG=0
flask run

Hola como puedo comprobar el error 500?

Uno de los principios de python es DRY (Don’t repeat yourself), así que decidí hacer un solo template para los errores, pues iban a ser templates con código repetido y quedo así:

  • error.html
{% extends 'base.html' %}
{% block title %}
    {{ super()}}
    {{status}}
{% endblock %}

{% block content %}
    <h1>{{ texto }}</h1>
    <p>{{ error }}</p>
{% endblock %}

Y las funciones desde las funciones de errores le paso el contexto haciendo uso de Dictionary Unpacking para no tener que escribir más código en las templates.

Python
Error Handlers

@app.errorhandler(404)
def not_found(error):
    context = {
        'error':error,
        'texto':"Lo sentimos no encontramos lo que buscas",
        'status':404
    }
    return render_template('error.html', **context)

@app.errorhandler(500)
def server_error(error):
    context = {
        'error':error,
        'texto':"Algo salio mal",
        'status':500
    }
    return render_template('error.html', **context)

Y para simular el error 500 use el metodo abort de flask.

from flask import Flask, request, make_response, redirect, render_template, abort

app = Flask(__name__)

@app.route('/error')
def error_500():
    abort(500)

La verdad es que preferí ir un poquitito más allá y hacer esto en el HTML, tomé un concepto de Amazon de poner perritos cuando algo pasa y lo hice así:

<!DOCTYPE html> 
<html lang "en">
<head>
    <meta charset = "UTFF-8">
    <title>
    {% block title %}Learning Flask | {% endblock %}
    </title>
    <link rel = "stylesheet" href = "{{url_for('static', filename = 'css/main.css')}}">
</head>
<body>
    {% block content%}
    <img src = "{{url_for('static', filename='images/500e.png')}}" alt = "doggie">
    <h1> Oh hotcakes, this was a mistake from our side, we're working on it</h1>
    <p>{{ error }}</p>
    {% endblock %}
</body>
</html>

Notarán que no utilicé el template base.html porque no me gustó que siguiera mostrando los links ni las imágenes que ya tenía. Así que aquí les dejo mi html del 500

@app.errorhandler(500)
def not_found_500(error):
""“
Se debe provocar un error en el codigo y tener el modo debug=False
”""
return render_template(‘500.html’, error=error)

@app.errorhandler(500)
def errorServer(error):
return render_template(‘500.html’)

Mi código en python:

@app.errorhandler(500)
def internal_error(error):
    return render_template('500.html', error=error)

El código de HTML:

{% extends 'base.html' %}
{% import 'macros.html' as macros %}

{% block title %}
    {{ super() }}
    internal error 500
{% endblock %}

{% block content %}

    <h1>Lo sentimos hay problemas en la conexion</h1>
    <h2>500</h2>

{% endblock %}

si salió el 404

Python

@app.errorhandler(404)
def not_found(error):
    return render_template('404.html', error=error) 

HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="{{ url_for('static', filename='css/glitch.css') }}">
    <title>Bienvenido | 404</title>
</head>
<body>
    <div title="404">404</div>    
</body>
</html>

CSS

@import url('https://fonts.googleapis.com/css?family=Fira+Mono:400');

body{ 
  display: flex;
  width: 100vw;
  height: 100vh;
  align-items: center;
  justify-content: center;
  margin: 0;
  background: #131313;
  color: #fff;
  font-size: 96px;
  font-family: 'Fira Mono', monospace;
  letter-spacing: -7px;
}

div{
  animation: glitch 1s linear infinite;
}

@keyframes glitch{
  2%,64%{
    transform: translate(2px,0) skew(0deg);
  }
  4%,60%{
    transform: translate(-2px,0) skew(0deg);
  }
  62%{
    transform: translate(0,0) skew(5deg); 
  }
}

div:before,
div:after{
  content: attr(title);
  position: absolute;
  left: 0;
}

div:before{
  animation: glitchTop 1s linear infinite;
  clip-path: polygon(0 0, 100% 0, 100% 33%, 0 33%);
  -webkit-clip-path: polygon(0 0, 100% 0, 100% 33%, 0 33%);
}

@keyframes glitchTop{
  2%,64%{
    transform: translate(2px,-2px);
  }
  4%,60%{
    transform: translate(-2px,2px);
  }
  62%{
    transform: translate(13px,-1px) skew(-13deg); 
  }
}

div:after{
  animation: glitchBotom 1.5s linear infinite;
  clip-path: polygon(0 67%, 100% 67%, 100% 100%, 0 100%);
  -webkit-clip-path: polygon(0 67%, 100% 67%, 100% 100%, 0 100%);
}

@keyframes glitchBotom{
  2%,64%{
    transform: translate(-2px,0);
  }
  4%,60%{
    transform: translate(-2px,0);
  }
  62%{
    transform: translate(-22px,5px) skew(21deg); 
  }
}
```![glitch404.png](https://static.platzi.com/media/user_upload/glitch404-1f88554c-dd29-45f7-b284-4397acdb9702.jpg)

Codigo de python:

@app.route('/internal-error')
def raise_internal_error():
    return 1 / 0


@app.errorhandler(500)
def internal_server_error(error):
    return render_template('500.html', error=error)

Codigo de 500.html

{% extends 'base.html' %}

{% block title %}
    {{ super() }}
    500
{% endblock %}

{% block content %}
    <h1>Lo sentimos! Parece que tenemos in error interno en el servidor</h1>
    <p>{{ error }}</p>
{% endblock %}

yo le puse gatetes ❤️
400

500

el código del main:

el archivo 500.html :

Me quedó bien:

@app.errorhandler(500)
def server(error):
    return render_template('500.html', error=error)

{% extends 'base.html' %}

{% block title %}
    {{ super() }}
    error 500
{% endblock %}

{% block content %}
    <h1>error de servidor</h1>
    <p>{{ error }}</p>
{% endblock%}
@app.errorhandler(500)
def internal_server_error(error):
    return render_template('500.html', error=error)
{% extends 'base.html' %}
{% block title %}
    {{ super() }}
    500
{% endblock %}

{% block content %}
    <h1>Internal Server Error</h1>
    <p>{{ error }}</p>
{% endblock %}

Reto

Para visualizar el error tube que desactivar el modo “DEBUG” e introducir un error en el endpoint de /hello.

Error introducido

@app.route('/hello')
def hello():
    user_ip = request.cookies.get('user_ip')

    context= {
        'user_ip': user_ip,
        'todos': TODOS,
    }
    return render_template('hello.html', **context, some=context['a']). # raises an error because key 'a' does not exists in the context.

Preview

500 html

{% extends 'base.html' %}

{% block title %}
  {{ super() }}
  Internal Server error
{% endblock %}

{% block content %}
  <h2>
    Internal server error
  </h2>

  <h1>
    500
  </h1>

  <p>
    {{ error }}
  </p>
{% endblock %}

main py

@app.errorhandler(500)
def internal_error(error):
    return make_response(render_template('500.html', error=error), 500)

No se me habia ocurrido que fuese tan facil

Basicamente hice un copy&paste del error 404. No me queda claro como probar si lo hice bien:

@app.errorhandler(500)
def error_interno(error):
    return render_template('500.html', error=error)
{% extends 'base.html' %}

{% block title %}
        {{ super() }}
        500
{% endblock %}

{% block content %}
        <h1> Error interno. Espere por favor. </h1>
        <p> {{ error }} </p>
{% endblock %}

El archivo 500.html lo crearía así:

{% extends 'base.html' %}
{% block title %}
{{ super() }}
    500
{% endblock %}

{% block content %}
    <h1>Lo sentimos, error del servidor, intenta de nuevo más tarde</h1>
    <p>{{ error }}</p>
{% endblock %}

Vamaaas! Resolví un bug!

Codigo Python:

@app.errorhandler(500)
def internal_server(error):
    return render_template('500.html', error=error)

HTML:

{% extends 'base.html' %}
{% block title %} 
    {{ super() }}
    500
{% endblock %}
{% block content %}
<h1>INTERNAL SERVER ERROR. </h1>
<p>{{error}}</p>
{% endblock %}

Mi solución:

Archivo python

@app.errorhandler(500)
def internal_server_error(error):
    return render_template('500.html',error=error)

500.html:

{% extends 'base.html' %}

{% block title %}
    {{ super() }}
    500
{% endblock %}

{% block content %}
    <h1>Algo ha ido mal en el servidor</h1>
    <p>{{ error }}</p>
{% endblock %}
@app.errorhandler(500)
def internal_error(error):
    return render_template('500.html', error=error)
{% extends 'base.html'%}
{% import 'macros.html' as macros %}

{% block title %} 
    {{super()}}
    Server error
{% endblock%}


{% block content%}
    <h1>Lo sentimos ocurrio un error</h1>
    <p>Por favor intenta en otro momento</p>
{% endblock %}
<code>
@app.errorhandler(500)
def internal_error(error):
    return render_template('500.html', error=error)

El reto me quedó así:



main.py

@app.errorhandler(500)
def server_error(error):
    return render_template('500.html',error=error)

500.html

{% extends 'base.html' %}

{% block title %} 
    {{ super() }}
    Server error
{% endblock %}

{% block header %}
    <h1>Error 500 : Internal Server Error</h1>
{% endblock %}

{% block content %}

    <h1>Sorry, we are already working on it.</h1>
    <p>{{ error }}</p>

{% endblock %}

Renderizar un HTML para los errores 5XX como los de Youtube

@app.errorhandler(500)
def server_error(error):
    return render_template('500.html', error=error)```

main.py

@app.errorhandler(500)
def error500(error):
return render_template(‘500.html’, error=error)

500.html

{% extends ‘base.html’ %}

{% block title %}
{{ super() }}
500
{% endblock %}

{% block content %}
<h1>Error de servidor, lo sentimos, comunicate con el administrador</h1>
{{ error }}
{% endblock %}

Logic

@app.errorhandler(500)
def internal_server_error(error):
    return render_template('500.html', error=error)

🎨Html

{% extends 'base.html' %}

{% block title %} {{super()}} Lo sentimos {% endblock %}

{% block content %}
  <h1>😢 Estamos trabajando para solucionar este error</h1>
  {{ error }}
{% endblock %}

El código quedaría así:

app.py

@app.errorhandler(500)
def not_found_500(error):
    return render_template('500.html', error=error)

500.html

{% extends 'base.html' %}
{% import 'macros.html' as macros %}

{% block title %}
    {{ super() }}
    500
{% endblock %}

{% block content %}
<h1>Lo sentimos hubo un problema con el servidor :(,<br>
    estamos trabajando para resolverlo.<br>
    Intenta en unos intantes.
</h1>
<p>{{ error }}</p>
{%endblock%}

Hola, mi solución:

@app.errorhandler(500)
def internal_server(error):
    return render_template('500.html', error=error)```

Template:

{% extends ‘base.html’ %}

{% block title %}
{{ super() }}
500
{% endblock %}

{% block content %}
<h2>Lo sentimos, creo que hay problemas con el servidor, intentalo de nuevo en 1 minutos.</h2>
<p>{{ error }}</p>
{% endblock %}```

Nota: Si el servidor fue levantado como Debugger no se controlara correctamente el error 500, para verificar que esta funcionando correctamente es necesario levantar el servidor sin Debugger(Production), para hacer eso, se puede ejecutar el siguiente comando, en el terminal:

export FLASK_DEBUG=1
flask run

Alguien sabe por qué no me funciona? Tengo el código tal cual lo hizo el profesor, pero no carga, sigue apareciendo la página con el Not Found

main.py

@app.errorhandler(500)
def server_error(error):
    return render_template('500.html', error=error)

500.html

{% extends 'base.html' %}
{% block title %}
    500
{% endblock title %}

{% block content %}
    <h1>Lo sentimos, ocurrió un error en el servidor, comunicate con el admin </h1>
    <p>{{error}}</p>
{% endblock content%}

"""
activar nuestro entorno con: source venv/bin/activate
SE CORRE EN EL ENTORNO VIRTUAL Y DEFINIMOS VARIABLES DE ENTORNO PARA QUE FUNCIONE 
export FLASK_APP=main.py
export FLASK_DEBUG=1
"""
from flask import Flask, request, make_response, redirect, render_template

app = Flask(__name__)

todos = ['TODO 1', 'TODO 2', 'TODO 3']

@app.errorhandler(404)
def not_found(error):
    return render_template('404.html', error=error)

@app.errorhandler(500)
def server_error(error):
    return render_template('500.html', error=error)


@app.route('/')
def index():
    user_ip = request.remote_addr

    response = make_response(redirect('/hello'))
    response.set_cookie('user_ip', user_ip)

    return response


@app.route('/hello')
def hello():
    user_ip = request.remote_addr
    context = {
        'user_ip': user_ip,
        'todos': todos
    }
    return render_template('hello.html', **context)

Hay que tener en cuenta que para poder hacer el reto deben, desactivar el modo debug

export FLASK_DEBUG=0

Render para el error 500

@app.errorhandler(500)
def internal_error():
    return render_template('errors/500.html')
@app.errorhandler(500)
def server_error(error):
    return render_template('errors/500.html', error=error)

Para arrojar un error pueden importar el modulo abort de flask
abort recibe como parametro el numero de error error a lanzar

from flask import Flask, redirect, render_template, abort

@app.errorhandler(500)
def error_server(error):
    return render_template('./errors/500.html', error=error)

@app.route('/debug-errors/500')
def error_500():
	abort(500)
{% extends 'base.html' %}

{% block title %}
	{{ super() }}
	Error Server
{% endblock title %}

{% block content %}
	<h1>Ha ocurrido un problema con el servidor intentelo mas tarde</h1>
	<p>{{ error }}</p>
{% endblock content %}

Error 400 :

500.html

{% extends ‘base.html’ %}

{% block title %}
{{ super() }}
500
{% endblock %}

{% block content%}
<h1>a ocurrido un problema con el server intentalo nuevamente</h1>
<p> {{ error }}</p>
{% endblock %}

main.py
@app.errorhandler(500)
def error_server(error):
return render_template(‘500.html’, error = error)

main.py

500.html

Template (500.html):

main.py:

Así quedó la página de error, para activarla desactivé el modo debug y metí un error de sintaxis

El main.py:

@app.errorhandler(500)
def not_found(error):
    return render_template('500.html', error=error)

Y el 500.html:

{% extends 'base.html' %}

{% block title %}
{{ super() }}
    500
{% endblock %}

{% block content %}
    <h1>Lo sentimos, ourrio un error</h1>
    <p>{{ error }}</p>
{% endblock%}
{% extends 'base.html' %}

{% block title %} 
    {{ super() }}
500
{% endblock %}


{% block content%}
    <h1>Lo sentimos Nuestros Servidores en estos momentos estan teniendo Mantenimiento</h1>
        <h2> Intentalo nuevamenta mas tarde</h2>
{% endblock %}

Reto cumplido!

main.py

@app.route('/error/fatal')
def error_fatal():
    raise(Exception('500 error'))
    


@app.errorhandler(404)
def not_found(error):
    return render_template("404.html", error=error)

@app.errorhandler(500)
def server_down(error):
    return render_template('500.html', error=error)

500.html

{% block title %} {{super()}} 500 {% endblock %}

{% block content %}
    <h2>Lo sentimos</h2>
    <h3>Volvemos Pronto</h3>
    <h6>Estamos trabajando en ello</h6>
    <p> {{error}} </p>
{% endblock%}

navbar.html

<nav>
  <ul>
    <img src="{{ url_for('static', filename='img/platzi.png') }}" alt="platzi-logo"/>
    <li><a href="{{ url_for('index')}}">Ir a inicio</a></li>
    <li><a href="{{ url_for('error_fatal') }}">Ir a error 500</a></li>
    <li><a href="https://platzi.com" target="_blank">Ir a platzi</a></li>
  </ul>
</nav>

en el main.py

@app.errorhandler(500)
def server_error(error):
	return render_template('500.html`, error=error)``



```{% extends 'base.html' %}
{% block title %}
{{ super() }}
    500
{% endblock %}

{% block content %}
    <h1>lo sentimos estamos realizando pequeños cambios en nuestro servidor para mejorara nuestro servicio </h1>
    <p>{{ error }}</p>
{% endblock %}

Leyendo documentación de flask me encontré estos códigos para manejar HTTPException e InternalServerError de manera dinámica y no tener que manejar error por error
https://flask.palletsprojects.com/en/1.1.x/errorhandling/#application-errors

@app.errorhandler(HTTPException)
def handle_exception(e):
    """Return JSON instead of HTML for HTTP errors."""
    # start with the correct headers and status code from the error
    response = e.get_response()
    # replace the body with JSON
    response.data = json.dumps({
        "code": e.code,
        "name": e.name,
        "description": e.description,
        })
    response.content_type = "application/json"
    return response

 
@app.errorhandler(InternalServerError)
def handle_500(e):
    original = getattr(e, "original_exception", None)

    if original is None:
        # direct 500 error, such as abort(500)
        return render_template("500.html"), 500

    # wrapped unhandled error
    return render_template("500_unhandled.html", e=original), 500```
@app.errorhandler(500)
def internal_server_error(error):
    return render_template('500.html', error=error)

#Html
{% extends 'base.html' %}
{%  import 'macros.html' as macros %}
{% block title %}{{ super() }}Error Interno 500{% endblock %}

{% block content %}
<img id='sheldon' src="https://k30.kn3.net/5CE944069.jpg" >
<h1 id='er5'>Lo sentimos :( Tenemos un error Interno</h1>
<h2>Estamos trabajando para solucionarlo</h2>      
<h3>{{ error }}</h3>
   
{% endblock %}

Aquí la prueba:
Primero una ruta para provocar el error hacer el test:

Pueden modificar una ruta ya hecha:
(Esta función esta mal, me dará error 500).

@app.route('/algomalo')
def no_server():
    #  raise(Exception('500'))
    return sadasdasd

Reconociendo el error con Error Handler

@app.errorhandler(500)
def server_error(error):
    return render_template('500.html', error=error)

Usando un template para el error 500


    {% extends 'base.html'%}
    {% import  'macros.html' as macros %}

    {% block title %}
    {{super()}}
        500 Error del servidor
    {%endblock%}

    {%block content%}
        <h1>500 error :\</h1>
        <h2>Lo sentimos el servidor tuvo un error, intentalo más tarde.</h2>
    {%endblock%}

Nota 1: si provocarán un error deben pasar el debug mode a 0 usando:
export FLASK_DEBUG = 0

Nota 2:Recuerden reiniciar el servidor cuando ya no estén en debug mode.

Nota 3: Recuerden regresarlo a Debug mode para que no sufran.

Nota 4: Tomen agua 😃

Primeramente cree un ruta /test y proboque un error 500

@app.route('/test')
def test():
    raise(Exception('500 error'))

La manera como lo maneje fue así:

@app.errorhandler(Exception)
def internal_error_server(e):
    return render_template("500.html", error=e)

Debo mencionar que obligatoriamente el parametro del decorador es Exception, no funciono colocandole el numero 500

Les dejo un link para encontrar Templates para sus 404
https://freefrontend.com/html-css-404-page-templates/

Reto finalizado

  • main .py
from flask import Flask, request, make_response, redirect, render_template
app = Flask(__name__)

todos = ['TEXT1', 'TEXT2', 'TEXT3']

@app.errorhandler(404)
def not_found(error):
    return render_template('404.html', error= error)

@app.errorhandler(500)
def server_error(error):
    return render_template('500.html', error= error)

@app.route('/')
def index():

    user_ip = request.remote_addr
    response = make_response(redirect('/hello'))
    response.set_cookie('user_ip', user_ip)
    return response


@app.route('/hello')
def hello_world():

    user_ip = request.cookies.get('user_ip')
    context = {
        'user_ip': user_ip,
        'todos':todos,
    }

    return render_template('hello.html', **context)

error500.html:

{% extends 'base.html' %}
{% block title %}
{{ super() }}
Server error
{% endblock %}

{% block content %}
    <h1>Actualmente hay un error en el servidor intentalo mas tarde</h1>
{% endblock %}

Saludos a todos aqui les dejo mas informacion oficial respecto a los errores:

Le di más detalle a la página

Mi solución al reto

En el archivo .py añadi esta ruta


@app.errorhandler(500):
def server_error(error500):
    return render_template('500.html', error500=error500)

Lego cree un archivo llamado 500.html el cual contenia el siguiente codigo

{% extends 'base.html' %} 



{% block title %}
    {{ super() }}
    Internal server error
{% endblock %}

{% block content%}
    <h1> Alert! 500 Internal server error  </h1>
    <p> {{ error500 }} </p>
{% endblock %}

y listo! un error 500 para toda la familia.

![](

La función en general es muy parecida, lo que hice fue renombrar el template y usar condicionales alli para que el template no solo sea 404 sino de errores en general

@app.errorhandler(404)
def not_found(error):
    return render_template('error.html', error = error, error_code = 404)

@app.errorhandler(500)
def not_found(error):
    return render_template('error.html', error = error, error_code = 500)

{% extends 'base.html' %}

{% block title %}
    {{ error_code }}
{% endblock %}

{% block content %}

    {% if error_code == 404 %}
        <h1>Lo sentimos, no encontramos lo que buscabas</h1>
        {{ error }}
    {% elif error_code == 500 %}
        <h1>Error en el servidor, prueba recargar mas tarde</h1>
        {{ error }}
    {% endif %}

{% endblock %}

Codigo en Python:

@app.errorhandler(500)
def not_found(error):
    return render_template('500.html', error=error)

El codigo en html:

{% extends 'base.html' %}

{% block title %}
    {{super()}}
    404 - No encontrado
{% endblock %}

{% block content %}
    <h1>Error del servidor temporalmente fuera de servicio, intenta mas tarde</h1>
    <p>{{ error }}</p>
{% endblock %}

Python Handler:

@app.errorhandler(500)
def not_found(error):
    return render_template('500.html', error=error)

HTML Code:

{% extends 'base.html'%}

{% block title %}
    {{ super() }}
    <h1>500</h1>
{% endblock %}


{% block content %}
    <h1>We are really embarrased! Our server is not working as expected.</h1>
    <h2>We will be back as soon as possible</h2>
    <p>Detail: {{ error }}</p>
{% endblock %}```

Hola, yo simule el error solo con este código:

@app.route('/500')
def error():
    return server_error(error)```

la manera adecuada seria seteando la variable FLASK_DEBUG=0, sin embargo si presentás problemas trabajando con visual podes ver el resultado de este problema generando una ruta al mismo.

Para probar el error es neceserio que la variable FLASK_DEBUG=0

@app.route('/error')
def error():
    return 5/0

@app.errorhandler(500)
def not_found(error):
    return render_template('500.html', error=error)

En esa ruta genero el error automaticamente

En el main,py:

Y en el 500.html:

# Para manejar los errores html en flask 
@app.errorhandler(404)
def notfound(error)
	return render_template('404.html')

@app.errorhandler(500)
def internalerror(error)
	return render_template('500.html')

@app.errorhandler(Exception)
def pageerror(error)
	return render_template('pageerror.html')

Recomendarìa que para hacer una pàgina custom para un error de aplicaciòn 500; se use la menos logica posible… talvez renderizar un template plano, sin extender el base, etc. Ya que el error puedo generarse incluso al renderizar eso, y terminamos haciendo algo sin sentido al fin y al cabo.

Por eso la mayorìa de los sitios muestran una pagina casi plana cuando ocurre el 500, algunos mas viejitos se acordaràn de la vieja ballenita que aparecìa cuando Twitter se caìa dos por tres.

<@ app.errorhandler(500)
def internal_server_error(errror)
	return render_template ('500.html'), error=error>