Fandom

Scratchpad

CherryPy-Tutorial-Spanish

215,595pages on
this wiki
Add New Page
Discuss this page0 Share

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.

CherryPy-Tutorial-Spanish at Wikia


Welcome to the CherryPy-Tutorial-Spanish mini wiki at Scratchpad!

You can use the box below to create new pages for this mini-wiki. Make sure you type [[Category:CherryPy-Tutorial-Spanish]] on the page before you save it to make it part of the CherryPy-Tutorial-Spanish wiki (preload can be enabled to automate this task, by clicking this link and saving that page. Afterwards, you may need to purge this page, if you still see this message).


Qué es CherryPy?

CherryPy es un framework de desarrollo web orientado a objetos en Python. Provee las bases sobre las cuales aplicaciones web complejas pueden ser escritas, con poco o nada de conocimiento e los protocolos subyacentes. CherryPy permite a los desarrolladores construir aplicacones web en una forma muy similar a la que construirían cualquier programa Python. Esto generalmente resulta en menos tiempo de desarrollo.

CherryPy hace lo mejor que puede para mantenerse fuera entre el programador y el problema. Las aplicaciones CherryPy son usualmente muy simples. Funciona mágicamente (out-of-the-box); el comportamiento por defecto es lo suficientemente sensible para permitir un uso sin configuraciones o personalizaciones extensas. EL servidor web embebido, permite a uno desplegar aplicaciones web en donde Python este instalado.

Qué NO ES CherryPy?

Como framwework (marco de trabajo) de aplicaciones web, CherryPy hace todo lo necesario para permitir que codigo Python sea ejecutado cuando un recurso (o URL) es requerido por el usuario. Sin embargo, no es un lenguaje de templating (plantilla), como PHP. CherryPy puede trabajar con varios paquetes de templating, incluyendo Cheetah, CherryTemplate, y varios otros. Pero por favor, noten que los paquetes de templating mientras son necesarios en algunos casos, no lo son estrictamente. Y que código Python"puro" puede ser utilizado para generar páginas web.

CherryPy incluye un servidor web liviano embebido, suficientemente capaz de soportar importantes cargas de tráfico. Se estima que CherryPy puede manejar 500 requests/segundo con una configuración razonable (a enero del 2005); esto puede ser traducido como una salida de 15 Mbps. Sin embargo, CherryPy no es apache. Si por otra razon necesita un servidor web de clase empresarial, podrá utilizar Apache y Cherrypy juntos.

De qué se trata este tutorial?

Este tutorial cubre los pasos básicos para que un principiante obtenga lo básico del enfoque único que tiene CherryPy acerca del desarrollo de aplicaciones web. Luego de seguir este tutorial, el programador podrá comprender como funcionan las aplicaciones CherryPy, y también implementar simples pero poderosas aplicaciones por si mismo. Algunos conocimientos de Python se asumen. Uno no necesita ser un experto para trabajar con CherryPy, pero un buen entendimiento de lo básico de la orientación a objetos es muy recomendable.

Conocimiento requerido.

Se asume que el usuario tiene:

  • Algunos conocimientos de Python
  • Alguna experiencia con programación orientada a Objetos.
  • Algún conocimiento de HTML, que es necesario para construir páginas web.

Aprendiendo Python

Como dice arriba, esto no es una guía del lenguage Python. Hay disponibles muchos recursos buenos para aquellos que estén aprendiendo Python. El sitio official de Python lista alguos buenos, incluyendo un excelente tutorial.

Tu primer aplicación CherryPy

El estandar "Hola Mundo!" toma menos de 10 lineas de código cuando se escribe utilizando CherryPy.


import cherrypy  
   
class HelloWorld:  
    def index(self):  
        return "Hola Mundo!"  
    index.exposed = True  
   
cherrypy.root = HelloWorld()  
cherrypy.server.start()  


Se asume que ya tienes CherryPy instalado. Copia este archivo y guardalo localmente como hello.py, luego largá la aplicacion con el comando


python hello.py 


Desde tu navegador, ve hacia http://localhost:8080 y deberías ver el Hola Mundo! ahí.

Cómo funciona?

