Mostrando entradas con la etiqueta python. Mostrar todas las entradas
Mostrando entradas con la etiqueta python. Mostrar todas las entradas

miércoles, diciembre 02, 2015

Configurando virtualenv para Django en Ubuntu

Procedemos a su instalación:
sudo apt-get install python-virtualenv 

Configuramos virtualenv en el directorio django1.7, pues vamos a crear una instalación de Django con la versión 1.7 para nuestro proyecto. Accediendo al directorio que genera virtualenv podremos activar nuestro entorno:

virtualenv django1.7
cd django1.7/
source bin/activate

Este directorio contendrá todas las librería para la configuración de python con los paquetes que nosotros deseemos, no es necesario meter nuestro proyecto dentro de dicha carpeta.

Ahora podemos instalar Django y todas las librerías que necesitemos para nuestro proyecto, ojo tenemos que ver que el prompt ha cambiado y muestra que estamos trabajando con el entorno virtualenv que hemos activado:

(django1.7)$ pip install django==1.7

(django1.7)$pip install django_tables2
(django1.7)$pip install django_filter
(django1.7)$pip install xhtml2pdf

La instalación de mysql para utilizarlo con Django requiere de instalar el paquete de desarrollo de mysql y el compilador gcc:

(django1.7)$sudo apt-get install libmysqlclient-dev
(django1.7)$sudo apt-get install gcc
(django1.7)$pip install MySQL-python


Si el proyecto se va lanzar desde apache con WSGI, tendremos que añadir al path de python el directorio del virtualenv:

WSGIDaemonProcess hammam python-path=/home/usuario/miproyecto:/home/usuario/django1.7/lib/python2.7/site-packages

viernes, septiembre 19, 2014

Configurando el entorno de desarrollando para Django en Ubuntu GNU/Linux

Python ya estará instalado en nuestra versión de Ubuntu, sólo tendremos que instalar Django, pero la versión disponible para Ubuntu no suele ser la más reciente de Django así que utilizaremos:

sudo apt-get install python-pip
sudo pip install Django


También podemos instalar ipython para tener una shell más rica: 

sudo apt-get install ipython

podemos verificar que se ha instalado correctamente verificando la versión instalada:

django-admin --version


También necesitamos tener instalado java versión 7, con OpenJDK:

sudo apt-get install icedtea-7-plugin openjdk-7-jre
 
con Oracle Java:
 
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer

Obtener Eclipse IDE for Java EE Developers, actualmente la última versión es Luna:

http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/lunar

Instalar PyDev desde Eclipse, seleccionamos Help en el menú y luego Install new software ... donde añadimos una nueva fuente de software con la dirección web:
http://pydev.org/updates

y a instalar se ha dicho... 


Para indicarle a PyDev que utilice Python y Django instalado, tenemos que acceder al siguiente dialogo Window->Preferences->PyDev->Interpreter-Python y pulsar sobre el botón Auto Config y finalizamos pulsando OK.




Fuentes de información:
www.eclipse.org
http://www.ubuntu-guia.com/2012/04/instalar-oracle-java-7-en-ubuntu-1204.html
http://pydev.org/manual_101_install.html

lunes, septiembre 02, 2013

Instalación de OpenERP 7 en Ubuntu Server 12.04 desde launchpad

OpenERP
Comenzaremos instalando el software necesario para poder instalar OpenERP:

sudo apt-get install graphviz ghostscript postgresql-client \
python-dateutil python-feedparser python-matplotlib \
python-ldap python-libxslt1 python-lxml python-mako \
python-openid python-psycopg2 python-pybabel python-pychart \
python-pydot python-pyparsing python-reportlab python-simplejson \
python-tz python-vatnumber python-vobject python-webdav \
python-werkzeug python-xlwt python-yaml python-imaging postgresql bzr
 
sudo apt-get install python-dev mc python-setuptools python-babel \
python-feedparser python-reportlab-accel python-zsi python-openssl \
python-egenix-mxdatetime python-jinja2 python-unittest2 python-mock \
python-docutils lptools python-psutil python-paramiko poppler-utils \
python-pdftools antiword  

