<jupyter_start><jupyter_text>FLASK----------------------- Usaremos Python y una biblioteca llamada **Flask** para escribir nuestro propio servidor web, implementando funciones adicionales. Flask también es un **framework**, donde se establece un conjunto de convenciones para la utilización de sus librerias. Por ejemplo, al igual que otras librerias, Flask incluye funciones que podemos usar para analizar solicitudes individualmente, pero como framework, también requiere que el código de nuestro programa esté organizado de cierta manera:  Estructura Proyecto Flask<jupyter_code>flask-project-name
    +--application.py
    +--requirements.txt
    +--static/
    |    +--image1
    |    +--style.css
    |    +--script.js
    +--templates/
    |    +--index.html
    |    +--layaout.html
    |    +--page-n.html<jupyter_output><empty_output><jupyter_text>Donde:- `application.py` : Código python para nuestro servidor web.- `requirements.txt` :  Incluye la lista de librerias necesarias para que nuestra solución funciones.- `static/` : Directorio de archivos estáticos, tal como CSS y JavaScript files.- `templates/` : es un directorio de archivos HTML. Existen múltiples framework para cada uno de los lenguajes populares que existen hoy en día. En python entre los populares tenemos Django, Flask, Piramide  Patrón de Diseño en Flask Flask también implementa un patrón de **design pattern**, o la forma en que nuestro programa y código están organizados. Para Flask, el patrón de diseño es generalmente MVC o Model-view-controller:  Donde:- El **controller** es nuestra **lógica y código que administra nuestra aplicación en general**, dada la entrada del usuario. En Flask, este será nuestro código Python.- La **view** es la **interfaz de usuario, como el HTML y CSS que el usuario verá e interactuará**.- El **model** es **nuestra data** tal como base de datos SQL o CSV   Nuestra Primera aplicacion Flask Podemos realizar una simple aplicación web a partir del siguiente código<jupyter_code>from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello_world():
    return "Hello, Flask!"<jupyter_output><empty_output><jupyter_text>- Primero, importaremos `Flask` de la biblioteca `flask`, que usa una letra mayúscula para su nombre principal.- Luego, crearemos una variable de aplicación dando el nombre de nuestro archivo será la variable `Flask`.- A continuación, etiquetaremos una función para `/` route o URL con `@app.route`. El símbolo `@` en Python se llama decorador, que aplica una función a otra.- Llamaremos a la función `index`, ya que debería responder a una solicitud de `/`, la página predeterminada. Y nuestra función solo responderá con una cadena por ahora.  Ejecución-----------------Para poder ejecutar nuestra script podemos realizar los siguiente pasos sobre **CMD**:`> set FLASK_APP=python_file_name``> flask run` * Running on http://127.0.0.1:5000/ Actualizaremos nuestro código para devolver HTML con la función `render_template`, que encuentra un archivo dado y devuelve su contenido:<jupyter_code>from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def index():
    return render_template("index.html")<jupyter_output><empty_output><jupyter_text>Tendremos que crear un directorio `templates/` y crear un archivo `index.html` con algo de contenido dentro.Ahora, escribiendo `flask run` devolverá ese archivo HTML cuando visitemos la URL de nuestro servidor. Pasaremos un argumento a `render_template` en nuestro código de controlador:<jupyter_code>from flask import Flask, render_template, request

app = Flask(__name__)

@app.route("/")
def index():
    return render_template("index.html", name=request.args.get("name", "world"))<jupyter_output><empty_output><jupyter_text>Resulta que podemos darle a `render_template` cualquier argumento, como `name`, y lo sustituirá en nuestra plantilla o en nuestro archivo HTML con marcadores de posición. - En `index.html`, reemplazaremos `hello, world` con `hello`, para decirle a Flask dónde sustituir la variable `name`:<jupyter_code><!DOCTYPE html>

<html lang="en">
    <head>
        <title>hello</title>
    </head>
    <body>
        hello, {{ name }}
    </body>
