09_objetos_request_y_response.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![imagenes/pythonista.png](imagenes/pythonista.png)](https://pythonista.io)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objetos ```request``` y ```response```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ADVERTENCIA:**  \n",
    "\n",
    "Para poder realizar exitosamente los ejercicios de esta *notebook* es necesario haber seguido al pie de la letra y en orden sucesivo las instrucciones de todas las *notebooks* previas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notas preliminares sobre este capítulo.\n",
    "\n",
    "Este capítulo contiene al servicio web que será consumido por los comandos de la *notebook* [```10_objetos_request_y_response_cliente.ipynb```](10_objetos_request_y_response_cliente.ipynb), por lo que es necesario que el servidor de *Django* de esta *notebook* esté en ejecución cuando la *notebook* del cliente se esté ejecutando."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El paquete ```django.http```.\n",
    "\n",
    "Este paquete cuenta con herramientas diseñadas para gestionar las peticiones y repuestas más comunes de *HTTP*, incluyendo algunos mensajes de estado.\n",
    "\n",
    "En el capítulo [```06_peticiones_y_respuestas.ipynb```](06_peticiones_y_respuestas.ipynb) se describió brevemente:\n",
    "\n",
    "* El modo en el que los datos de las peticiones (*requests*) enviadas por un cliente son recibidas por el servidor de *Django* y contenidas en objetos instanciados de la clase ```django.http.HttpRequest```.\n",
    "* El modo en el que una función de vista  permite enviar una respuestas (*responses*) a un cliente por medio de una instancia de la clase ```django.http.HttpResponse```. \n",
    "\n",
    "En este capítulo se explorarán a detalle algunos recursos del módulo ```django.http```, incluyendo más información sobre ```django.http.HttpRequest``` y ```django.http.HttpResponse```.\n",
    "\n",
    "La referencia de este paquete puede ser consultada en:\n",
    "\n",
    "https://docs.djangoproject.com/en/3.2/ref/request-response/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos de ```django.http.HttpRequest```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos informativos.\n",
    "\n",
    "* ```get_host()``` regresa la *URL* del servidor.\n",
    "* ```get_port()``` regresa el puerto de conexión al servidor.\n",
    "* ```get_full_path()``` regresa la URL incluyendo los argumentos.\n",
    "* ```get_full_path_info()``` es similar a ```get_full_path()```, pero utilizando el atributo ```path_info```.\n",
    "* ```build_absolute_uri()``` regresa la *URL* absoluta.\n",
    "* ```is_secure()``` indica si la conexión es segura."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos de *XML*.\n",
    "\n",
    "* ```is_ajax()``` indica si el contenido es *AJAX*.\n",
    "* ```read()``` lee todo el contenido de forma similar al método ```read()``` de ```open()```.\n",
    "* ```readline()``` lee una línea del contenido de forma similar al método ```readline()``` de ```open()```.\n",
    "* ```readlines()``` lee cada línea del contenido y regresaun un objeto tipo ```list``` de forma similar al método ```readlines()``` de ```open()```.\n",
    "* ```__iter__()``` regresa un iterador."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos de *cookies*.\n",
    "\n",
    "* ```get_signed_cookie()``` recibe una *cookie* firmada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La clase ```django.http.QueryDict```.\n",
    "\n",
    "Los atributos ```GET``` y ```PUT``` de la clase ```django.http.HtmlRequest``` son instancias de la clase ```django.http.QueryDict```.\n",
    "\n",
    "La clase ```django.http.QueryDict``` es similar a un objeto tipo ```dict```, con la diferencia de que puede contener más de un objeto con la misma clave. Estos objetos con clave compartida son referidos dentro de en un objeto de tipo ```list```.\n",
    "\n",
    "La clase ```django.http.QueryDict``` es inmutable por defecto.\n",
    "\n",
    "```\n",
    "QueryDict.(query_string=<consulta>, mutable=<boolean>, encoding=<codificación>)\n",
    "````\n",
    "\n",
    "Donde: \n",
    "\n",
    "* ```<consulta>``` es un objeto de tipo ```str``` que contiene una consulta con parámetros como si se ingresarane  un una *URL*.\n",
    "* ```<booleano>``` es un objeto de tipo ```bool```. El valor por defecto es ```False``` e indica que el objeto instanciado es inmutable.\n",
    "* ```<codificación>``` es una cadena de caracteres que indica la codificación del texto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos de ```django.http.QueryDict```.\n",
    "\n",
    "Cuenta con los siguientes métodos que son similares a los del tipo ```dict```:\n",
    "\n",
    "* ```clear()```.\n",
    "* ```pop()```.\n",
    "* ```popitem()```.\n",
    "* ```setdefault()```.\n",
    "* ```update()```.\n",
    "* ```items()```.\n",
    "* ```values()```.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Métodos de gestión.\n",
    "\n",
    "* ```get()``` obtiene un atributo del objeto  ```django.http.QueryDict```.\n",
    "* ```dict()``` convierte el contenido del objeto ```django.http.QueryDict``` en un objeto tipo ```dict```.\n",
    "* ```copy()``` crea una copia del objeto ```django.http.QueryDict```.\n",
    "* ```urlencode()``` regresa un objeto ```str``` cuyo contenido usa la sintaxis de una consulta en una *URL* para desplegar las listas del objeto```django.http.QueryDict``` ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Métodos de listas.\n",
    "\n",
    "* ```getlist()``` regresa la lista de objetos ligados a una clave.\n",
    "* ```setlist()``` èn caso de que el objeto ```django.http.QueryDict``` sea mutable, es posible modificar o crear una lista con clave.\n",
    "* ```appendlist()```.\n",
    "* ```setlistdefault()```.\n",
    "* ```lists()``` regresa las claves y sus listas correspondientes contenida en un objeto ```django.http.QueryDict```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Detalles de la clase ```django.http.HttpResponse```.\n",
    "\n",
    "``` python\n",
    "django.http.HttpResponse(content='', content_type=None, status=200, reason=None, charset=None)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Métodos de ```django.http.HttpResponse```.\n",
    "\n",
    "#### Métodos de gestión.\n",
    "\n",
    "* ```has_header()```\n",
    "* ```setdefault()```\n",
    "\n",
    "#### Métodos de gestión de *cookies*.\n",
    "\n",
    "* ```set_cookie()```\n",
    "* ```set_signed_cookie()```\n",
    "* ```delete_cookie()```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Otras subclases de ```django.http.Reponse```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Respuestas por tipo.\n",
    "\n",
    "* ```django.http.JsonResponse```.\n",
    "* ```django.http.FileResponse```.\n",
    "* ```django.http.StreamingResponse```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clases  de mensajes de estado.\n",
    "\n",
    "####  Mensajes de reenvío (```300```).\n",
    "\n",
    "* ```django.http.HttpResponseRedirect``` (```302```).\n",
    "* ```django.http.HttpResponseNotModified``` (```304```).\n",
    "* ```django.http.HttpResponsePermanentRedirect``` (```308```). \n",
    "\n",
    "#### Mensajes de error del cliente (```400```).\n",
    "\n",
    "* ```django.http.HttpResponseBadRequest``` (```400```)\n",
    "* ```django.http.HttpResponseForbidden``` (```403```)\n",
    "* ```django.http.HttpResponseNotFound``` (```404```)\n",
    "* ```django.http.HttpResponseNotAllowed``` (```405```)\n",
    "* ```django.http.HttpResponseGone``` (```410```)\n",
    "\n",
    "#### Mensajes de error del servidor (```500```).\n",
    "* ```django.http.HttpResponseServerError``` (```500```)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excepciones.\n",
    "\n",
    "* ```django.http.UnreadablePostError```.\n",
    "* ```django.http.Http404```.\n",
    "* ```django.http.BadHeaderError```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo ilustrativo.\n",
    "\n",
    "El archivo ```src/09/urls.py``` contiene el siguiente código:\n",
    "\n",
    "\n",
    "``` python\n",
    "from django.urls import path, re_path \n",
    "from . import views\n",
    "\n",
    "\n",
    "urlpatterns = [path('', views.index, name=\"inicio\"), \n",
    "               path('vista', views.vista),\n",
    "               re_path(r'^claves/(?P<clave>[0-9]{4}$)', views.clave),\n",
    "               path('claves/<int:numero>', views.numero),\n",
    "               path('claves/<str:nombre>', views.saluda),\n",
    "               path('json', views.respuesta_json),\n",
    "               path('contenido', views.contenido),\n",
    "               path('error', views.error),\n",
    "               path('listas', views.listas)]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para la plataforma GNU/Linux y MacOS X:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cp src/09/urls.py tutorial/main/urls.py "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para la plataforma Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!copy src\\09\\urls.py tutorial\\main\\urls.py "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pycat tutorial/main/urls.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El archivo ```src/09/views.py``` contiene el siguiente código:\n",
    "\n",
    "\n",
    "``` python\n",
    "from django.http import HttpResponse, HttpResponseServerError, JsonResponse\n",
    "from django.views.decorators.csrf import csrf_exempt\n",
    "\n",
    "\n",
    "def index(request):\n",
    "    return HttpResponse(\"<h1>Hola, mundo.</h1>\")\n",
    "\n",
    "\n",
    "def vista(request):\n",
    "    return HttpResponse('<ul><li>URL: {}</li><li>Método: {}</li><li>Codificación: {}</li><li>Argumentos: {}</li></ul>'.format(request.path, request.method, request.encoding, request.GET.dict()))\n",
    "\n",
    "\n",
    "def clave(request, clave):\n",
    "    return HttpResponse('<h1>Introdujiste la clave: {}</h1>'.format(str(clave)))\n",
    "\n",
    "\n",
    "def numero(request, numero):\n",
    "    return HttpResponse('<h1>Introdujiste el número: {}</h1>'.format(str(numero)))\n",
    "\n",
    "\n",
    "def saluda(request, nombre):\n",
    "    return HttpResponse('<h1>¡Hola, {}!</h1>'.format(nombre))\n",
    "\n",
    "\n",
    "def respuesta_json(request):\n",
    "    return JsonResponse({'tipo contenido':request.content_type, 'metodo':request.method, 'ruta':request.path})\n",
    "\n",
    "\n",
    "def error(request):\n",
    "    return HttpResponseServerError('<h1>¡Ups!</h1>')\n",
    "\n",
    "\n",
    "@csrf_exempt\n",
    "def contenido(request):\n",
    "    return JsonResponse(request.POST.dict())\n",
    "\n",
    "\n",
    "def listas (request):\n",
    "    return HttpResponse(request.GET.lists())\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para la plataforma Linux y MacOS X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!cp src/09/views.py tutorial/main/views.py "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para la plataforma Windows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!copy src\\09\\views.py tutorial\\main\\views.py "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pycat tutorial/main/views.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arranque del servicio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arranque desde la *notebook*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%cd tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!python manage.py runserver 0.0.0.0:8000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota:** Es necesario interrumpir el *kernel* de la *notebook* para terminar la ejecución del servidor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arranque desde una terminal.\n",
    "\n",
    "#### Carga del entorno.\n",
    "\n",
    "* En caso de que se acceda a la terminal de la máquina virtual proporcionada por *Pythonista<sup>®</sup>*, es necesario cargar el entormno con el siguiente comando.\n",
    "\n",
    "```\n",
    "source ~/pythonista/bin/activate\n",
    "```\n",
    "#### Inicio del servidor.\n",
    "\n",
    "* Desde la terminal ubicar el shell en el directorio ```tutorial```, en el cual se encuentra el script ```manage.py```.\n",
    "\n",
    "```\n",
    "python manage.py runserver 0.0.0.0:8000\n",
    "```\n",
    "\n",
    "**Nota:** \n",
    "Es necesario que el firewall de su equipo esté configurado para transmitir desde el puerto ```8000```. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resultado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las siguientes *URLs* pueden ser accedidas mediante un navegador debido a que usa el método ```GET```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://localhost:8000/main/error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://localhost:8000/main/listas\n",
    "\n",
    "https://localhost:8000/main/listas?nombre=Juan&apellido=Perez\n",
    "\n",
    "\n",
    "https://localhost:8000/main/listas?nombre=Juan&apellido=Perez&nombre=Jesus&nombre=Pablo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://localhost:8000/main/contenido?nombre=jose&apellido=perez&nombre=Jesus&nombre=Pablo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: center\"><a rel=\"license\" href=\"https://creativecommons.org/licenses/by/4.0/\"><img alt=\"Licencia Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/80x15.png\" /></a><br />Esta obra está bajo una <a rel=\"license\" href=\"https://creativecommons.org/licenses/by/4.0/\">Licencia Creative Commons Atribución 4.0 Internacional</a>.</p>\n",
    "<p style=\"text-align: center\">&copy; José Luis Chiquete Valdivieso. 2020.</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}