wget http://gdata-python-client.googlecode.com/files/gdata-2.0.17.tar.gz 
tar zxvf gdata-2.0.17.tar.gz 
cd gdata-2.0.17/
sudo python setup.py install
 
Creamos el usuario de openerp:
sudo adduser openerp  --home=/opt/openerp 

Creamos la base de datos y usuario de openerp en postgresql:

sudo passwd postgres
su - postgres
createuser --createdb --username postgres --no-createrole --no-superuser --pwprompt openerp
exit

Instalamos el servidor de openERP: 
su - openerp 
mkdir v7
cd v7
bzr branch lp:openerp-web/7.0 web
bzr branch lp:openobject-server/7.0 server
bzr branch lp:openobject-addons/7.0 addons
bzr branch lp:openerp-spain/7.0    
exit
 

Configuración del servidor openERP:
sudo cp /opt/openerp/v7/server/install/openerp-server.conf /etc/openerp-server.conf
sudo chown openerp.openerp /etc/openerp-server.conf
sudo chmod 640 /etc/openerp-server.conf 
sudo nano /etc/openerp-server.conf
 
En el fichero de configuración /etc/openerp-server.conf lo dejamos así:
[options]
; This is the password that allows database operations:
admin_passwd = <clave-administrador>
db_host = False
db_port = False
db_user = openerp
db_list = False
db_password = <nuestra-clave-de-base-datos-postgresql>
addons_path = /opt/openerp/v7/addons,/opt/openerp/v7/web/addons,/opt/openerp/v7/7.0
;Log settings
logfile = /var/log/openerp/openerp-server.log
log_level = error 

Configurando el sistema para el correcto funcionamiento del log:


sudo mkdir /var/log/openerp
sudo chown openerp.root /var/log/openerp
sudo cp /opt/openerp/v7/server/install/openerp-server.logrotate /etc/logrotate.d/openerp-server
sudo chmod 755 /etc/logrotate.d/openerp-server

Inicio automático del servidor de openERP, para ello: 
sudo touch  /etc/init.d/openerp-server
sudo chmod 755 /etc/init.d/openerp-server
sudo chown root: /etc/init.d/openerp-server
sudo update-rc.d openerp-server defaults
sudo nano /etc/init.d/openerp-server
Contenido del fichero /etc/init.d/openerp-server : 
#!/bin/sh

### BEGIN INIT INFO
# Provides:             openerp-server
# Required-Start:       $remote_fs $syslog
# Required-Stop:        $remote_fs $syslog
# Should-Start:         $network
# Should-Stop:          $network
# Default-Start:        2 3 4 5
# Default-Stop:         0 1 6
# Short-Description:    Enterprise Resource Management software
# Description:          Open ERP is a complete ERP and CRM software.
### END INIT INFO

PATH=/bin:/sbin:/usr/bin
DAEMON=/opt/openerp/v7/server/openerp-server
NAME=openerp-server
DESC=openerp-server

# Specify the user name (Default: openerp).
USER=openerp

# Specify an alternate config file (Default: /etc/openerp-server.conf).
CONFIGFILE="/etc/openerp-server.conf"

# pidfile
PIDFILE=/var/run/$NAME.pid

# Additional options that are passed to the Daemon.
DAEMON_OPTS="-c $CONFIGFILE"

[ -x $DAEMON ] || exit 0
[ -f $CONFIGFILE ] || exit 0

checkpid() {
    [ -f $PIDFILE ] || return 1
    pid=`cat $PIDFILE`
    [ -d /proc/$pid ] && return 0
    return 1
}

case "${1}" in
        start)
                echo -n "Starting ${DESC}: "

                start-stop-daemon --start --quiet --pidfile ${PIDFILE} \
                        --chuid ${USER} --background --make-pidfile \
                        --exec ${DAEMON} -- ${DAEMON_OPTS}

                echo "${NAME}."
                ;;

        stop)
                echo -n "Stopping ${DESC}: "

                start-stop-daemon --stop --quiet --pidfile ${PIDFILE} \
                        --oknodo

                echo "${NAME}."
                ;;

        restart|force-reload)
                echo -n "Restarting ${DESC}: "

                start-stop-daemon --stop --quiet --pidfile ${PIDFILE} \
                        --oknodo
      
                sleep 1

                start-stop-daemon --start --quiet --pidfile ${PIDFILE} \
                        --chuid ${USER} --background --make-pidfile \
                        --exec ${DAEMON} -- ${DAEMON_OPTS}

                echo "${NAME}."
                ;;

        *)
                N=/etc/init.d/${NAME}
                echo "Usage: ${NAME} {start|stop|restart|force-reload}" >&2
                exit 1
                ;;
