08_json_con_django.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "[![imagenes](imagenes/pythonista.png)](https://pythonista.mx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# El formato *JSON* y *Django*."
   ]
  },
  {
   "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": [
    "## El formato *JSON*.\n",
    "\n",
    "*JSON* es el acrónimo de *Javascript Object Notation* y antes de las modificaciones publicadas en el estándar [*ECMAScript 2015*](https://www.ecma-international.org/ecma-262/6.0/), correspondía al modo en el que se definen objetos en *Javascript*. Sin embargo, la notación es tan simple y práctica que ha sido adoptada como un formato para la transmisión de datos y ha evolucionado de forma paralela a *Javascript*.\n",
    "\n",
    "Para aprender más acerca de *JSON* es posible consultar la siguiente liga:\n",
    "\n",
    "https://www.w3schools.com/js/js_json_intro.asp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El paquete ```json``` de *Python*.\n",
    "\n",
    "Este paquete ```json``` es parte de la biblioteca estándar de *Python* cuenta con herramientas capaces transformar objetos de *Python* a cadenas de caracteres con una estructura apegada a *JSON* y viceversa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Las funciones ```json.dumps()``` y ```json.loads()```.\n",
    "\n",
    "Estas dos funciones permiten tranformar cadenas de caracteres que contengan una estructura de datos apegadas a *JSON* y objetos de *Python* (primordialmente objetos tipo ```dict```)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "#### La función ```json.dumps()```.\n",
    "Transforma a un objeto ingresada como primer parámetro a una cadena de texto en formato *JSON*.\n",
    "\n",
    "**Sintaxis:**\n",
    "\n",
    "```\n",
    "json.dumps(<objeto>)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**\n",
    "\n",
    "* Se aplicará la función ```json.dumps``` al objeto tipo ```dict``` con nombre ```estudiante```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante = {'nombre completo': ['Juan', 'Pérez', 'Sánchez'], 'rol': 'estudiante'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(estudiante)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "json.dumps(estudiante)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A la cadena de caracteres resultante se le dará el nombre ```estudiante_json``` y se utilizará en los ejemplos siguientes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante_json = json.dumps(estudiante)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante_json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(estudiante_json)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La función ```json.loads()```.\n",
    "\n",
    "Esta función transforma una cadena de caracteres que contiene información en formato *JSON* y la transforma en un objeto de tipo ```dict```.\n",
    "\n",
    "**Sintaxis:**\n",
    "\n",
    "```\n",
    "json.loads(<cadena de caracteres>)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**\n",
    "\n",
    "* Se utilizará el objeto ```estudiante_json``` para recuperar los datos y transferirlos a un objeto llamado ```nuevo_estudiante```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nuevo_estudiante = json.loads(estudiante_json)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nuevo_estudiante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(nuevo_estudiante)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Aún cuando los datos de ```nuevo_estudiante``` son los mismos de ```estudiante```, no son el mismo objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante == nuevo_estudiante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante is nuevo_estudiante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Las funciones ```json.dump()``` y ```json.load()```.\n",
    "\n",
    "Estas dos funciones realizan tranformaciones con *JSON*, pero a partir de archivos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La función ```json.dump()```.\n",
    "Transforma a un objeto ingresado como primer parámetro a una cadena de texto en formato *JSON* y la guarda en un objeto de tipo archvo que se ingresa como segundo parámetro.\n",
    "\n",
    "**Sintaxis:**\n",
    "\n",
    "```\n",
    "json.dump(<objeto>, <archivo>)\n",
    "```\n",
    "\n",
    "Donde:\n",
    "\n",
    "* ```<archivo>``` corresponde a un objeto creado mediante la función ```open()``` en modo de escritura."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**\n",
    "\n",
    "* A continuación se creará un archivo de texto ```alumno.json``` y el objeto correspondiente será llamado ```archivo```.\n",
    "* El resultado de aplicar ```json.dump()``` al objeto ```alumno``` será guardado en el archivo de texto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"alumno.json\", \"wt\") as archivo:\n",
    "    json.dump(estudiante, archivo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para las plataformas basadas en *GNU/Linux* y *MacOS X*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "!cat alumno.json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para la plataforma *Windows*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!type alumno.json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### La función ```json.load()```.\n",
    "Lee el contenido de un archivo que contiene información en formato *JSON* y la transforma en un objeto de tipo ```dict```.\n",
    "\n",
    "**Sintaxis:**\n",
    "\n",
    "```\n",
    "json.load(<archivo>)\n",
    "```\n",
    "\n",
    "Donde:\n",
    "\n",
    "* ```<archivo>``` corresponde a un objeto creado mediante la función ```open()``` en modo de lectura."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**\n",
    "\n",
    "* La siguiente celda accederá al archivo de texto ```alumno.json``` y el objeto correspondiente será llamado ```archivo```.\n",
    "* Al aplicar ```json.load()``` al objeto ```alumno``` se creará un objeto de tipo ```dict```, el que se le asignará el nombre ```otro_estudiante```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"alumno.json\", \"rt\") as archivo:\n",
    "    otro_estudiante = json.load(archivo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "otro_estudiante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "otro_estudiante == estudiante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "otro_estudiante is estudiante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Incompatibilidad con objetos ```bytes```.\n",
    "\n",
    "Las herramientas de *JSON* no pueden transformar objeto de tipo ```bytes``` y al intentarlo se levantará una excepción ```TypeError```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "json.dumps({'Nombre': b'Jose'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La clase ```django.http.JsonResponse```.\n",
    "\n",
    "La clase ```django.http.JsonResponse``` es una subclase de ```django.http.HttpResponse```, la cual permite que una función de vista regrese una respuesta en formato *JSON* a partir de un objeto ```dict```.\n",
    "\n",
    "```\n",
    "JsonResponse(<objeto tipo dict>)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**\n",
    "\n",
    "El *script* ```src/08/urls.py``` incluye una ruta apuntando a ```main/path```, ligándola a la función de vista ```views.respuesta_json()```.\n",
    "\n",
    "``` python\n",
    "from django.urls import path, re_path \n",
    "from . import views\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",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A continuación se sustituirá al *script* ```tutorial/main/urls.py``` con el *script* ```src/08/urls.py```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para la plataforma *GNU/Linux* y *MacOS X*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cp src/08/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\\08\\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 *script* ```src/08/views.py``` incluye a la función de vista ```respuesta_json()``` con el siguiente código:\n",
    "\n",
    "``` python\n",
    "def respuesta_json(request):    \n",
    "    return JsonResponse({'tipo contenido':request.content_type, 'metodo':request.method, 'ruta':request.path, 'argumentos':request.GET.dict()})\n",
    "```\n",
    "\n",
    "Esta función regresa un objeto instanciado de ```django.http.JsonResponse```, el cual contiene algunos atributos del objeto ```request``` que se ingresa como argumento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A continuación se sustituirá al *script* ```tutorial/main/views.py``` con el *script* ```src/08/views.py```."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Para las plataformas *GNU/Linux* y *MacOS X*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cp src/08/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\\08\\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 web."
   ]
  },
  {
   "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": false
   },
   "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": [
    "El resultado puede observarse en http:https://localhost:8000/main/json\n",
    "\n",
    "El resultado puede observarser en http:https://localhost:8000/main/json?nombre=juan&apellido=perez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align: center\"><a rel=\"license\" href=\"http: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=\"http: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. 2021.</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
}