</html><jupyter_output><empty_output><jupyter_text>- Podemos usar la variable `request` de la biblioteca Flask para obtener un parámetro de la solicitud HTTP, en este caso también el `name`, y volver a un valor predeterminado de `world` si no se proporcionó uno. - Ahora, cuando reiniciamos nuestro servidor después de realizar estos cambios, y visitamos la página predeterminada con una URL como `/?name=David`, veremos esa misma entrada devuelta en el HTML generado por nuestro servidor.Podemos suponer que la consulta de búsqueda de Google, en / search? Q = cats, también se analiza mediante algún código para el parámetro q y se pasa a alguna base de datos para obtener todos los resultados que son relevantes. Luego, esos resultados se utilizan para generar la página HTML final.  Forms Moviremos nuestra plantilla original a `greet.html`, para que reciba al usuario con su nombre. En `index.html`, crearemos un formulario:<jupyter_code><!DOCTYPE html>

<html lang="en">
    <head>
        <title>hello</title>
    </head>
    <body>
        <form action="/greet" method="get">
            <input name="name" type="text">
            <input type="submit">
        </form>
    </body>
</html><jupyter_output><empty_output><jupyter_text>- Enviaremos el formulario a la `/greet` ruta y tendremos una entrada para el `name` parámetro y otra para el botón de envío.- En nuestro `applications.py` controlador, también necesitaremos agregar una función para la `/greet` ruta, que es casi exactamente lo que teníamos `/` antes:<jupyter_code>@app.route("/")
def index():
    return render_template("index.html")


@app.route("/greet")
def greet():
    return render_template("greet.html", name=request.args.get("name", "world"))<jupyter_output><empty_output><jupyter_text>- Nuestro formulario `index.html` será estático ya que puede ser el mismo en todo momento.Ahora, podemos ejecutar nuestro servidor, ver nuestro formulario en la página predeterminada y usarlo para generar otra página.  Post - Nuestro formulario anterior utilizó el método GET, que incluye los datos de nuestro formulario en la URL.- Vamos a cambiar el método en nuestro HTML: ``. Nuestro controlador también deberá cambiarse para aceptar el método POST y buscar el parámetro en otro lugar:<jupyter_code>@app.route("/greet", methods=["POST"])
def greet():
    return render_template("greet.html", name=request.form.get("name", "world"))<jupyter_output><empty_output><jupyter_text>- Si bien `request.args` es para parámetros en una solicitud GET, tenemos que usar request.formen Flask para parámetros en una solicitud POST.Ahora, cuando reiniciamos nuestra aplicación después de realizar estos cambios, podemos ver que el formulario nos lleva a /greet, pero los contenidos ya no están incluidos en la URL.  Layouts - En `index.html` y `greet.html`, tenemos un código HTML repetido. Solo con HTML, no podemos compartir código entre archivos, pero con las plantillas de Flask (y otros marcos web), podemos descartar ese contenido común. - Crearemos otra plantilla, `layout.html`:<jupyter_code><!DOCTYPE html>

<html lang="en">
    <head>
        <title>hello</title>
    </head>
    <body>
        {% block body %}{% endblock %}
    </body>
</html><jupyter_output><empty_output><jupyter_text>Flask admite Jinja, un lenguaje de creación de plantillas, que utiliza la sintaxis `{% %}` para incluir bloques de marcadores de posición u otros fragmentos de código. Aquí hemos nombrado nuestro bloque `body` ya que contiene el HTML que debería ir en el elemento ``. Del mismo modo, en `greet.html`, nosotros definimos the bloque `body` con solo el saludo:<jupyter_code>{% extends "layout.html" %}

{% block body %}

    hello, {{ name }}

{% endblock %}<jupyter_output><empty_output><jupyter_text>Ahora, si reiniciamos nuestro servidor y vemos el código fuente de nuestro HTML después de abrir la URL de nuestro servidor, vemos una página completa con nuestro formulario dentro de nuestro archivo HTML, generado por Flask.Incluso podemos reutilizar la misma ruta para admitir los métodos GET y POST:<jupyter_code>@app.route("/", methods=["GET", "POST"])
def index():
    if request.method == "POST":
        return render_template("greet.html", name=request.form.get("name", "world"))
    return render_template("index.html")<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.09677798682972719, 'fraction_numerical': 0.0012935089369708374, 'mean_word_length': 4.625, 'pattern_counts': {'":': 1, '<': 76, '<?xml version=': 0, '>': 78, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 1, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '11', 'dir': 'jupyter-structured-clean-dedup', 'id': '62784', 'license': 'Apache-2.0', 'n_tokens_mistral': 2735, 'n_tokens_neox': 2680, 'n_words': 1007, 'path': 'Modulo5/4.Flask.ipynb', 'repo_name': 'ShirleyRodriguez08/PythonFundamentos', 'size': '8504'}