esac

exit 0
 
Para iniciar el servidor:
sudo /etc/init.d/openerp-server start 

 

OpenERP en el puerto 80 y 443

iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 8069
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8070
iptables-save 

Aplicar actualizaciones

sudo /etc/init.d/openerp-server stop
sudo su openerp
cd /opt/openerp/v7/addons/
bzr pull
cd /opt/openerp/v7/web/
bzr pull
cd /opt/openerp/v7/7.0/
bzr pull
cd /opt/openerp/v7/server/
bzr pull

./openerp-server -c /etc/openerp-server.conf -u all -d <base-de-datos>

Aplicar parches

cd /opt/openerp/v7/addons/
bzr patch <url-al-parche>

 
Fuentes de información:
http://help.openerp.com/question/2562/how-to-install-openerp-v70-on-ubuntu-1204-from-launchpad-repository/ 
http://www.theopensourcerer.com/2012/12/how-to-install-openerp-7-0-on-ubuntu-12-04-lts/ 
http://huber.salazarcarlos.com/?p=23


miércoles, agosto 28, 2013

Desplegando aplicaciones django en Ubuntu 12.04 con un servidor web Apache y el módulo mod_wsgi

Empezaremos por la instalación del software necesario, posiblemente alguno ya se encuentre instalado en nuestro equipo:


sudo apt-get install python
sudo apt-get install python-mysqldb 
sudo apt-get install apache2 libapache2-mod-wsgi
sudo apt-get install mysql-server  
sudo easy_install -U distribute
sudo pip install django 

Verificamos la correcta instalación de django, para ello vemos la versión instalada (actualmente la 1.5.2):
 
django-admin --version


Crear la base de datos y el usuario de mysql que utiliza nuestro proyecto. Una vez conectados a mysql como administrador (root) indicaremos las siguientes ordenes:

mysql>CREATE DATABASE mi_base_de_datos;
mysql>CREATE USER 'mi_usuario'@'localhost' IDENTIFIED BY 'mi_clave';
mysql>GRANT ALL PRIVILEGES ON mi_base_de_datos.* TO 'mi_usuario'@'localhost';
mysql>FLUSH PRIVILEGES;

Copiamos o creamos el proyecto Django, en el caso que sea un proyecto nuevo:

$django-admin startproject mi_proyecto
$cd mi_proyecto
$python manage.py startapp mi_aplicacion

Editamos el fichero de configuración del proyecto (mi_proyecto/settings.py) para adaptar los valores al nuevo equipo, quedaría así:


DEBUG = False
TEMPLATE_DEBUG = DEBUG

ADMINS = (
    # ('Your Name', 'your_email@example.com'),
)

MANAGERS = ADMINS

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': 'mi_base_de_datos',                      # Or path to database file if using sqlite3.
        'USER': 'mi_usuario',                      # Not used with sqlite3.
        'PASSWORD': 'mi_clave',                  # Not used with sqlite3.
        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
    }
}

ALLOWED_HOSTS = ['midominio.es']

TIME_ZONE = 'Europe/Madrid'

LANGUAGE_CODE = 'es-es'

SITE_ID = 1

USE_I18N = True

USE_L10N = True

SE_TZ = True

MEDIA_ROOT = ''

MEDIA_URL = ''

STATIC_ROOT = ''

STATIC_URL = '/static/' 
 
ADMIN_MEDIA_PREFIX ='/static/admin/'
 
STATICFILES_DIRS = (
)

STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
#    'django.contrib.staticfiles.finders.DefaultStorageFinder',
)