Miremos hello.py

  • La declaración import cherrypy importa el modulo CherryPy. Esto es un requerimiento para tener CherryPy funcionando.
  • Declaramos la clase llamada HelloWorld. Una instancia de la clase es el objeto que va a ser publicado por CherryPy. Contiene un sólo método, llamado index, que sera llamado por la URL raiz por el sitio pedido (por ejemplo: http://localhost/). Este método devuelve el contenido de la página web, en este caso la cadena "Hola mundo!".
  • index.exposed = True es un paso necesario para "decirle" a CherryPy que el método index() va a ser expuesto (exposed). Sólo los métodos expuestos pueden ser llamados para responder una request. Esta propiedad permite que el usuario (de CherryPy) seleccione que métodos de un objeto van a estar accesibles via Web; los que no sean expuestos no podrán ser accedidos.
  • cherrypy.root = HelloWorld() pública una instancia de la clase HelloWorld
  • cherrypy.server.start() llama al servidor web embebido. Correra hasta que sea explicitamente interrumpido, con ctrl-c o con una señal (kill, o terminar proceso).
  • Es tambien posible implementar un shutdown para el servidor como parte de la aplicacion, pero escapa del alcance del tutorial.

Cuando una aplicación es ejecutada, el servidor CherryPy es iniciado con la configuración por defecto. Escuchará en el localhost puerto 8080. Estas configuraciones pueden ser cambiadas con el archivo de configuración (veremos sobre esto más adelante).

Finalmente, el servidor web recive la request para la URL http://localhost:8080. Busca por el mejor método para manejar la request, comenzando por cherrypy.root (el cuál es la instancia de HelloWorld). En este caso en particular, la raiz del sitio web es mapeado automáticamente al método index() (similar al index.html que es la página estandar para los servidores web convencionales). La clase HelloWorld define un método index() y lo expone. CherryPy llama a cherrypy.root.index(), y el resultado de esta llamada es enviada de vuelta al navegador como el contenido de la página index para el sitio web. Todo el trabajo es hecho automáticamente; el programador de la aplicación solo necesita proveer el contenido deseado como valor de retorno para el método index().

Conceptos

Publicando objetos

Cualquier objeto adjunto al cherrypy.root se dice que esta publicado. Esto significa que el objeto es accesible via la rutina de mapeo URL-a-objeto. Sin embargo, eso no significa que el objeto en si mismo es accesible directamente desde la Web. Para que esto pase, el objeto debe ser expuesto

Exponiendo objectos

CherryPy mapea las URL de requests a objetos y llama al método que corresponda automáticamente. Los métodos que pueden ser llamados como resultado de una request externa se dicen que están expuestos.

Los objetos se exponen en CherryPy seteando el atributo exposed. Esto puede ser realizado directamente por el objeto mismo:

objeto.exposed = True

Los métodos también pueden ser expuestos por un decorador.

Por qué esta distinción?

La distinción entre un objeto publicado y uno expuesto puede parecer tonta o innecesaria al comienzo. Por definición, todos los objetos expuestos están también publicados, entonces ¿por qué debemos preocuparnos acerca de los objetos no expuestos?

La respuesta es que, a pesar de que sólo los objetos expuestos pueden ser accedidos como resultado de una consulta externa, hay algunas situaciones donde las request pueden ser remapeadas a cualquier objeto publicado, incluyendo los no expuestos. Esto es una propiedad avanzada que se va a ver en juego más adelante. por ahora, todo lo que se necesita comprender, son estos conceptos básicos.

Encontrando el objeto correcto

Para el usuario, la aplicación web es como un sitio con archivos estáticos. El usuario escribe (o hace click) en una URL, y obtiene la página web deseada. Un servidor web convencional usa la URL para obtener un archivo estático del sistemas de archivo (filesystem). Por otro lado, el servidor de aplicación web no solo sirve (en el sentido de brindar un servicio) el contenido estático de archivos; también puede mapear la URL que recibe, en un objeto y llamarlo. El resultado es enviado al navegador del usuario, donde será renderizado en una página web. El resultado es una aplicación de páginas web dinámicas; para cada URL, un único objeto puede ser llamado en acción.

La clave para comprender como escribir una nueva aplicación web es entender cómo ocurre este mapeo. CherryPy utiliza un procedimiento de mapeo directo. La razi (root) del sitio es el objeto cherrypy.root. Cuando recibe una URL, analiza los componentes del path, y procede a mirar hacia abajo hasta encontrar un objeto que "se ajuste mejor" para esa URL en particular. Para cada componente del path trata de encontrar un objeto con el mismo nombre, comenzando por cherrypy.root, y siguiendo hacia abajo para cada componente que encuentra, hasta que no encuentre ninguno. Un ejemplo lo mostraría mejor:

cherrypy.root.onepage = OnePage()
cherrypy.root.otherpage = OtherPage()

En el ejemplo de arriba, la URL http://localhost/onepage apuntará al primer objeto y la URL http://localhost/otherpag apuntará al segundo. Como de costumbre, esta búqueda es hecha automáticamente. Pero esto vá aún más allá:

cherrypy.root.some = Page() cherrypy.root.some.page = Page()

En este ejempo, la URL http://localhost/some/page será mapeada al objeto cherrypy.root.some.page. Si este objeto es expuesto (o alternativamente su método index lo es), será llamado para esa URL.

El método index

El método index() tiene un rol especial en CherryPy. Como el archivo index.html, es (el método index) la página por defecto en cualquier nodo interno del árbol del objeto. El método index() es el único método que no soporta parámetros posicionales.

El método index() sólo es llamado por una coincidencia completa con la URL. Si la URL coincide parcialmente (en otras palabras, si CherryPy no puede encontrar una coincidencia para un componente en el path), no será llamado.

Llamando otros métodos

CherryPy puede llamar directamente a otros métodos de los objetos publicados, si recive una URL que los mapea directamente. Por ejemplo:

1    def foo(): 
2        return 'Foo!' 
3    foo.exposed = True 
4
5    cherrypy.root.foo = foo

En el ejemplo, cherrypy.root.foo contiene un objeto función, llamado foo. Cuando CherryPy recibe un request para la URI /foo, automáticamente llamará a la función foo(). Notar que puede ser una función directamente, o un método de cualquier objeto; cualquier cosa "llamable" servirá.

En algunos casos avanzados, puede haber conflictos cuando CherryPy intente decidir qué método va a manejar el request. El método index() tiene precedencia. Pero si CherryPy encuentra una coincidencia completa y el último objeto en la coincidencia es "llamable" (lo que significa que el método, función o cualquier otro objeto de Python que soporte el método __call__); y finalmente, si el "llamable" mismo no contiene un método index() válido, entonces el objeto en sí mismo va a ser llamado. Estas reglas son más que necesarias porque las clases en Python en realidad son "llamables"; llamarlas produce una nueva instancia. Puede parecer confuso, pero las reglas son muy simples en la práctica.

Recibiendo datos de un formulario HTML

Cualquier método que es llamado por CherryPy - index, o cualquiera que se pueda - puede recibir daros adicionales de un formulario HTML utilizando argumentos claves (keyword arguments). Por ejemplo, el siguiente formulario de acceso (login) envía el nombre de usuario y contraseña (username y password) como argumentos utilizando el método POST (entiéndase método como método de request a un servidor http, y no método de objeto):

1	<form action="doLogin" method="post"> 
2	     <p>Username</p> 
3	     <input type="text" name="username" value=""  
4	                size="15" maxlength="40"/> 
5	     <p>Password</p> 
6	     <input type="password" name="password" value="" 
7	                size="10" maxlength="40"/> 
8	     <p><input type="submit" value="Login"/></p> 
9	     <p><input type="reset" value="Clear"/></p> 
10	</form> 

El siguiente código puede ser utilizado para manejar esta URL (/doLogin):

1	class Root: 
2	    def doLogin(self, username=None, password=None): 
3	        # check the username & password 
4	        ... 
5	    doLogin.exposed = True 
6	 
7	cherrypy.root = Root() 

Ambos argumentos tienen que ser declarados como argumentos claves. EL valor por defecto puede ser utilizado ya sea para dar un valor por defecto que se ajuste, o bien para darle contexto a la aplicación para que detecte que valores fueron omitidos en la request.

CherryPy soporta ambos métodos para los formularios, el GET y el POST. Los argumentos son pasados de la misma forma sin importar que método utilizó en el navegador para enviar los datos al servidor.

The CherryPy configuration file

CherryPy uses a simple configuration file to customize some aspects of its behavior. The configuration file can be edited with any conventional text editor (even Notepad will do it), and can be used even by non-technical users for some simple customization tasks. For example:

1	[global] 
2	server.socket_port = 8000 
3	server.thread_pool = 10 
4	session_filter.on = True 
5	static_filter.root = "/home/site" 
6	 
7	[/static] 
8	static_filter.on = True 
9	static_filter.dir = "static" 


Many of the values are self explanatory (for example, server.socket_port, which allows changing the default port at which CherryPy listens); others need a better understanding of CherryPy internals.

  • The server.thread_pool option determines how many threads CherryPy starts to serve requests.
  • The static_filter.root statement specifies the directory from which the static files are served.
  • The [/static] statement specifies that static content from /home/site/static/* is served as /static/*
  • The session_filter.on statement enables the session functionality. Sessions are necessary to implement complex Web applications, with user identification, for example.

The configuration file name can be passed as an argument to the start method; the values will be read right before the server is started:

1	cherrypy.config.update(file="myserver.conf") 
2	cherrypy.server.start() 

The configuration settings can also be defined as a pure Python dictionnary and then pass to the cherrypy.config.update directly. cherrypy.server.start

The definition of cherrypy.server.start() is:

1	def start(self, init_only=False, server_class=_missing): 
2	    """
3	        Main function. All it does is this:
4	            - read/parse config file if any
5	            - create response and request objects
6	
7	            - start HTTP server
8	    """


To change the application's configuration you can also pass a dictionary as a keyword parameter to cherrypy.config.update() like:

1	cherrypy.config.update({ 
2	        'global': { 
3	            'server.socket_port' : 8888, 
4	            'server.thread_pool' : 10 }}) 

The cherrypy structure

Most of the features of CherryPy are available through the cherrypy module. It contains several members:

  • As mentioned before, cherrypy.root is the published object tree; the object at cherrypy.root is the root for the website, and the objects it contains form the application tree.
  • cherrypy.server contains the API to control the server.
  • cherrypy.request contains the all the information that comes with the HTTP request, after it is parsed and analyzed by CherryPy.
    • cherrypy.request.headers contains a mapping with the header options that were sent as part of the request.
    • cherrypy.session is a special mapping that is automatically generated and encoded by CherryPy; it can be used to store session-data in a persistent cookie. For it to work you have to enable the session functionality by setting session_filter.on to True in your config.
  • cherrypy.response contains the data that is used to build the HTTP response.
    • cherrypy.response.headers contains a mapping with the header options that will be returned by the server, before the contents get sent.
    • cherrypy.response.body contains the actual contents of the webpage that will be sent as a response.

Filtros

El código de CherryPy es extremadamente ligero y limpio. Sólo contiene las características necesarias para apoyar el protocolo HTTP y para llamar al objeto correcto para cada solicitud. Las características adicionales se pueden agregar con el uso de filtros modulares. 

Un filtro es un objeto que tiene la oportunidad de trabajar en una petición, ya que se encuentra en en el flujo de procesamiento de CherryPy. Se encuentran varios filtros como parte de la biblioteca estándar de CherryPy, en cherrypy.lib.filter. Algunos ejemplos son: 


  • DecodingFilter: gestiona automáticamente los datos Unicode de cada solicitud, convirtiendo las cadenas de entrada que son enviadas por el navegador en cadenas nativas de Python.
  • EncodingFilter: convierte automáticamente la respuesta desde el formato de cadena Unicode nativo de Python  a la codificación adecuada (Latin-1 o UTF-8, por ejemplo).
  • GzipFilter: Comprime el contenido sobre la marcha, usando el formato gzip. Ahorra ancho de banda.
  • XmlRpcFilter: Implementa un XML-RPC especial a través de la capa de adaptación del estándar CherryPy. Se ocupa de la traducción de los datos a petición y la respuesta (un proceso llamado "de clasificación").

Los filtros proporcionan una gran flexibilidad. La lista de filtros? se puede configurar para cualquier parte del sitio. Diferentes filtros se pueden aplicar a diferentes partes del sitio, y el orden de los filtros se pueden cambiar. El usuario puede incluir filtros personalizados para aplicaciones especiales, cambiar el comportamiento de CherryPy sin la necesidad de cambiar sus componentes internos.

La lista de filtros para cualquier parte del sitio se puede configurar en la configuración del servidor de archivos: 


encoding_filter.on = True gzip_filter.on = True

Aquí estamos indicando que la aplicación puede utilizar cadenas Unicode de los contenidos que genera; la traducción a utf8 se hará automáticamente. Además, todos los contenidos serán automáticamente comprimidos con gzip, ahorrando ancho de banda.

Conclusión

Este tutorial sólo cubre lo básico de CherryPy, pero trata de presentarlo en una forma que sea fácil para el usuario, descubrir como usarlo. La distribución de CherryPy viene con muchos tutoriales buenos, sin embargo la mejor manera de dominar CherryPy es usándolo para escribir tu propia aplicación Web. El servidor web embebido hace más fácil para cualquiera no sólo probar, sino también desplegar las aplicaciones locales, o sitios pequeños para Internet. Pruébalo, y háznos saber como te llevaste con él!

Also on Fandom

Random wikia