A veces cuando estamos haciendo un programa nos interesa que nuestro código pueda ser extendido sin tener que tocar su estructura; incluso lo que nos puede interesar es que este código sea extendido en algunas ocasiones y en otras no. Otro requisito que podemos tener también sería que quien lo extienda no seamos nosotros. A menudo todo esto y mucho más se suele hacer con lo que llamamos Plug-ins; por cierto, siempre me ha hecho mucha gracia la traducción al catalán de la palabra: 'afegitons'.
Pues bien, como yo de programación no entiendo mucho le pedí a Pau que me ayudara a entender los modelos de plug-ins que implementaban algunos programas hechos con Python, ya que me interesaba integrar esta funcionalidad en una serie de códigos que estoy desarrollando. En este post intentaré explicar cómo funciona el paradigma de los plug-ins que usa Trac.
Primero de todo hay que tener en cuenta que Trac usa un patrón de despliegue de objetos llamado Singleton, o sea que todas las instancias de un objeto se refieren a la misma instancia. De hecho, no sé decir hasta qué punto es necesario que el código siga este patrón para usar el sistema de plug-ins; aunque yo diría que al menos las partes del código que quieran ser extendidas por el modelo de plug-ins de Trac lo tienen que seguir.
Los plug-ins de Trac tienen las siguientes características:
-
Un Plug-in es un componente que extiende la funcionalidad de otro componente
-
Un Plug-in puede extender otro Plug-in
Para incorporar la filosofía que tiene Trac para soportar Plug-ins en nuestro código hay que importar el componente 'trac.core', de este componente usaremos lo siguiente:
-
trac.core.Interface (clase) se usa para definir cuál es el contrato que tendrán que seguir los plug-ins.
-
trac.core.ExtensionPoint (función) cuando queremos que un componente sea extendido usará esta función para recuperar las implementaciones del contrato. Define los puntos de hook que tiene nuestro código.
-
trac.core.implements (función) cuando un componente usa esta función es para implementar un contrato, o sea, que los plug-ins que se construyan lo tienen que usar.
Antes de seguir explicaré qué se entiende por contrato. Un contrato es en esencia una clase de tipo interfaz (python no tiene este modelo como tal) que define qué métodos (u otras clases) pueden ser extendidos dentro del componente original. O sea, que hay que no solo definir cuál es el contrato que se ofrece sino también documentarlo lo mejor posible, explicando cuáles son las entradas y salidas que se esperan de cada uno de los métodos/clases.
Para que todo esto se entienda mejor Pau me puso el siguiente ejemplo:
Imaginemos que tenemos una clase del tipo DNI que implementa una base de datos de DNIs, donde tiene un método que nos permite introducir DNIs en la base de datos:
class DNI(trac.core.Component):
dni_checks = trac.core.ExtensionPoint(IDNIInput)
def __init__(self):
self._dnis = []
def add(self, dni):
assert not dni in self._dnis, "DNI ja existeix"for dni_check in self.dni_checks:
if dni_check.check(dni) is False:
print "El dni %s sembla no ser correcte" % ( dni )
return
self._dnis.append(dni)
def llista(self):
print self._dnis
Hay que fijarse en que la línea:
dni_checks = trac.core.ExtensionPoint(IDNIInput)
lo que hace es cargar los plug-ins que extienden la funcionalidad del código original. Además hay que fijarse en que el parámetro que usa la función es la clase que define el contrato sobre el que se hacen los plug-ins:
class IDNIInput(trac.core.Interface):
def check(dni):
""" Es cridada cada cop que s'entra un nou dni, espera que es retorni un valor boleà"""
Como se puede ver el contrato solo define un método: 'check' que tiene que tener un parámetro de entrada y espera un valor booleano de salida.
Hay que fijarse en que la clase DNI cada vez que añada un elemento a la base de datos (en este caso una simple lista), llamará a todos los plug-ins que cumplan el contrato por el orden en que se han instanciado (se han importado en el código original) mediante el siguiente código.
for dni_check in self.dni_checks:
if dni_check.check(dni) is False:
print "El dni %s sembla no ser correcte" % ( dni )
return
Un ejemplo de plug-in sobre el código anterior y que cumple el contrato especificado podría ser este:
import trac.core
import dni
class ValidDNI(trac.core.Component):
trac.core.implements(dni.IDNIInput)
def check(self, dni):
if type(dni) is not type("str"):
return False
if len(dni) != 9:
return False
return True
Se puede ver cómo la clase es una instancia de 'trac.core.Component' (modelo Singleton) e implementa la interfaz 'dni.IDNIInput'. A nivel funcional lo que se hace es bien simple, comprobamos que sea una cadena de texto y que tenga un tamaño de 9 caracteres, si eso se da retorna un 'True' o si no un 'False'.
Un ejemplo de cómo quedaría el código principal sería:
import trac.core
class IDNIInput(trac.core.Interface):
def check(nom):
""" Es cridada cada cop que s'entra un nou dni"""
class DNI(trac.core.Component):
dni_checks = trac.core.ExtensionPoint(IDNIInput)
def __init__(self):
self._dnis = []
def add(self, dni):
assert not dni in self._dnis, "DNI ja existeix"
for dni_check in self.dni_checks:
if dni_check.check(dni) is False:
print "El dni %s sembla no ser correcte" % ( dni )
return
self._dnis.append(dni)
def llista(self):
print self._dnis
Ejemplos de uso:
>>> import trac.core
>>> from dni import DNI
>>>
>>> dni_bd = DNI(comp_mgr)
>>> dni_bd.add("38135009C")
>>> dni_bd.add("38135009")
>>> dni_bd.llista()
['38135009C', '38135009']
# importem el plug-in check_dni
>>> import check_dni
>>> dni_bd.add("11111111")
El dni 11111111 sembla no ser correcte
>>> dni_bd.add("11111111A")
>>> dni_bd.llista()
['38135009C', '38135009', '11111111A']
Definimos el código 'log_dni' que será otro plug-in:
import trac.core
import dni
class LogDNI(trac.core.Component):
trac.core.implements(dni.IDNIInput)
def check(self, dni):
print "Nou dni entrat %s" % (dni)
Seguimos con el ejemplo anterior:
# importem ara el plug-in 'log_dni'
>>> import log_dni
>>> dni_bd.add("22222222B")
Nou dni entrat 22222222B
A estas alturas ya se han cargado dos plug-ins que trabajan uno después del otro y se ha podido apreciar la simplicidad y potencia del modelo. Obviamente se pueden echar cosas en falta como por ejemplo algún elemento que defina el listado de plug-ins disponibles y que permita alterar el orden en que estos se ejecutan pero eso ya se debería desarrollar aparte.
Espero haberlo descrito de forma comprensible y siendo lo más fiel posible a las explicaciones de Pau, al que tengo que agradecerle el esfuerzo y dedicación para explicarme este modelo de Plug-ins de Python.
- Paquete con ejemplos: plugins.tar
1 comentario
Los comentarios del blog antiguo, tal como se escribieron. Los comentarios están cerrados.
pau
Tot un paler, sort que tu mantens el blog viu !!! no com altres :P