TEMPLATE_LOADERS = (
    'django.template.loaders.filesystem.Loader',
    'django.template.loaders.app_directories.Loader',
#     'django.template.loaders.eggs.Loader',
)

MIDDLEWARE_CLASSES = (
    'django.middleware.common.CommonMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    # Uncomment the next line for simple clickjacking protection:
)

ROOT_URLCONF = 'mi_proyecto.urls'

WSGI_APPLICATION = 'mi_proyecto.wsgi.application'

TEMPLATE_DIRS = (
    '/home/usuario/mi_proyecto/mi_aplicacion/templates' 
    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
)

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # Uncomment the next line to enable the admin:
     'django.contrib.admin',
     'mi_aplicacion',
    # Uncomment the next line to enable admin documentation:
    # 'django.contrib.admindocs',
)
                  
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse'
        }
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'],
            'class': 'django.utils.log.AdminEmailHandler'
        }
    },
    'loggers': {
        'django.request': {
            'handlers': ['mail_admins'],
            'level': 'ERROR',
            'propagate': True,
        },
    }
}
                  
Si se trata de un proyecto nuevo, creamos las tablas de la base de datos y el usuario administrador mediante:


python manage.py syncdb

Podemos verificar el correcto funcionamiento del proyecto lanzando el servidor web de desarrollo de django. Para que funcione correctamente el servidor de desarrollo en el fichero de configuración tendremos que indicar Debug=True, en caso contrario obtendremos '500 server error':


python manage.py runserver 192.168.0.1:8001


Editamos el fichero de configuración de Apache  /etc/apache2/sites-available/default para indicar dentro del <VirtualHost *:80> la configuración del módulo mod_wsgi.

El fichero quedaría así:

<VirtualHost *:80>
        ServerAdmin webmaster@localhost

        WSGIDaemonProcess miproyecto python-path=/home/usuario/mi_proyecto/
        WSGIProcessGroup miproyecto
        WSGIScriptAlias / /home/usuario/mi_proyecto/mi_proyecto/wsgi.py
 
        Alias /static/admin/ /usr/local/lib/python2.7/dist-packages/django/contrib/admin/static/admin/
               
        <Directory /usr/local/lib/python2.7/dist-packages/django/contrib/admin/static/admin>
            Order allow,deny
            Allow from all
        </Directory>
 
        <Directory /home/usuario/mi_proyecto/mi_proyecto>
        <Files wsgi.py>
        Order deny,allow
        Allow from all
        </Files>
        </Directory> 
 
        ErrorLog ${APACHE_LOG_DIR}/error.log
        LogLevel warn
        CustomLog ${APACHE_LOG_DIR}/access.log combined
 
</VirtualHost> 
 
Reiniciamos el servidor apache y ya estaría listo:

 sudo service apache2 restart

domingo, agosto 25, 2013

Instalar la herramienta de musicología music21en ubuntu 13.04

music21

music21 está desarrollado en python así que tendremos que confirmar que  Ubuntu tenga instalado python, para ello podemos ver la versión instalada mediante:

python -V

obtendremos que la versión instalada es la 2.7.4 de python.

Ahora instalaremos algunos aplicaciones y paquetes de python adicionales que son utilizados por music21:

sudo apt-get install lilypond
sudo apt-get install musescore 
sudo apt-get install ipython
sudo apt-get install ipython-notebook
sudo apt-get install python-matplotlib
sudo apt-get install python-scipy 
sudo apt-get install python-pandas python-sympy python-nose

Instalamos music21:

sudo pip install music21


Ahora toca probar que todo se ha instalado correctamente, desde ipython de forma interactiva podemos recuperar una partitura de ejemplo y mostrarla mediante musescore:

from music21 import *
sBach = corpus.parse('bach/bwv7.7')
us = environment.UserSettings()
us['musicxmlPath'] = '/usr/bin/musescore'
sBach.show()

miércoles, julio 17, 2013

Editando vídeos desde la consola de GNU/Linux

Supongamos que partimos de un vídeo en formato DV (formato sin compresión habitual en las cámaras de vídeo) con la grabación completa y deseamos un fragmento. Por lo tanto, lo primero será reproducirlo para ver en que instantes de tiempo vamos a realizar los cortes. Tendremos que anotar el tiempo en que se inicia y la duración del fragmento que deseamos, todo en segundos.

