Mente Leal

Desactivar actualización de un plugin en Wordpress

noreply@blogger.com (Anonymous) — Wed, 06 Jan 2016 15:27:00 +0000

Vamos a "Plugins - Plugins instalados", hacemos clic en editar.

Al principio del código ponemos:

Código PHP:
?php/**
* @package admin_flush_w3tc
* @version 1.2
*/
/*
Plugin Name: Admin Flush W3TC Cache

Cambiamos la linea donde esta la versión por algo más alto como * @version 999

Instalar sublime text en chakra y en otros linux

noreply@blogger.com (Anonymous) — Thu, 24 Apr 2014 15:28:00 +0000

Primero debemos bajarnos el archivo tar.bz2 de http://www.sublimetext.com/ .

Luego debemos descomprimirlo:

Para 32bit:

tar -jxvf Sublime\ Text\ 2\ 2.0.1.tar.bz2

Para 64bits:

tar -jxvf Sublime\ Text\ 2\ 2.0.1\ x64.tar.bz2

Luego aplicar los siguientes comandos:

sudo mv Sublime\ Text\ 2 sublime
sudo mv sublime /opt/ cd /opt
sudo chown -R root:root sublime
sudo chmod -R +r sublime

Ahora tenemos que crear los ejecutables:

sudo touch /usr/bin/sublime_text
sudo chmod 775 /usr/bin/sublime_text

Tenemos que editar algunos archivos:

sudo nano /usr/bin/sublime_text

y le agregamos lo siguiente:

#!/bin/sh
#export MOZILLA_FIVE_HOME="/usr/lib/mozilla/"
export SUBLIME_HOME="/opt/sublime"
$SUBLIME_HOME/sublime_text "$*

grabamos con Ctrl + o y cerramos con Ctrl + x.

Editamos este otro archivo:

sudo nano /usr/share/applications/sublime.desktop

y le agregamos el siguiente contenido:

[Desktop Entry]
Encoding=UTF-8
Name=Sublime Text
Comment=Sublime Text 2
Exec=sublime_text
Icon=/opt/sublime/Icon/256x256/sublime_text.png
Terminal=false
Type=Application
Categories=GNOME;GTK;Utility;TextEditor;
StartupNotify=true

De igual forma, lo grabamos y cerramos. Ya podemos visualizarlo en nuestro lanzador. En el caso de chakra se encontrará en Utilidades.

ReportLab: Gráficos (16)

noreply@blogger.com (Anonymous) — Wed, 19 Feb 2014 22:57:00 +0000

Está es la última parte de ReportLab, y pueden usarlo, como muchos, con Django. Yo lo uso más en aplicaciones de escritorio, pero donde este Python, ReportLab es una manera fácil de trabajar con pdf.

Por si necesitan alguna función bastante rebuscada, pueden acceder al REFERENCE de ReportLab.

Bien, en cuanto a gráficos, podemos decir que es un subpaquete de ReportLab integrado a este, veamos como se trabaja con ellos:

# -*- coding:utf-8 -*-
import os

from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer, PageBreak
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.pagesizes import A4
from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY
from reportlab.lib import colors
from reportlab.lib.units import inch

from reportlab.graphics.shapes import Drawing, Rect, String, Group, Line
from reportlab.graphics.widgets.markers import makeMarker


doc = SimpleDocTemplate('test.pdf', pagesize=A4)
story = []
estilo = getSampleStyleSheet()

#EJEMPLO 01: Dibujando alguna forma y texto
#==========
d = Drawing(400, 200)

r =(Rect(50, 50, 300, 100, fillColor=colors.yellow))
r.strokeColor = colors.red  # otra forma de agregar propiedades
r.strokeWidth = 3
d.add(r)

d.add(String(150,100, 'Hola mundo', fontSize=18, fillColor=colors.red))
d.add(String(180,86, 'Caracteres especiales: \
             \xc2\xa2\xc2\xa9\xc2\xae\xc2\xa3\xce\xb1\xce\xb2',
             fillColor=colors.red))
story.append(d)
#Entre las distintas formas tenemos: Rect, Circle, Ellipse, Wedge, Polygon,
#Line, PolyLine, String, Group, 


#EJEMPLO 02: Obteniendo propiedades
#==========
#Esto es un buena forma de saber las propiedades de los elementos que usemos,
#usaremos pprint que nos lo mostrará en el shell
import pprint
r = Rect(0, 0, 200, 100)
pprint.pprint(r.getProperties())

#EJEMPLO 03: Label
#==========
from reportlab.graphics.charts.textlabels import Label

d = Drawing(200, 100)
lab = Label()
lab.setOrigin(100,90)
lab.angle = 45
lab.dx = 0  # desplazamiento en x
lab.dy = -20  # desplazamiento en y
lab.boxStrokeColor = colors.green
lab.setText('Un \nLabel \nMulti-Linea')
d.add(lab)
pprint.pprint(lab.getProperties())  # tiene muchas más propiedades
story.append(d)

#EJEMPLO 04: Ejes
#===========
#Nota: Aquí los datos aún no se muestran
from reportlab.graphics.charts.axes import XCategoryAxis,YValueAxis
d = Drawing(400, 200)
data = [(10, 20, 30, 40), (15, 22, 37, 42)]

xAxis = XCategoryAxis()
xAxis.setPosition(75, 75, 300)  # x, y, ancho
xAxis.configure(data)
xAxis.categoryNames = ['Oso', 'Tigre', 'León', 'Camaleón']
xAxis.labels[2].dy = -15
xAxis.labels[2].angle = 30
xAxis.labels[2].fontName = 'Times-Bold'

yAxis = YValueAxis()
yAxis.setPosition(50, 80, 125)
yAxis.configure(data)
d.add(xAxis)
d.add(yAxis)

story.append(d)
story.append(PageBreak())

#EJEMPLO 05: Gráfico de Barras
#===========
from reportlab.graphics.charts.barcharts import VerticalBarChart

d = Drawing(400, 200)
data = [
        (13, 5, 20, 22, 37, 45, 19, 4),
        (14, 6, 21, 23, 38, 46, 20, 5)
        ]
bc = VerticalBarChart()
bc.x = 50
bc.y = 50
bc.height = 125
bc.width = 300
bc.data = data
bc.strokeColor = colors.black
bc.valueAxis.valueMin = 0
bc.valueAxis.valueMax = 50
bc.valueAxis.valueStep = 10  #paso de distancia entre punto y punto
bc.categoryAxis.labels.boxAnchor = 'ne'
bc.categoryAxis.labels.dx = 8
bc.categoryAxis.labels.dy = -2
bc.categoryAxis.labels.angle = 30
bc.categoryAxis.categoryNames = ['Ene-14','Feb-14','Mar-14',
       'Abr-14','May-14','Jun-14','Jul-14','Ago-14']
bc.groupSpacing = 10
bc.barSpacing = 2
#bc.categoryAxis.style = 'stacked'  # Una variación del gráfico
d.add(bc)
pprint.pprint(bc.getProperties())
story.append(d)

#EJEMPLO 06: Gráfico linear
#==========
from reportlab.graphics.charts.linecharts import HorizontalLineChart

titulo = Paragraph("Calificaciones Informática", estilo['title'])
story.append(titulo)
story.append(Spacer(0, inch*.1))

d = Drawing(400, 200)
lc = HorizontalLineChart()
lc.x = 30
lc.y = 50
lc.height = 125
lc.width = 350
lc.data = [[8,10,5,2]]
lc.categoryAxis.categoryNames = ['Suspenso', 'Aprobado', 'Notable', 
                                'Sobresaliente']
lc.categoryAxis.labels.boxAnchor = 'n'
lc.valueAxis.valueMin = 0
lc.valueAxis.valueMax = 12
lc.valueAxis.valueStep = 2  # Los pasos pueden ser tambien [10, 15, 30, 35, 40]
lc.lines[0].strokeWidth = 2
lc.lines[0].symbol = makeMarker('FilledCircle') # círculos rellenos
lc.lines[1].strokeWidth = 1.5
d.add(lc)
story.append(d)

#EJEMPLO 07: Trazos lineales
#==========
from reportlab.graphics.charts.lineplots import LinePlot

d = Drawing(400, 200)
data = [
    ((1,1), (2,2), (2.5,1), (3,3), (4,6)),
    ((1,2), (2,3), (2.5,2), (3.5,5), (4,3))
]
lp = LinePlot()
lp.x = 50
lp.y = 50
lp.height = 125
lp.width = 300
lp.data = data
lp.joinedLines = 1
lp.fillColor = colors.yellow
lp.lines[0].symbol = makeMarker('FilledCircle')
lp.lines[1].symbol = makeMarker('Circle')
lp.lineLabelFormat = '%2.0f'
lp.strokeColor = colors.black
lp.xValueAxis.valueMin = 0
lp.xValueAxis.valueMax = 5
lp.xValueAxis.valueSteps = [1, 2, 2.5, 3, 4, 5]
lp.xValueAxis.labelTextFormat = '%2.1f'
lp.yValueAxis.valueMin = 0
lp.yValueAxis.valueMax = 7
lp.yValueAxis.valueSteps = [1, 2, 3, 5, 6]


#Veamos como se inserta las leyendas. En este caso usaremos el LineLegend,
#que son leyendas en linea.
from reportlab.graphics.charts.legends import LineLegend

legend = LineLegend()
legend.fontSize = 8
legend.alignment = 'right'
legend.x = 0
legend.y = 0
legend.columnMaximum = 2
legend.fontName  = 'Helvetica'

#Definimos nuestras etiquetas  y usamos los colores del propio gráfico.
etiquetas  = ['Opcion 01', 'Opcion 02']
legend.colorNamePairs  = [(lp.lines[i].strokeColor, etiquetas[i]) 
                            for i in xrange(len(lp.data))]

d.add(lp)
d.add(legend)
story.append(d)


#EJEMPLO 08: Gráficos Circulares
#==========
from reportlab.graphics.charts.piecharts import Pie

d = Drawing(300, 200)
pc = Pie()
pc.x = 65
pc.y = 15
pc.width = 170
pc.height = 170
pc.data = [10,20,30,40,50]
pc.labels = ['IE','Kopete','Chrome','Firefox','Opera']

pc.slices.strokeWidth=0.5
pc.slices[3].popout = 10
pc.slices[3].strokeWidth = 2
pc.slices[3].strokeDashArray = [2,2]
pc.slices[3].labelRadius = 1.75
pc.slices[3].fontColor = colors.red
pc.sideLabels = 1  # Con 0 no se muestran líneas hacia las etiquetas
#~ pc.slices.labelRadius = 0.65  # Para mostrar el texto dentro de las tajadas

#Insertamos la legenda

from reportlab.graphics.charts.legends import Legend
legend = Legend() 
legend.x               = 370 
legend.y               = 0 
legend.dx              = 8  
legend.dy              = 8  
legend.fontName        = 'Helvetica'  
legend.fontSize        = 7  
legend.boxAnchor       = 'n'  
legend.columnMaximum   = 10  
legend.strokeWidth     = 1  
legend.strokeColor     = colors.black  
legend.deltax          = 75  
legend.deltay          = 10  
legend.autoXPadding    = 5  
legend.yGap            = 0  
legend.dxTextSpace     = 5  
legend.alignment       = 'right'  
legend.dividerLines    = 1|2|4  
legend.dividerOffsY    = 4.5  
legend.subCols.rpad    = 30  

#Insertemos nuestros propios colores
colores  = [colors.blue, colors.red, colors.green, colors.yellow, colors.pink]
for i, color in enumerate(colores): 
    pc.slices[i].fillColor = color
    
legend.colorNamePairs  = [(
                            pc.slices[i].fillColor, 
                            (pc.labels[i][0:20], '%0.2f' % pc.data[i])
                           ) for i in xrange(len(pc.data))]

d.add(pc) 
d.add(legend)
story.append(d)

#EJEMPLO 09: Usando Grupo
#==========
d = Drawing(400, 200)
Ejes = Group(
    Line(0,0,100,0),  # eje x
    Line(0,0,0,50),   # eje y
    Line(0,10,10,10), # Marcas en el eje y
    Line(0,20,10,20),
    Line(0,30,10,30),
    Line(0,40,10,40),
    Line(10,0,10,10), # Marcas en el eje x
    Line(20,0,20,10),
    Line(30,0,30,10),
    Line(40,0,40,10),
    Line(50,0,50,10),
    Line(60,0,60,10),
    Line(70,0,70,10),
    Line(80,0,80,10),
    Line(90,0,90,10),
    String(20, 35, 'Ejes', fill=colors.black)
    )

PrimerGrupoEjes = Group(Ejes)
PrimerGrupoEjes.translate(10,10)
d.add(PrimerGrupoEjes)

SegundoGrupoEjes = Group(Ejes)
SegundoGrupoEjes.translate(150,10)
SegundoGrupoEjes.rotate(15)
d.add(SegundoGrupoEjes)

TercerGrupoEjes = Group(Ejes)
TercerGrupoEjes.translate(300,10)
TercerGrupoEjes.rotate(30)
d.add(TercerGrupoEjes)

story.append(d)

doc.build(story)
os.system('test.pdf')

ReportLab: Platypus - Sobre las tablas (15)

noreply@blogger.com (Anonymous) — Tue, 18 Feb 2014 22:43:00 +0000

Las tablas trabajan con un mecanismo de grilla, se ajustan al contenido. Entre sus argumentos principales tenemos:

Table(data, colWidths=None, rowHeights=None, style=None)

La data debe ser texto, instancias de Flowables, una lista o una tupla. colWidths es el ancho de las columnas, asi como el alto sería rowHeights. Para poner los estilos se puede usar el método setStyle. Además tenemos TableSyle, como veremos su uso en el ejemplo, pero sea cuál sea el método que usemos, los argumentos disponibles son:

FONT
FONTNAME or FACE
FONTSIZE or SIZE
LEADING
TEXTCOLOR
ALIGN or ALIGNMENT
LEFTPADDING
RIGHTPADDING
BOTTOMPADDING
TOPPADDING
BACKGROUND
ROWBACKGROUNDS Son una lista de colores ciclico por ejemplo: (color1, color2)
COLBACKGROUNDS
VALIGN Puede ser TOP, MIDDLE o BOTTOM
INNERGRID Linea dentro del grid
BOX Lineas alrededor del grid
GRID Combinación de box e innergrid
LINEBELOW Linea arriba
LINEABOVE Linea abajo
LINEBEFORE Línea antes Ej: ('LINEBEFORE',(2,1),(2,-2),1,colors.pink)
LINEAFTER Línea posterior
SPAN Combinar celdas

Veamos el ejemplo, en el que mostramos las distintas propiedas, incluyendo combinación de celdas e insersión de párrafos e imágenes.

import os
#Librerias reportlab a usar:
from reportlab.platypus import (SimpleDocTemplate, PageBreak, Image, Spacer,
Paragraph, Table, TableStyle)
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.pagesizes import A4
from reportlab.lib import colors

doc = SimpleDocTemplate("test.pdf", pagesize = A4)
story=[]

#Ejemplo 01
t = Table([
        ['', 'Ventas', 'Compras'], 
        ['Enero', 1000, 2000], 
        ['Febrero', 3000, 100.5],
        ['Marzo', 2000, 1000],
        ['Abril', 1500, 1500]
    ], colWidths=80, rowHeights=30)
t.setStyle([
        ('TEXTCOLOR', (0, 1), (0, -1), colors.blue),
        ('TEXTCOLOR', (1, 1), (2, -1), colors.green),
        ('BACKGROUND',(1,1),(-1,-1),colors.cyan),
        ('BOX',(1,1),(-1,-1),1.25,colors.yellow),
        ('INNERGRID',(1,1),(-1,-1),1,colors.red),
        ('VALIGN', (0,0), (-1, -1), 'MIDDLE'),
    ])
story.append(t)
story.append(Spacer(0,15))

#Ejemplo02
datos = (
        ('Nombre ciclo', 'Núm. Alumnos', 'Núm aprobados'),
        ('Desarrollo Aplic. Informáticas', 15, 5),
        ('Admin. Sist. Informáticos', 40, 25),
        ('Explotación Sist. Informáticos', 50, 20)
    )
tabla = Table(data = datos,
              style = [
                       ('GRID',(0,0),(-1,-1),0.5,colors.grey),
                       ('BOX',(0,0),(-1,-1),2,colors.black),
                       ('BACKGROUND', (0, 0), (-1, 0), colors.pink),
                       ]
              )
story.append(tabla)
story.append(Spacer(0,15))

#Ejemplo 03
estiloTabla = TableStyle([
     ('LINEABOVE', (0,0), (-1, 0), 2, colors.green),
     ('ALIGN', (1,1), (-1, -1), 'RIGHT'),
     ('ROWBACKGROUNDS', (0,0), (-1, -1), (colors.yellow, None)),
     
    ])
estiloTabla.add('BACKGROUND', (0,0), (-1,0), colors.Color(0, 0.7, 0.7))
t = Table([
        ['', 'Ventas', 'Compras'], 
        ['Enero', 1000, 2000], 
        ['Febrero', 3000, 100.5],
        ['Marzo', 2000, 1000],
        ['Abril', 1500, 1500]
    ], style = estiloTabla)

#Ejemplo 04: CELDAS COMPLEJAS
estilo = getSampleStyleSheet()
I = Image('tuxTemplario.png', width=100, height=100)

P1 = Paragraph('''El tux templario''', estilo["BodyText"])
P2 = Paragraph('''Viva Linux''', estilo["BodyText"])

t = Table(
    data=[
        ['A',   'B', 'C',     P1, 'D'],
        ['00', '01', '02', [I,P2], '04'],
        ['10', '11', '12', '13', '14'],
        ['20', '21', '22',  '23', '24'],
        ['30', '31', '32',  '33', '34']
    ],
    style=[
        ('GRID',(1,1),(-2,-2),1,colors.green),
        ('BOX',(0,0),(1,-1),2,colors.red),
        ('LINEABOVE',(1,2),(-2,2),1,colors.blue),
        ('LINEBEFORE',(2,1),(2,-2),1,colors.pink),
        ('BACKGROUND', (0, 0), (0, 1), colors.pink),
        ('BACKGROUND', (1, 1), (1, 2), colors.lavender),
        ('BACKGROUND', (2, 2), (2, 3), colors.orange),
        ('BOX',(0,0),(-1,-1),2,colors.black),
        ('GRID',(0,0),(-1,-1),0.5,colors.black),
        ('VALIGN',(3,0),(3,0),'BOTTOM'),
        ('BACKGROUND',(3,0),(3,0),colors.limegreen),
        ('BACKGROUND',(3,1),(3,1),colors.khaki),
        ('ALIGN',(3,1),(3,1),'CENTER'),
        ('BACKGROUND',(3,2),(3,2),colors.beige),
        ('ALIGN',(3,2),(3,2),'LEFT'),
    ]
)
story.append(t)

#Ejemplo 05: Combinación de celdas

t=Table(
    data=[
        ['Arriba\nIzquierda', '', '02', '03', '04'],
        ['', '', '12', '13', '14'],
        ['20', '21', '22', 'Abajo\nDerecha', ''],
        ['30', '31', '32', '', '']
    ],
    style=[
        ('GRID',(0,0),(-1,-1),0.5,colors.grey),
        ('BACKGROUND',(0,0),(1,1),colors.palegreen),
        ('SPAN',(0,0),(1,1)),
        ('BACKGROUND',(-2,-2),(-1,-1), colors.pink),
        ('SPAN',(-2,-2),(-1,-1)),
    ])
story.append(Spacer(0, 10))
story.append(t)

doc.build(story)
os.system("test.pdf")

ReportLab: Platypus - Sobre los párrafos (14)

noreply@blogger.com (Anonymous) — Mon, 17 Feb 2014 23:35:00 +0000

Paragraph(text, style, bulletText=None)

Evidentemente text es el texto a escribir. Algo importante y a destacar es que permite el uso de texto Python entre las triples comillas simples (''' y '''). bulletText provee al texto un punto y aparte por defecto para el párrafo. El tipo de letra y otras propiedades del texto se configuran en el argumento style, que es una instancia de la clase ParagraphStyle, y que pueden obtenerse y usarse de la siguiente forma:

from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
estilo=getSampleStyleSheet()
estilo.add(ParagraphStyle(name = "ejemplo",  alignment=TA_CENTER, fontSize=20,
           fontName="Helvetica-BoldOblique"))

Los argumentos principales de la clase ParagraphStyle son:

class ParagraphStyle(PropertySet):
defaults = {
'fontName':'Times-Roman', # Nombre de la fuente
'fontSize':10, # Tamaño de fuente
'leading':12, # Espaciado entre lineas
'leftIndent':0, # Identación a la izquierda
'rightIndent':0, # Identación a la derecha
'firstLineIndent':0, # Primera linea identada
'alignment':TA_LEFT, # Alineación
'spaceBefore':0, # Espacio antes del párrafo (excepto en el top de un frame)
'spaceAfter':0, # Espacio después del párrafo (excepto en botton de un frame)
'textColor': black, # Color de Texto
'backColor':None, # Color de fondo
'borderWidth': 0, # Ancho de borde
'borderPadding': 0, # Padding desde el borde
'borderColor': None, # Color de Borde
'borderRadius': None, # Radio de las intersecciones del borde
'bulletFontName':'Symbol', # Nombre de la Fuente de la viñeta
'bulletFontSize':10, # Tamaño de la viñeta
'bulletIndent':0, # Identación de la viñeta
}

Veamos un ejemplo en el que se muestra el uso de los atributos de párrafo, así como manejo de etiquetas de marcado XML, inserción de lista númeradas, plantillas de enumeración, viñetas y más. Para ello, puedes descargar el ejemplo.

ReportLab: Platypus - Canvas como Flowable, ejemplo resumen (13)

noreply@blogger.com (Anonymous) — Mon, 17 Feb 2014 16:59:00 +0000

En la entrada anterior, vimos como trabajan los niveles de platypus, sin embargo no se vio el paso directo entre el nivel 1 (canvas) y el nivel 2 (flowables), ya que los dibujos creados en el nivel 1 fueron del tipo No-Flowables, usados como pie de página y encabezado.

En este ejemplo veremos el uso de la clase Flowable, en la que heredaremos sus atributos y crear nosotros nuestros propios dibujos con canvas:

#-*- coding:utf-8 -*-
import os

#Librerias reportlab a usar:
from reportlab.platypus import (BaseDocTemplate, PageTemplate, 
NextPageTemplate, PageBreak, Frame, FrameBreak, Flowable, Paragraph, 
Image, Spacer)
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY
from reportlab.lib.pagesizes import A4, landscape
from reportlab.lib.units import inch

#CREAMOS EL DOCTEMPLATE
#======================
doc = BaseDocTemplate('test.pdf', pagesize=A4) #landscape(A4) para Horizontal

#CREAMOS LOS CANVAS
#==================
def encabezado(canvas,doc):
    canvas.saveState()
    canvas.setFont('Times-Roman', 9)
    canvas.drawString(inch, A4[1] - 50, "Ejemplo de DocTemplate y PageTemplate")
    canvas.line(inch, A4[1] - 60, A4[0] - 65, A4[1] - 60)
    canvas.restoreState()
    
def piePagina(canvas,doc):
    canvas.saveState()
    canvas.setFont('Times-Roman',9)
    canvas.drawString(inch, 0.75 * inch, "Página %d" % doc.page)
    canvas.restoreState()
    
#Creamos nuestro flowable. Se tiene que tener al menos un método wrap y draw    
class Rectangulo(Flowable):
    def __init__(self, ancho=206, alto=100):
        self.ancho = ancho
        self.alto = alto
    
    def wrap(self, *args):
        """Provee el tamaño del área de dibujo"""
        return (self.ancho, self.alto)

    def draw(self):
        canvas = self.canv  # El atributo que permite dibujar en canvas
        canvas.saveState()
        canvas.setLineWidth(1)
        canvas.rect(0, 0, self.ancho, self.alto, fill=0)
        canvas.restoreState()

#Modifiquemos un flowable existente
class RotarImagen(Image):
    def wrap(self, availWidth, availHeight):
        self.w, self.h = Image.wrap(self, availWidth, availHeight)
        return self.w, self.h

    def draw(self):
        self.canv.translate(0,self.h)
        self.canv.rotate(-90)
        Image.draw(self)

#CREAMOS LOS FRAMES
#==================
#Frame (x1, y1, ancho, alto, leftPadding=6, bottomPadding=6, rightPadding=6,
#topPadding=6, id=None, showBoundary=0)

frame0 = Frame(doc.leftMargin, doc.bottomMargin, 
                doc.width, doc.height, showBoundary=1, id='normalBorde')
frame1 = Frame(doc.leftMargin, doc.bottomMargin, 
                doc.width, doc.height / 2, id='capitulo')
frame2 = Frame(doc.leftMargin, doc.bottomMargin, 
                doc.width /2 - 6, doc.height, id='col1')
frame3 = Frame(doc.leftMargin + doc.width / 2 + 6, doc.bottomMargin, 
                doc.width / 2 - 6, doc.height, id='col2')

#CREAMOS LOS PAGETEMPLATE
#========================
#PageTemplate(id=None,frames=[],onPage=_doNothing,onPageEnd=_doNothing)

doc.addPageTemplates([
    PageTemplate(id='caratula', frames=frame0),
    PageTemplate(id='capitulos', frames=frame1),
    PageTemplate(id='contenido', frames=[frame2, frame3], 
                 onPage = encabezado, onPageEnd=piePagina),
                    ])

#CREAMOS LOS FLOWABLES
#=====================
#Creamos la hoja de Estilo
estilo=getSampleStyleSheet()
estilo.add(ParagraphStyle(name = "Titulo",  alignment=TA_CENTER, fontSize=20,
           fontName="Helvetica-BoldOblique"))
           
#Iniciamos el platypus story
story=[]

#Creamos la carátula:
story.append(Spacer(0,200))
story.append(Image("Tux2.png", width=150, height=200))
story.append(Spacer(0,20))
titulo = Paragraph("Ejemplo PageTemplate-DocTemplate", estilo['Titulo'])
story.append(titulo)

#Creamos el contenido en general
story.append(NextPageTemplate('capitulos'))
story.append(PageBreak())
story.append(Paragraph("Capítulo I: Conociendo ReportLab", estilo['Heading1']))
  
story.append(NextPageTemplate('contenido'))
story.append(PageBreak())
story.append(Paragraph("Contenido del Capítulo I. " * 300, estilo['Normal']))
                
story.append(NextPageTemplate('capitulos'))
story.append(PageBreak())
story.append(Paragraph("Capítulo II: Sobre Platypus", estilo['Heading1']))

story.append(NextPageTemplate('contenido'))
story.append(PageBreak())
story.append(Paragraph("Contenido de la columna I ", estilo['Title']))
story.append(Paragraph("Lorem ipsum "*140, estilo['BodyText']))
story.append(FrameBreak()) #Se mueve al siguiente frame del pagetemplate
story.append(Paragraph("Contenido de la columna II", estilo['Title']))
story.append(Paragraph("Domine Sanctus "*50, estilo['BodyText']))
story.append(Paragraph("Veamos un rectángulo:", estilo['BodyText']))
story.append(Rectangulo())
story.append(Paragraph("Veamos un cuadrado:", estilo['BodyText']))
story.append(Rectangulo(50, 50))

I = RotarImagen("tuxito.png")
I.hAlign = "CENTER"
story.append(I)
                      
#CONSTRUIMOS EL PDF
#==================
doc.build(story)

os.system("test.pdf")

ReportLab: Platypus - PageTemplate y DocTemplate (12)

noreply@blogger.com (Anonymous) — Sat, 15 Feb 2014 17:57:00 +0000

Los niveles más altos en platypus son los PageTemplates y DocTemplates. Los DocTemplates están formados por un conjunto de PageTemplates.

Los DocTemplates son expresado a trávez de BaseDocTemplate, que es una clase que implementa la maquinaria básica para el formateo del documento. Posee un método build que procesa una lista de Flowables (obviamente, estos almacenados en los frames, y los frames en los pagetemplates) y un método addPageTemplates que agrega los pagetemplates. De esta forma se llega a producir el documento PDF a alto nivel.

Los argumentos principales del BaseDocTemplate son los siguientes:

BaseDocTemplate( nombreArchivo, # Nombre de nuestro pdf
                    pagesize=defaultPageSize, # Tamaño de página
                    pageTemplates=[], # Lista de pagetemplates
                    showBoundary=0, # Para mostrar el borde
                    leftMargin=inch, # Magen izquierdo
                    rightMargin=inch, # Margen derecho
                    topMargin=inch, # Margen superior
                    bottomMargin=inch, # Margen inferior
                    title=None, # Titulo del pdf
                    author=None, # Autor del pdf
                    )

El SimpleDocTemplate (from reportlab.platypus import SimpleDocTemplate), es una platilla de documento predefinida, cuyo uso por lo general se da en relación con el canvas. No usa una lista de pagetemplates, pero nos asigna uno. Además, en su método build, se puede usar onFirstPage y onLaterPages, como modelos de primera página y páginas posteriores. (ejemplo)

En cuanto a los PageTemplates, que son contenedores de los Frames, poseen los siguientes argumentos:

PageTemplate(id=None, # Identificador
                          frames=[], # Lista de frames
                          onPage=_doNothing, # Por lo general es usado como encabezado
                          onPageEnd=_doNothing # Por lo general es usado como pie de página
   )

Tanto onPage como onPageEnd deben ser llamados por una función, que tiene la estructura siguiente:

def XXX(canvas, documento)

Esas dos rutinas, en si tienen el objetivo de dibujar, partes estáticas en las páginas, que no son fluibles como los flowables (No-Flowables). Es por eso, que por lo general su uso se centra en encabezado, pies de página, marcas de agua.

Ahora, veamos el ejemplo de cómo usar el pagetemplate y doctemplate

#-*- coding:utf-8 -*-
import os

#Librerias reportlab a usar:
from reportlab.platypus import (BaseDocTemplate, Frame, Paragraph, 
                    NextPageTemplate, PageBreak, PageTemplate)
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.units import inch
from reportlab.lib.pagesizes import A4


#NIVEL 1: CREAMOS LOS CANVAS
#===========================   
#Creamos los canvas para el pie de página y encabezado, que serán fijos
def encabezado(canvas,doc):
    canvas.saveState()
    canvas.setFont('Times-Roman',9)
    canvas.drawString(inch, A4[1]-50, "Ejemplo de DocTemplate y PageTemplate")
    canvas.restoreState()
    
def pie(canvas,doc):
    canvas.saveState()
    canvas.setFont('Times-Roman',9)
    canvas.drawString(inch, 0.75 * inch, "Page %d" % doc.page)
    canvas.restoreState()

#NIVEL 2: CREAMOS LOS FLOWABLES
#==============================
#Creamos la hoja de Estilo
estilo=getSampleStyleSheet()

#Iniciamos el platypus story
story=[]

#Añadimos al story los flowables. Hay que tener en cuenta que se inicia
#con el primer pageTemplate "UnaColumna"
story.append(Paragraph("Esto es el texto del Frame normal del pagetemplate" +\
                       " de una columna"* 500, estilo['Normal']))
                        
story.append(NextPageTemplate('DosColumnas'))  # Cambio de PageTemplate
story.append(PageBreak())  # Inicio en otra hoja
story.append(Paragraph("Esto es el texto del Frame que pertenece al" +\
                       " pagetemplate de dos columnas" * 500, estilo['Normal']))
                
story.append(NextPageTemplate('UnaColumna'))
story.append(PageBreak())
story.append(Paragraph("Regresamos al texto del Frame normal del" +\
                        " pagetemplate de dos columnas"*100, estilo['Normal']))

#NIVEL 3: CREAMOS LOS FRAMES, para luego asignarlos a un pagetemplate.
#===========================
#Frame (x1, y1, ancho, alto, leftPadding=6, bottomPadding=6, rightPadding=6,
# topPadding=6, id=None, showBoundary=0)

#1. Frame que contendrá a toda el contenido de una hoja
frameN = Frame(inch, inch, 451, 697, id='normal')

#2. Frame de columnas
frame1 = Frame(inch, inch, 220, 697, id='col1')
frame2 = Frame(inch + 230, inch, 220, 697, id='col2')

#NIVEL 4: CREAMOS LOS PAGETEMPLATE, le asignamos los frames y los canvas
#=================================
#PageTemplate(id=None,frames=[],onPage=_doNothing,onPageEnd=_doNothing)
PTUnaColumna = PageTemplate(id='UnaColumna', frames=frameN, onPage=pie)
PTDosColumnas =  PageTemplate(id='DosColumnas', frames=[frame1,frame2],
                        onPage=encabezado, onPageEnd=pie)

#NIVEL 5: CREAMOS EL DOCTEMPLATE, a partir del BaseDocTemplate
#===============================
doc = BaseDocTemplate('test.pdf', pageTemplates=[PTUnaColumna, PTDosColumnas], 
        pagesize=A4)

#Construimos el PDF
doc.build(story)

os.system("test.pdf")

Si han sido observadores, no ha habido un paso directo entre el nivel 1 y el nivel 2, y eso se debe a que los canvas que usamos son NO FLOWABLES, que han sido usados directamente en los pagetemplates del nivel 4. En el siguiente post, veremos como usar canvas en flowables y otras cosas más.

ReportLab: Platypus - Frames (11)

noreply@blogger.com (Anonymous) — Thu, 13 Feb 2014 22:14:00 +0000

Los Frames son contenedores activos, quienes a su vez son contenidos en un PageTemplates. Tienen una localización y tamañon, manteniendo el concepto de espacio dibujable restante.

Frame (x1, y1, ancho, alto, leftPadding=6, bottomPadding=6, rightPadding=6, topPadding=6, id=None, showBoundary=0)

El comando anterior, crear una instancia del Frame con cordenadas x,y que son relativas a la página en uso. Los Padding reducen espacio para dibujar. El id, sirve como un identificador (ej: 'ColumnaDerecha'). Si el showBoundary es distinto de cero, se mostrará las fronteras del frame en tiempo de ejecución.

- Frame.addFromList(drawList, canvas) Añade la lista de flowables
- Frame.split(flowable, canvas) Devuelve una lista de flowables
- Frame.drawBoundary(canvas) Dibuja el marco del Frame

Veamos el ejemplo:

import os

#Cargamos los módulos que necesitamos.

from reportlab.pdfgen.canvas import Canvas
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.units import inch
from reportlab.platypus import Paragraph, Frame
from reportlab.platypus import Image
from reportlab.platypus import Spacer

#Creamos objeto Canvas.
c = Canvas('test.pdf')

#Estilo de la hoja.
estiloHoja = getSampleStyleSheet()

#Demás estilos.
estiloN = estiloHoja['Normal']
estiloH = estiloHoja['BodyText']

#Inicializamos platypus story.
story = []

#Añadimos algunos flowables.
imagen_logo = Image("Tux2.png", width=150, height=200)
story.append(imagen_logo)

#Dejamos espacio.
story.append(Spacer(0,20))

#Añadimos un párrafo.
story.append(Paragraph("Esto es un ejemplo de frame 01",estiloN))

#Definimos un frame.
frame = Frame(3, 3, 200, 260, showBoundary=1)
frame.addFromList(story, c)

#Inicializamos platypus story.
story2 = []

#Añadimos algunos flowables.
story2.append(Paragraph("Este es el párrafo del segundo Frame",estiloH))

#Dejamos espacio.
story2.append(Spacer(0,20))

#~ #Una imagen.
imagen_logo = Image("imagen.jpg", width=100, height=100)
story2.append(imagen_logo)

#Definimos otro frame.
frame2 = Frame(250, 3, 250, 250, 6, showBoundary=1)
frame2.addFromList(story2, c)

#Salvamos el PDF.
c.save()

os.system("test.pdf")

ReportLab. Platypus - Flowables (10)

noreply@blogger.com (Anonymous) — Thu, 13 Feb 2014 21:32:00 +0000

Ya vimos en temas anteriores el nivel más bajo de todos, el pdfgen.canvas. Ahora veremos las capas superiores, que en su conjunto serán usadas por Platypus.

El Flowables es una clase abstracta para cosas que pueden ser dibujadas; por ejemplo: los párrafos y las tablas. Usa métodos como:

- Flowable.drawOn(canvas, x, y) Envía el flowable a un canvas en particular. Maneja el traslado de las coordenadas del canvas (x,y) , de manera que dicho canvas pueda dibujar el flowable en un frame de coordenadas absolutas.

- Flowable.wrap(width, height) Calcula el espacio que usará el flowable.

# -*- coding:utf-8 -*-
import os
from reportlab.platypus import Paragraph
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.pdfgen.canvas import Canvas
from reportlab.lib.pagesizes import A4

hojaEstilo = getSampleStyleSheet()
estilo = hojaEstilo['BodyText']

P=Paragraph('Un pequeño ejemplo', estilo)

c = Canvas('test.pdf')

#Supongamos que nuestro frame sea el tamaño de la hoja A4
PAGE_WIDTH = A4[0]
PAGE_HEIGHT = A4[1]

#El párrafo tiene un ancho y un alto respectivo, por lo tanto el método wrap
#calculará el espacio que realmente se requiere para reajustar el Flowable, 
#en este caso el párrafo.
w, h = P.wrap(PAGE_WIDTH, PAGE_HEIGHT)   
print w, h
#Hay que tener en cuenta que el ancho del párrafo se extiende por el ancho de
#la página.

#Especificamos en que altura del eje Y se ubicará el párrafo   
UbicacionParrafo= PAGE_HEIGHT - h
#Mandamos el Flowable(el párrafo), al canvas.
P.drawOn(c, 0, UbicacionParrafo)

c.save()

os.system("test.pdf")

ReportLab: Platypus - Entendiendo la relación con pdfgen.canvas (09)

noreply@blogger.com (Anonymous) — Thu, 13 Feb 2014 17:25:00 +0000

Platypus (Page Layout and Typography Using Scripts), es una librería para disponer las páginas en un alto nivel, permitiendonos crear documentos complejos con poco esfuerzo.

Platypus busca separar el diseño del contenido de los documentos. Así por ejemplo, los párrafos son construidos usando estilo de párrafos, y las páginas usando plantillas. De esta forma, si se crea un millar de páginas, bastará con modificar las especificaciones de estilo para que resulte efecto en todo el documento.

Platypus usa un diseño de capas:

DocTemplates: Es la plantilla del documento.
PageTemplates: Es la plantilla para las páginas.
Frames: Son las regiones en las páginas que contienen texto o gráficos
Flowables: Elementos de texto ó gráficos que están incrustados en el documento (párrafos, tablas, imágenes, pero no pies de página)
pdfgen.Canvas: El que se encarga de pintar el documento, a partir de las órdenes de las otras capas superiores.

El gráfico siguiente lo explica mejor ( Los de color púrpura son los Frames):

Veamos un ejemplo:

# -*- coding:utf-8 -*-
import os

#Importamos algunas librerias: SimpleDocTemplate, es una plantilla de documento
#predefinida; getSampleStyleSheet, contiene una hoja de estilos de ejemplo;
#inch es una pulgada
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import inch

PAGE_WIDTH = A4[0]
PAGE_HEIGHT = A4[1]

styles = getSampleStyleSheet()

#Definimos las caracteristicas fijas de la primera página
def myFirstPage(canvas, doc):
    canvas.saveState()
    canvas.setFont('Times-Bold', 16)
    canvas.drawCentredString(PAGE_WIDTH/2.0, PAGE_HEIGHT - 108, Title)
    canvas.setFont('Times-Roman', 9)
    canvas.drawString(inch, 0.75 * inch, "Primera pagina / %s" %pageinfo)
    canvas.restoreState()

#Definimos disposiciones alternas para las caracteristicas de las otras páginas
def myLaterPages(canvas, doc):
    canvas.saveState()
    canvas.setFont('Times-Roman', 9)
    canvas.drawString(inch, 0.75 * inch, "Página %d / %s" %(doc.page, pageinfo))
    canvas.restoreState()


Title = "Hola mundo"
pageinfo = "Ejemplo Platypus"
#Creamos un documento basándonos en una plantilla
doc = SimpleDocTemplate("test.pdf")
#Iniciamos el story para los registros
story = [Spacer(0, 80)]
#Definimos un estilo
estilo = styles['Normal']
#Creamos 100 párrafos
for i in range (100):
    texto = ("Este es el párrafo número %s. " %(i+1) ) *20
    #Definimos un párrafo usando un estilo
    p = Paragraph(texto, estilo)
    #Registramos en el story
    story.append(p)
    #También registramos el espacio que tendrá entre párrafos
    story.append(Spacer(0, 20))
#Construimos el documento a partir de los argumentos definidos
doc.build(story, onFirstPage = myFirstPage, onLaterPages = myLaterPages)

os.system("test.pdf")

Python: Convertir variable a cadena

noreply@blogger.com (Anonymous) — Thu, 06 Feb 2014 16:23:00 +0000

Una de las cosas particulares que encontré en la red, fue el de convertir una variable en una cadena.
Claro, algunos no le verán el sentido, ya que se podría usar diccionarios, pero sé que en algún momento podría ser útil.

a = "algo"
b = 512
c = None

def vartostr(var):
    return [name for name, ref in globals().iteritems() if ref is var][0]

lista = [a, b, c]
for i in lista:
    print "Estos son los valores de la variable %s: %s" %(vartostr(i), i)

Mostrar Folder con python en multiplataforma

noreply@blogger.com (Anonymous) — Tue, 04 Feb 2014 17:17:00 +0000

Al crear una aplicación quería lanzar un Folder, para que el usuario lo viera. Me encontré con varias soluciones, pero no las he probado todas en multiplataforma.

Supongo que la desición radica en cúan multiplataforma es la solución, como en el caso de Linux, si la solución se aplica a la mayoría de distros.

Solución 01

import os
import platform

def open_file(path):
    if platform.system() == "Windows":
        os.startfile(path)
    elif platform.system() == "Darwin":
        subprocess.Popen(["open", path])
    else:
        subprocess.Popen(["xdg-open", path])

open_file(path)

Solución 02

import webbrowser
webbrowser.open(path)

Solución 03

import os
systems = {
    'nt': os.startfile,
    'posix': lambda foldername: os.system('xdg-open "%s"' % foldername),
    'os2': lambda foldername: os.system('open "%s"' % foldername)
     }

systems.get(os.name, os.startfile)(path)

Obviamente hay más soluciones, si tienen alguna compartanla.

ReportLab: Insertando Fuentes TTF (08)

noreply@blogger.com (Anonymous) — Mon, 03 Feb 2014 21:16:00 +0000

Insertar fuentes TrueType, se puede realizar no solo con pdfgen.canvas, sino también con platypus (que lo veremos más adelante).

Para el ejemplo, hemos descargado una fuente cualquiera, muchas en la web, llamada "COMICATE.ttf", en este caso veremos la inserción en canvas.

# -*- coding:utf-8 -*-
import os
from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas

from reportlab.pdfbase import pdfmetrics
from reportlab.pdfbase.ttfonts import TTFont

#TTFont(nombre, archivo)
pdfmetrics.registerFont(TTFont('COMICATE', 'COMICATE.ttf'))

c=canvas.Canvas("test.pdf", pagesize = A4)
c.drawString(100, 700, "Texto sin usar fuente ttf")

c.setFont('COMICATE', 20)
c.drawString(100, 600, "Texto usando fuente ttf")

c.showPage()

c.save()
os.system("test.pdf")

ReportLab: Encoding UTF8 - Solución UnicodeDecodeError: 'utf8' (07)

noreply@blogger.com (Anonymous) — Mon, 03 Feb 2014 20:54:00 +0000

El error siguiente: UnicodeDecodeError: 'utf8' codec can't decode bytes in position...

por lo general aparece cuando leemos datos de otra fuente el cuál contiene datos en bytes, como latin-1, ANSI, estos se necesitan convertir a Unicode. Python provee tal conversión, por lo tanto la solución es inmediata.

En el ejemplo tenemos un texto guardado en ANSI, cuyo contenido es "Aquí un texto sin canción", en el que se produce un error al momento de dibujarlo en el canvas. Sin embargo, usando unicode(), todo se resuelve.

# -*- coding:utf-8 -*-
import os
from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas

c=canvas.Canvas("test.pdf", pagesize = A4)

archivo = open("texto en latin.txt", "r")
for linea in archivo:
    linea = unicode(linea, 'latin-1') #Solucionamos el problema de codificación
    c.drawString(100, 700, linea.strip())  # strip quita caracteres en blanco

c.showPage()

c.save()
os.system("test.pdf")

ReportLab: pdfgen - Objeto de trayectoria y Tipo de líneas (06)

noreply@blogger.com (Anonymous) — Mon, 03 Feb 2014 17:46:00 +0000

Ya vimos sobre los objetos de texto, que permiten dibujar de forma más comoda los textos. Para los gráficos, contamos con path object. La ventaja de usarlo, reside en la comparativa de dibujar a mano alzada, en la que el cierre de los puntos de unión se da automáticamente.

En el ejemplo también veremos sobre los tipos de líneas, y con esto finalizaremos el aspecto gráfico con pdfgen.

# -*- coding:utf-8 -*-
import os
from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas
from math import sqrt

c=canvas.Canvas("test.pdf", pagesize = A4)

#PATH OBJECT
#=================
#Creamos una estrella de 6 puntas. Como se sabe esta formada por la 
#intersección de dos triángulos equiláteros.

#1. Dibujemos de la forma clásica, línea a línea
def estrellaDavid(x1, y1, lado):
    l = lado  
    h = (l * sqrt(3) / 2)     
        
    c.line(x1, y1, x1 + l, y1)
    c.line(x1, y1, x1 + l / 2 , y1 + h)
    c.line(x1 + l, y1, x1 + l / 2, y1 + h)

    c.line(x1, y1 + 2*h/3, x1 + l, y1 + 2*h/3)
    c.line(x1, y1 + 2*h/3, x1 + l / 2, y1 + 2*h/3 - h)
    c.line(x1 + l, y1 + 2*h/3, x1 + l / 2, y1 + 2*h/3 - h)

c.drawString(100, 800, "Dibujo línea a línea")
c.setLineWidth(5)
estrellaDavid(200, 600, 200)


#2. Dibujemos usando Objeto de trayectoria (path object).
#A diferencia del método anterior, es como dibujar teniendo un lapiz en mano. 
#Si tenemos que levantarlo usamos moveTo; si tenemos que trazarlo, lineTo, y 
#lo importante los puntos de unión se cierran con p.close()
def estrellaDavid_po(x1, y1, lado):
    l = lado  
    h = (l * sqrt(3) / 2)  
    p = c.beginPath()
    p.moveTo(x1, y1)  # Nos movemos a un punto
    p.lineTo(x1 + l, y1)  # Trazamos la linea hasta el punto indicado
    p.lineTo(x1 + l / 2, y1 + h)
    p.lineTo(x1 , y1)
    p.close()  # Cierra el trazo de la figura dibujada
    
    p.moveTo(x1, y1 + 2*h/3)
    p.lineTo(x1 + l, y1 + 2*h/3)
    p.lineTo(x1 + l / 2, y1 + 2*h/3 - h)
    p.lineTo(x1, y1 + 2*h/3)
    p.close()
    c.drawPath(p)
#Hay más métodos de los path objects mencionados en el userguide, como:
# p.curveTo(x1,y1,x2,y2,x3,y3)  Dibuja una curva Bezier
# p.arc(x1,y1,x2,y2,startAng=0, extent=90)  Dibuja elipses parciales
# p.arcTo(x1,y1,x2,y2,startAng=0, extent=90)
# p.rect(x, y, ancho, alto)
# p.ellipse(x, y, ancho, alto)
# p.circle (x_centrado, y_centrado, radio)

c.drawString(100, 400, "Dibujo con path object. Notesé la unión de puntos.")
estrellaDavid_po(200, 200, 200)

c.showPage()

#TIPOS DE UNIÓN DE LINEAS (JOIN)
#========================
c.setLineWidth(5)  # Tamaño de línea
estrellaDavid_po(20, 600, 150)
c.setLineJoin(1)  # Línea redondeada. (0) Default: Es puntiaguda
estrellaDavid_po(220, 600, 150)
c.setLineJoin(2)  # Línea cuadrada
estrellaDavid_po(420, 600, 150)

#TIPOS DE EXTREMO DE LINEA (CAP)
#=========================
c.line(220, 400, 350, 400)
c.setLineCap(1)  # Extremo redondeado. (0) Default: Cuadrado Sin Proyección
c.line(220, 380, 350, 380)
c.setLineCap(2)  # Extremo Cuadrado Con Proyección
c.line(220, 360, 350, 360)

c.setLineWidth(0.5)
c.line(220, 420, 220, 340)
c.line(350, 420, 350, 340)

#LINEA ENTRECORTADAS (DASH)
#===================
c.setLineWidth(1)
c.setDash(6, 3)  # sucesión de 6 puntos trazados, y 3 no trazados
estrellaDavid_po(20, 150, 150)
c.setDash(1, 2)  # sucesión de 1 punto trazado y 2 no trazados
estrellaDavid_po(220, 150, 150)
c.setDash([1,3,5,3], 0)  # sucesión alternada en la lista. 0: punto de inicio
estrellaDavid_po(420, 150, 150)

c.showPage()

c.save()
os.system("test.pdf")

ReportLab: pdfgen - La librería lib.colors y transparencia (05)

noreply@blogger.com (Anonymous) — Mon, 03 Feb 2014 17:28:00 +0000

Por lo general, al rellenar dibujos usamos colores rgb, cmyk, escala de grises, insertando valores para que en combinación nos de un determinado color. Si uno quiere insertar de forma grosa; por ejemplo el color azul, lo puede hacer directamente desde lib.colors. Además que da la opción de insertar colores transparentes:

Veamos el ejemplo:

# -*- coding:utf-8 -*-
import os
from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas
from reportlab.lib.colors import Color, green, red  # Traemos algunos colores

c=canvas.Canvas("test.pdf", pagesize = A4)

print c.getPageNumber()  # Número de página

c.setLineWidth(20)  # Tamaño de la linea
c.setStrokeColorRGB(0.5, 0.5, 0.5)
c.setFillColorRGB(0.9, 0.0, 0.0)
c.rect(200, 300, 200, 200, fill=1)

#Creando color transparente
rojoTransparente = Color(100, 0, 0, alpha=0.5 )

c.setFillColor(green)  # Utilizamos un color que ya tenemos
c.rect(255, 125, 100, 100, fill=1, stroke=False)
c.setFillColor(rojoTransparente)
c.rect(300, 175, 100, 100, fill=1, stroke=False)

c.showPage()

c.save()
os.system("test.pdf")

ReportLab: pdfgen - Objeto de texto (04)

noreply@blogger.com (Anonymous) — Sat, 01 Feb 2014 16:54:00 +0000

Al usar canvas.drawstring, nos vemos limitados a dibujar de forma lineal el texto, y si el texto es demasiado largo, no se mostrará en todo la página. Además, hay oportunidades en que nuestro texto lo tenemos en un archivo, talvez un txt. En esos casos se puede usar objectText.

Veamos el siguiente código que lo explica (se usa un archivo llamado lorem.txt, que contiene un párrafo de Lorem Ipsum:

# -*- coding:utf-8 -*-
import os
from reportlab.lib.pagesizes import A4
from reportlab.pdfgen import canvas

c=canvas.Canvas("test.pdf", pagesize = A4)

#FUENTES EN CANVAS
#-----------------
texto = "Lorem ipsum dolor sit amet"
x, y = 150, 710
for fuente in c.getAvailableFonts():  # Lista disponible de fuentes
    c.setFont(fuente, 10)  # Cambiamos la fuente y el tamaño
    c.drawString(x, y, texto)
    c.setFont("Helvetica", 12) 
    c.drawRightString(x-10, y, fuente + ":")
    y -= 20
 
#TRABAJANDO CON OBJETO DE TEXTO
#-------------------------------
# Indispensable para textos de varias lineas, ya que el método drawString 
# no podrá dibujar múltiples líneas:
textoArchivo = open("lorem.txt", "r")  # Abrimos un archivo de texto
texto = """Lorem ipsum dolor sit amet, consetetur sadipscing elitr, 
sed diam nonumyeirmod tempor invidunt ut labore et dolore magna 
aliquyam erat, sed diamvoluptua. At vero eos et accusam et justo duo dolores 
et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem 
ipsum dolor sit amet.Lorem ipsum dolor sit amet, consetetur sadipscing elitr, 
sed diam nonumyeirmod tempor invidunt ut labore et dolore magna aliquyam erat, 
sed diamvoluptua. At vero eos et accusam et justo duo dolores et ea reb""" 
 
textobject = c.beginText()  # Iniciamos el textobject
textobject.setTextOrigin(20, 400)  # Ubicamos el cursor donde dibujar
textobject.setFont("Helvetica-Oblique", 13)
for i in textoArchivo:
    i = i.replace("\n","")  # Remplazamos el salto de linea
    textobject.setCharSpace(0.5)  # Espacio entre caracteres 
    textobject.setWordSpace(1)  # Espacio entre palabras
    textobject.textLine(i)  # Dibujamos la linea
    textobject.moveCursor(5, 10)  # Movemos el cursor para luego escribir
textobject.setFillGray(0.4)  # Rellenamos con Escala de grises
textobject.setLeading(20)  # Espaciado entre lineas
textobject.textLines(texto)  # Insertamos el texto y con color gris
c.drawText(textobject)  # Dibujamos el texto pasando un objeto de texto
 
c.showPage()  

c.save()
os.system("test.pdf")

ReportLab: pdfgen - Insertando imágenes en canvas (03)

noreply@blogger.com (Anonymous) — Sat, 01 Feb 2014 00:22:00 +0000

En ReportLab hay dos formas principales de insertar imágenes: una es usando reportlab.graphics.shapes y la otra es canvas. La diferencia reside en que canvas inserta la imágen en una posición estática, mientras que la otra permite operaciones de rotado, escalado y traslado.

Si nuestro caso es solo insertar una imágen en cierta posición, sin modificarla y usando canvas, está es nuestra opción.

# -*- coding:utf-8 -*-
import os
from reportlab.pdfgen import canvas
c=canvas.Canvas("test.pdf", pagesize = A4)
#drawImage(archivo, x, y, width=None, height=None)
c.drawImage("Tux2.png", 0, A4[1]/2, width=400, height=400)
c.showPage()
c.save()
os.system("test.pdf")

No hay que olvidar que para otros formatos de imágenes debemos tener instalado el PIL.
Prueben con la misma imágen u otra, en la web la encontre con el nombre Tux2.png

ReportLab: pdfgen - Formas básicas y Texto en canvas (02)

noreply@blogger.com (Anonymous) — Fri, 31 Jan 2014 23:41:00 +0000

Es esta parte veremos algunas operaciones de texto y creación de formas básicas.

# -*- coding:utf-8 -*
import os
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import inch  # Tambien podemos usar otras medidas

c=canvas.Canvas("test.pdf", pagesize = A4)

#Ancho y alto de la página
ancho, alto = A4

#Definimos el tipo y tamaño de fuente
c.setFont("Helvetica", 24)

#Dibujamos un par de lineas, por omision serán de color negro
#-line(x1,y1,x2,y2) x1,y1 inicio de line; x2, y2 fin de linea
c.line(50,50,50,350)
c.line(50,50,350,50)

#Escogemos algunos colores
c.setStrokeColorRGB(0.0, 1, 0.0)  # Color de trazo
c.setFillColorRGB(0, 0.0, 0.5)  # Color de relleno

#Dibujamos un Cuadrado a partir de un rectángulo redondeado
#-roundRect(x, y, ancho, alto, radio de curva, stroke, fill)
#stroke y fill, si es 0 inidica no mostrar trazo ni relleno
c.roundRect(75, 75, 275, 257, 20, stroke = 1, fill = 1)
c.setFillColorRGB(0.75, 0.75, 0.0)  # Relleno para el texto "Cuadrado"
c.drawString(125, 80, "Cuadrado")

#Dibujamos un Círculo
c.setFillColorRGB(0.8, 0.0, 0.2)
c.circle(205, 205, 100, stroke=1, fill=1)  # x, y, radio, stroke, fill
c.setFillColorRGB(0, 1, 0.2)
c.drawString(155, 200, "Circulo")

#Dibujamos una Elipse
c.setStrokeColorRGB(1, 0, 0.0)
c.ellipse(75, 450, 350, 335)  #x1, y1, x2, y2, stroke, fill
c.setFillColorRGB(0, 0, 0.5)
c.drawString(150, 375, "Elipse")

c.showPage()  # Finalizamos la página

#Si lo han notado hemos de ingresar color de relleno y trazo para cada forma,
#sino especificamos, lo hara en negro.
#grid(lista en x, lista en y)
c.grid([20,40,60,80], [alto-20,alto-40,alto-60,alto-80])
#arc(x1,y1,x2,y2)
c.arc(200, 200, 400, 400)
#rect(x, y, alto, ancho, stroke=1, fill=0)
c.rect(300,500, 200, 100)

#Veamos los tipos de dibujo de texto
c.line(ancho/2, 720, ancho/2, 640)
c.drawString(ancho/2, 700, "Texto con punto de referencia a la izquierda")
c.drawRightString(ancho/2, 680, "Texto con punto de referencia a la derecha")
c.drawCentredString(ancho/2, 660, "Texto con punto de referencia en el centro")

c.save()  # Archivamos y cerramos canvas
os.system("test.pdf")  # Lanzamos el pdf

ReportLab: pdfgen - Lo básico de Canvas (01)

noreply@blogger.com (Anonymous) — Fri, 31 Jan 2014 22:07:00 +0000

PDFGEN es la interfaz más baja para generar PDF. Son secuencias de instrucciones para pintar un documento sobre una secuencia de páginas. El objeto que provee tal operación de pintado es el pdfgen canvas.

El canvas debe ser considerado como un papel con coordenadas x, y cuyo punto de origen es la esquina inferior izquierda. Se incrementa a la derecha y hacia arriba.

Hay que tener en cuenta que ReportLab tiene tres formas de uso (APIs): Canvas, Platypus, y Drawing.
Canvas te permitira dibujarlo todo en la hoja, Platypus va más enfocado en la producción de texto, separando el formato del contenido (algo similar a html y css), Drawing te permitirá crear gráficos un poco más avanzados, como los estadísticos.

Veamos un ejemplo básico:

import os

# Importamos Librería a usar
from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import A4  # Puede ser también Letter, A5, A6, ...

#A4 es una tupla, podemos extraer sus valores
#ancho, alto = A4 como también de la siguiente forma
anchoHoja = A4[0]
altoHoja = A4[1]
print anchoHoja, altoHoja

#Creamos el contexto de Canvas
#- Creamos el nombre del archivo 
#- pagesize es una tupla, por eso le pasamos A4 de lib
c=canvas.Canvas("test.pdf", pagesize = A4)

#Escribimos en la primera hoja
#drawString(x,y, texto)
c.drawString(50,500, " Mi PRIMER PDF")
c.drawString(250,300,"Coordenada=(250,300) ")
c.drawString(350,200,"(350, 10)")
c.drawString(150,400,"Aprendiendo REPORTLAB")

#Grabamos la página presente del canvas
c.showPage()  

#Escribimos en la segunda hoja
c.drawString(50,500, "Segunda Hoja")
c.showPage()

#Archivamos y cerramos el canvas
c.save()  

#Lanzamos el pdf creado
os.system("test.pdf")

ReportLab: Libreria PDF para Python (00)

noreply@blogger.com (Anonymous) — Fri, 31 Jan 2014 21:49:00 +0000

ReportLab, es una libreria que permite crear directamente documentos en PDF (Formato de Documento Portable) usando Python como lenguaje de programación. También permite crear gráficos en bitmap y vectores.

Me interese sobre ReportLab, debido a su capacidad de generar reportes, ya en el trabajo solicitan crear cantidad de reportes para ser impresos y hacerlo llegar a los clientes. Python es uno de mis lenguajes favoritos, y ReportLab me llamo mucho la atención.

ReportLab, actualmente trabaja con Python 2.7, por lo que la versión 3, tendrá que esperar (talvez este sea uno de los motivos por lo que soy renuente a desechar el 2.7)

Instalación:

Consultar en la página oficial http://www.reportlab.com.

Tanto en Linux como en windows hay que instalar dos cosas: primero, el ReportLab, y segundo, PIL (Python Imaging Library). Este último es para poder usar imágenes png o gif.

1. Linux

En ambos paquetes aplicar los siguientes comandos para instalar:

python setup.py build
sudo python setup.py install

2. Windows

Los instaladores lo pueden descargar desde la página oficial, o si desean les dejo estos enlaces:
PIL
ReportLab 2.7

Los manuales en español son inexistentes, solo hay pocas páginas web que lográn tal cometido;sin embargo todo se halla en la guía de usuario, que para muchos les puede incomodar el lenguaje anglosajon en el cual esta escrito. Sea el caso, trataré de publicar información sobre los aspectos generales de Report Lab, y lo más extremo, será cuestión de consultar en la guía oficial.

Nuestro propio widget con PyCairo

noreply@blogger.com (Anonymous) — Wed, 29 Jan 2014 16:08:00 +0000

Estos días estaba jugando con Cairo, debido a la curiosidad de saber de como hacen aquellos widgets que no encuentras en un editor de interfaz. Un ejemplo es el ecualizador de Clementine.

En fin, hay muchas formas de hacerlo, y Cairo me llamo la atención, ya que se integra con Python y GTK. Mi idea fue crear un progress bar algo distinto (sólo con fines de probar), en el cuál si cargaba hasta el 50% se mostrara en rojo, si cargaba hasta el 80% se mostrara en amarillo y el resto en azul. Y al completarse todo la carga, se muestre un texto "100% completo" sobre un fondo degradado:

Para ello trabaje, no enrrollandome con puro código gtk para crear una ventanita, sino usando glade.

Aquí use aquella herramienta que no había usado hasta ahora, el drawingarea.

Bueno el código quedó de la siguiente forma:

#!/usr/bin/python
# -*- coding: utf-8 -*- 
import gtk
import glib
import cairo


class App(object):
    def __init__ (self):
        #Iniciamos el porcentaje de carga
        self.percent = 0
        
        #Se carga el archivo glade
        builder = gtk.Builder()
        builder.add_from_file('Final.ui')
        
        #Se recuperan los widget a usar
        self.winMain = builder.get_object('window1')
        self.drawingarea = builder.get_object('drawingarea1')
        
        #Instanciamos nuestro widget
        self.pbBGR = ProgressBarBGR(self.drawingarea)
        
        #Conectamos las señales y mostramos la ventana
        builder.connect_signals(self)
        self.winMain.show()
    
    def on_btnIniciar_clicked(self, *args):
        #Ejecutamos el mètodo cada 20ms
        glib.timeout_add(20, self.on_timer) 
        
    def on_timer(self):
        #Incrementamos el porcentaje
        self.percent += 1
        
        #Trabajamos con nuestro widget
        self.pbBGR.setPercent(self.percent) # INSERTAMOS PORCENTAJE
        self.pbBGR.draw()  # DIBUJAMOS
        
        if self.percent > 99:
            self.percent = 0
            return False
        return True


class ProgressBarBGR():
    def __init__(self, drawingarea):
        self.__percent = 0  # Ocultamos nuestra variable
        self.drawingarea = drawingarea
        self.drawingarea.connect("expose-event", self.expose)
        
    def setPercent(self, percent):
        self.__percent = percent
        
    def getPercent(self):
        return self.__percent
    
    def draw(self):
        self.drawingarea.queue_draw()

    def expose(self, widget, event):
        #Creamos el contexto       
        cr = widget.window.cairo_create()
        
        #Determinamos eje x, eje y, ancho y alto del área de dibujo
        x, y = event.area.x, event.area.y
        width, height = event.area.width, event.area.height

        #Dibujamos el rectángulo principal
        cr.set_line_width(2)
        cr.rectangle(x, y, width, height)
        cr.set_source_rgb(0, 0, 0)
        cr.fill()
        
        #Dibujamos los 100 rectángulos y ponemos colores
        h = height
        w = width / 100.0
        perc = self.getPercent()
        if perc > 0:
            for i in range(0,100):
                if i <= perc and i < 50:
                    cr.set_source_rgb(1, 0, 0)
                elif i <= perc and i >= 50 and i <=80:
                    cr.set_source_rgb(1, 1, 0)
                elif i <= perc and i > 80 and i <=99:
                    cr.set_source_rgb(0, 0.5, 0.9)
                else:
                    cr.set_source_rgb(0, 0, 0)
                cr.rectangle( w * i, 0, w -1, h)
                cr.fill()
                
        #Dibujamos la barra completada al 100%
        if perc == 100:
            #Degradamos
            lg = cairo.LinearGradient(x, y, x, height)
            lg.add_color_stop_rgba(0.1, 0, 0, 0, 1)
            lg.add_color_stop_rgba(0.5, 0, 0.6, 1, 1)
            lg.add_color_stop_rgba(0.9, 0, 0, 0, 1)
            
            cr.rectangle(x, y, width, height)
            cr.set_source(lg)
            cr.fill()
            
            #Insertamos el texto de 100%
            cr.select_font_face("Serif", cairo.FONT_SLANT_NORMAL, 
            cairo.FONT_WEIGHT_BOLD)
            if height < 100:
                cr.set_font_size( height/2.5)
            else:
                cr. set_font_size((width + height) / 20)
            texto = "100% COMPLETO"
            (x, y, txtwidth, txtheight, dx, dy) = cr.text_extents(texto)
            cr.set_source_rgb(0.5, 0.5, 0.5)
            cr.move_to(width/2 - txtwidth/2, h/2 + txtheight/2)
            cr.show_text(texto)
            cr.set_source_rgb(1, 1, 1)
            cr.move_to(width/2 - txtwidth/2 + 2, h/2 + txtheight/2 +2 )
            cr.show_text(texto)
            
        
if __name__ == "__main__":
    App()
    gtk.main()

PD: esto fue desarrollado con PyGTK, facilmente se puede cambiar el código a PyGI. Por ejemplo:
en vez de usar "expose-event" se podría usar "draw". Es cuestión de revisar la documentación.

Test SyntaxHighlighter

noreply@blogger.com (Anonymous) — Tue, 28 Jan 2014 22:54:00 +0000

Estaba haciendo algunas pruebas con SyntaxHighlighter para publicar código con resaltadores de texto, el cuál es relativamente fácil de instalar. Se puede hacer de dos formas:

1. La primera es descargarse los archivos desde la página http://http://alexgorbatchev.com/SyntaxHighlighter/download/, y subirlos junto a nuestro web. Tenemos que poner esto en la cabecera:

2. Se puede enlazar desde el servidor del autor de la siguiente forma:

Luego donde insertemos el código, podemos hacerlo con la etiqueta pre o script, pero se ha de usar la clase de la siguiente forma:

    

        Ahora se muestra el código resaltado

Soporta una gran cantidad de lenguajes, solo es cuestión de añadir el archivo js en el head. Además cuenta con temas.

Por ejemplo aquí muestro código en python:

#!/usr/bin/python
# -*- coding: utf-8 -*- 
import gtk
import glib
import cairo

class App(object):
    def __init__ (self):
        #Variables Iniciales
        self.percent = 0
        
        # Se carga el archivo glade con la ventana
        builder = gtk.Builder()
        builder.add_from_file('Final.ui')
        
        # Se recuperan los widget a usar (no son necesarios todos)
        self.winMain = builder.get_object('window1')
        self.drawingarea = builder.get_object('drawingarea1')
        self.pbBGR = ProgressBarBGR(self.drawingarea)  # INSTANCIAMOS
        
        # Se asocian las señales
        builder.connect_signals(self)
        self.winMain.show()

gtk.gdk.thread_init() cuelga el programa en Windows XP (SOLUCIONADO)

noreply@blogger.com (Anonymous) — Sat, 11 Jan 2014 16:46:00 +0000

Cuando usamos gtk.gdk.thread_init() con python todo parece genial, corre en plataformas Linux y Windows, pero en este último, no lo hace en todas sus versiones. Hay empresas que hasta el día de hoy siguen usando Windows XP, y es aquí cuando nuestro programa crashea.

La solución es simple, y consultando en el IRC, en vez de usar gtk.gdk.thread_init(), hemos de usar:

import gobject
gobject.thread_init()

Con ello podremos correr nuestros hilos sin problemas :)

Evitar el log file generado por py2exe

noreply@blogger.com (Anonymous) — Fri, 10 Jan 2014 16:29:00 +0000

Para los que usamos py2exe para crear ejecutables en windows, nos habremos dado cuenta en algún momento, que si nuestro aplicativo cae en error, automaticamente se crea un archivo *.exe.log y se muestra en una ventana similar a esta:

Esto para el usuario final suele ser molestoso sobre todo cuando nuestro programa no presenta error alguno, sino "advertencias" que se pueden generar por distintas causas.

Una solución que encontré, fue la de agregar las siguientes lineas en el archivo principal, (que por lo general es el archivo "scripts" del cual creamos el ejecutable .exe, por ejemplo main.py)

import sys
sys.stderr = sys.stdout

Pero, qué es lo que hace estas líneas?

Bueno, en aplicaciones de interfaz gráfica, py2exe redirecciona sys.stderr a un log file, pero como aqui le pasamos sys.stdout lo que hará es ignorar todo lo escrito. Esto no quiere decir que desaparece los errores o advertencias del programa, solo los oculta del GUI. En el setup.py podemos crear un debug con la opción console, y asi siempre ver los errores en linea de comandos y evitarnos el fastidio de tal ventanita.