Cómo puedo hacer este empaquetador?

kvillaloboscr · #1 (**permalink**) 08/10/2012, 16:09

Hola foreros.

Pues bueno, el día de hoy se me presentó un reto, el cual consiste en crear un empaquetador para una aplicación llamada iRep. La cosa es que ocupo agarrar el contenido de un proyecto y crear un paquete independiente para cada página, tomando en cuenta su nombre.

A ver si me expliqué bien; tengo el siguiente árbol de directorios:

Cita:

Los he seccionado por los siguientes colores:
- Los verdes, deben de ir en todos los paquetes.
- Los amarillos, deben de ir en el paquete amarillo, los rojos en el rojo, y así sucesivamente, al final debe de quedar algo así:

Cita:

Como pudieron ver, lo que hago es lo siguiente:

Agarrar el nombre del archivo que se encuentra en la raíz de la carpeta (Page01.html, Page02.html, Page03.pdf) y luego crear una carpeta a partir de ese nombre, solo que sin la extensión.
Recorrer la carpeta _css hasta encontrar el nombre del archivo con extensión .css y agregarlo a la carpeta creada en el punto 1.
Hago lo mismo con la carpeta _img, solo que en esta creo la carpeta con el nombre del paquete, y dentro las imagenes que le corresponden.
Agrego la carpeta _template a todos los paquetes (ya que es general).
En la raíz de la carpeta creada en el punto 1, meto el archivo .html, y la imagen thumb y full.

Y pues bueno, me gustaría saber más o menos como puedo hacer eso en Python.
Un saludo.

razpeitia · #2 (**permalink**) 08/10/2012, 17:05

Solo tienes que saber como moverte en python.

Con os.walk puedes recorrer el árbol de directorios.

Con shutil.copy copias archivos.

Con os.mkdir creas carpetas.

Y con el modulo re puedes usar expresiones regulares para sacar coincidir patrones con el nombre de los archivos.

Básicamente todo lo que necesitas para programarlo en python.

kvillaloboscr · #3 (**permalink**) 08/10/2012, 17:45

Gracias, razpeitia.

Supongo que voy a tener que utilizar mucha recursividad para hacerlo, pero voy a hacer el intento. De igual manera, como es un proyecto, ofrezco remuneración por si alguien se anima a crearlo o a colaborar con el packager.

razpeitia · #4 (**permalink**) 08/10/2012, 23:13

No necesitas tanta recursividad. Para hacer este "simple" script.

Imagina que estas en alguna carpeta, y dentro de esa carpeta tienes una carpeta que llamaremos 'a' donde tienes la siguiente estructura.

Código:

a
├── _css
│** └── Pag01.css
├── _img
│** ├── _full
│** │** ├── Pag01-full.png
│** │** ├── Pag02-full.png
│** │** └── Pag03-full.png
│** ├── Pag01
│** │** ├── background.png
│** │** └── logo.jpg
│** ├── Pag02
│** │** └── header.png
│** └── _thumb
│**     ├── Pag01-thumb.png
│**     ├── Pag02-thumb.png
│**     └── Pag03-thumb.png
├── Pag01.html
├── Pag02.html
├── Pag03.pdf
└── _template
    ├── config.js
    └── style.css

Lo que hice para resolver este problema es muy sencillo (inspirado en el URLConf de Django):
Recorro los archivos y por cada archivo, reviso la lista de patrones, si llega a coincidir con un patrón entonces en base a ese patrón se formatea un nuevo destino a donde va a ser copiado.

Es un script rápido (mas o menos 2 - 3 horas) que hice:

Código Python:

Ver originalimport os
import re
 
def source(pattern_path):
    pattern = re.compile(pattern_path)
    def match(path):
        m = pattern.match(path)
        return m
    return match
 
def destination(str_format):
    "Format string with arguments recieved"
    def format_path(match):
        args = match.groups()
        return str_format.format(*args)
    return format_path
 
patterns = (
    (source(r'^a/_img/_full/Pag(\d+)-full\.(png|jpg|gif)$'), destination('b/Pag{0}')),
    (source(r'^a/_img/_thumb/Pag(\d+)-thumb\.(png|jpg|gif)$'), destination('b/Pag{0}')),
    (source(r'^a/_img/Pag(\d+)/'), destination('b/Pag{0}/_img/Pag{0}')),
    (source(r'^a/_css/Pag(\d+)\.css$'), destination('b/Pag{0}/_css')),
    (source(r'^a/Pag(\d+)\.'), destination('b/Pag{0}')),
    (source(r'^a/_template'), destination('b/Pag01/_template')),
    (source(r'^a/_template'), destination('b/Pag02/_template')),
    (source(r'^a/_template'), destination('b/Pag03/_template')),
)
 
# Kids, never ever indent this much
# It's just for fast programming sake
dir_tree = os.walk('a/')
for path, dirs, files in dir_tree:
    for file_ in files:
        full_path = os.path.join(path, file_)
        for src, dst in patterns:
            match = src(full_path)
            if match:
                command = 'mkdir -p %s' % (dst(match),)
                print command
                os.system(command)
                
                command = "cp %s %s" % (full_path, dst(match))
                print command
                os.system(command)

Una vez que corre el script al mismo nivel de la carpeta 'a' obtengo una carpeta hermana llamada 'b'.

Con la siguiente estructura:

Código:

b/
├── Pag01
│** ├── _css
│** │** └── Pag01.css
│** ├── _img
│** │** └── Pag01
│** │**     ├── background.png
│** │**     └── logo.jpg
│** ├── Pag01-full.png
│** ├── Pag01.html
│** ├── Pag01-thumb.png
│** └── _template
│**     ├── config.js
│**     └── style.css
├── Pag02
│** ├── _img
│** │** └── Pag02
│** │**     └── header.png
│** ├── Pag02-full.png
│** ├── Pag02.html
│** ├── Pag02-thumb.png
│** └── _template
│**     ├── config.js
│**     └── style.css
└── Pag03
    ├── Pag03-full.png
    ├── Pag03.pdf
    ├── Pag03-thumb.png
    └── _template
        ├── config.js
        └── style.css

Sientete libre de modificar el script para que cubra tus necesidades.

PD: Este script esta atado al sistema operativo en este caso ubuntu, para hacerlo correr en windows necesitas cambiar las llamadas al sistema (osea los comandos).