Para extraer el fragmento se puede utilizar la herramienta avconv  de audio y vídeo del proyecto Libav, es un proyecto de software libre para la manipulación de datos multimedia.

Su instalación en Ubuntu es muy sencilla:
sudo apt-get install libav-tools


Para trocear un vídeo utilizaremos:

avconv -i video.dv -vcodec copy --ss <inicio-en-segundos> -t <duración-en-segundos> -acodec copy trozo.dv


Probablemente el fragmento de vídeo en formato DV ocupe mucho espacio, puede ser interesante reducir su peso y perder la menor calidad posible, para ello una buena opción puede ser el codec de vídeo H.264/MPEG-4 AVC.

Convertir un vídeo a ffv1 y pcm_s16le para preservación:
avconv -vsync passthrough -i trozo.dv -vcodec ffv1 -g 1 -acodec pcm_s16le -map 0:v -map 0:a trozo.mkv


Convertir un vídeo a H.264/MPEG-4 AVC:

avconv -i trozo.dv -vcodec libx264 trozo.mp4

También nos puede interesar convertir el video a WebM, un formato de audio y vídeo diseñado libre de royaltis para su utilización en HTML5,  el proyecto está respaldado por Google.

Convertir un vídeo a WebM:

avconv -i trozo.dv trozo.webm

En algunas ocasiones nos podemos encontrar que el vídeo sólo tiene un canal de audio grabado, es decir, sólo escuchamos el sonido por uno de nuestros altavoces. Para poder solucionarlo podemos utilizar la herramienta Sound eXchange (SoX), un editor de audio desde la línea de comandos publicado con licencia GNU por Chris Bagwell.

Primero habrá que extraer el audio del fragmento de vídeo, para ello haremos uso nuevamente de la herramienta avconv y lo pasaremos al formato FLAC (Free Lossless Audio Codec), FLAC es un codec de audio de baja compresión sin perdida de información, a diferencia de MP3.
FLAC es un formato abierto y libre de royaltis, soporta metadatos, posicionamiento rápido y almacenar la imagen de portada.

Extraer el audio de un vídeo:
avconv -i trozo.mp4 -f flac audio.flac

Unir varios vídeos en uno:mencoder -oac copy -ovc copy -o final.VOB trozo1.VOB trozo2.VOB

Duplicar el audio de un canal en el otro y aumentar el volumen al doble:
sox -v 2.0  audio.flac audio-completo.flac channels 1

Sox nos avisará en el caso que el aumento del volumen produzca saturación del canal, indicando el número de ondas que se han recortado en la operación. Un ejemplo de esta situación: sox WARN sox: `audio.flac' balancing clipped 638 samples; decrease volume?

Ahora toca incorporar el nuevo audio al trozo del vídeo del cual lo obtuvimos. Para ello utilizaremos avconv, donde le facilitaremos como flujo de vídeo (-i trozo.mp4) el trozo de vídeo del que partíamos y como flujo de audio (-i audio-completo.flac) el audio con el canal duplicado. También hay que indicarle a avconv que el codec de vídeo sea H.264/MPEG-4 AVC (-vcodec libx264):

avconv -i trozo.mp4 -i audio-completo.flac -map 0:0 -map 1:0 -vcodec libx264  trozo-final.mp4

En algunas ocasiones nos puede solicitar avconv un bit rate, en ese caso se lo podemos indicar de la siguiente forma para uno de 640kb/s:


avconv -i trozo.mp4 -i audio-completo.flac -map 0:0 -map 1:0 -vcodec libx264 -ab 640k trozo-final.mp4



Para duplicar el audio de varios vídeos se puede utilizar el siguiente script en python:


#!/usr/bin/python
import sys, os
 
for i in range(1,len(sys.argv)):
    fichero= str(sys.argv[i])
    fichero_salida="%s-st.%s" % (fichero.rsplit(".",1)[0],fichero.rsplit(".",1)[1])
    os.system("avconv -i %s -f flac kk.flac" % fichero)
    os.system("sox -v 2.0  kk.flac kk2.flac channels 1")
    os.system("avconv -i %s -i kk2.flac -map 0:0 -map 1:0 -vcodec libx264  %s" % (fichero,fichero_salida))
    if os.path.exists("kk.flac"):
      os.remove("kk.flac")
    if os.path.exists("kk2.flac"):
      os.remove("kk2.flac"
 
 
El script espera que le facilitemos los vídeos a procesar como argumentos, y los convertirá a vídeos con el codec H.264/MPEG-4 AVC, el sonido en los dos canales y con el volumen duplicado.

Rotar un vídeo 

ffmpeg -i input.mp4 -c copy -metadata:s:v:0 rotate=90 output.mp4
  

Capturar la pantalla en vídeo (screencast)
Tenemos que indicarle a avconv que tome la fuente del servidor Xorg (-f x11grab): avconv -f x11grab -s 1366x768 -r 25 -i :0.0 -same_quant video.mp4

jueves, julio 04, 2013

¿Cómo renombrar documentos obtenidos de digitalizar a una cara documentos a doble cara?

En algunas ocasiones necesitamos digitalizar documentos que están a doble cara pero nuestro escaner no tiene la posibilidad de voltear la página para digitalizar simultáneamente las dos caras, aunque si dispone de alimentador de páginas.

Por lo que podemos digitalizar en una primera etapa las caras impares y en una segunda etapa las caras pares empezando por el final (para no tener que reordenar todas las hojas).

Mediante el siguiente script en Python podemos renombrar todos los ficheros para que estén ordenador y poder procesarlos posteriormente:


import os 
ficheroImpar="caraA" #nombre del fichero de la digitalizacion de las caras impares
inicioFicheroImpar=1 #numero por el que comienza el fichero
finFicheroImpar=157 #numero por el que termina

ficheroParInverso="caraB"
inicioFicheroParInverso=157 #los documentos estan digitalizados empezando por el final
finFicheroParInverso=1

nuevoFichero="vcongreso"
extension=".tiff" #extension de los ficheros
digitos=3 #numero de digitos para completar con ceros

for numeroImpar in range (inicioFicheroImpar, finFicheroImpar+1):
  nombreImpar=ficheroImpar+str(numeroImpar).zfill(digitos)+extension
  nuevoNombreImpar=nuevoFichero+str(numeroImpar*2-1).zfill(digitos+2)+extension
  
  numeroPar=inicioFicheroParInverso-numeroImpar+1
  nombrePar=ficheroParInverso+str(numeroPar).zfill(digitos)+extension
  nuevoNombrePar=nuevoFichero+str(numeroImpar*2).zfill(digitos+2)+extension
  
  print "Renombrar: "+nombreImpar+" "+nuevoNombreImpar
  if os.path.exists(nombreImpar):
    os.rename(nombreImpar,nuevoNombreImpar)
  else:
    print "No existe: "+nombreImpar
    
  print "Renombrar: "+nombrePar+" "+nuevoNombrePar
  if os.path.exists(nombrePar):
    os.rename(nombrePar,nuevoNombrePar)
  else:
    print "No existe: "+nombrePar
 
 
Otra situación habitual es tener todas las páginas digitalizadas pero la numeración no sea consecutiva, por lo que el script anterior no funcionará. Primero renombramos todos los ficheros de forma consecutiva mediante el siguiente programa en python:



import os

fichero="cara B" #nombre del fichero de la digitalización de las caras impares
inicioFichero=1 #numero por el que comienza el fichero
finFichero=190

extension=".tiff" #extension de los ficheros
digitos=3 #numero de digitos para completar con ceros
nuevaSecuencia=1

for numero in range (inicioFichero, finFichero+1):
  nombre=fichero+str(numero).zfill(digitos)+extension
  nuevoNombre=fichero+str(nuevaSecuencia).zfill(digitos)+extension
  if os.path.exists(nombre):
    nuevaSecuencia=nuevaSecuencia+1
    print "Renombrar: "+nombre+" "+nuevoNombre
    os.rename(nombre,nuevoNombre)