332 lines
11 KiB
Python
332 lines
11 KiB
Python
#! /usr/bin/env python
|
|
# -*- coding:utf-8 -*-
|
|
|
|
# pywiUpload - Piwigo gallery generator
|
|
# Copyright (C) 2009 saimon.org
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; If not, see http://www.gnu.org/licenses/
|
|
|
|
"""Prepare a gallery of images for Piwigo
|
|
|
|
This script resize images, create thumbnails with some options
|
|
(rename images, squared thumbs, ...), and upload images to a FTP server.
|
|
"""
|
|
|
|
__author__ = "Saimon (contact at saimon.org)"
|
|
__version__ = "0.7"
|
|
__date__ = "20090628"
|
|
__copyright__ = "Copyright (c) 2009 saimon.org"
|
|
__license__ = "GPL"
|
|
|
|
import os,sys
|
|
import getpass
|
|
import Image,ImageDraw
|
|
from ftplib import FTP
|
|
from configobj import ConfigObj
|
|
|
|
class pywiUpload:
|
|
"Prepare a gallery of images for Piwigo"
|
|
|
|
def __init__(self, conf=None):
|
|
self.filepath = ""
|
|
self.galname = ""
|
|
self.params = {}
|
|
configFile = conf if conf \
|
|
else os.path.join(sys.path[0], 'pywiUpload.conf')
|
|
self.readParams(configFile)
|
|
|
|
def getPath(self, pathname):
|
|
"return abslolute path from params dict"
|
|
return os.path.join(self.filepath, self.params[pathname]) \
|
|
if self.params.has_key(pathname) else ""
|
|
|
|
def createGallery(self, path):
|
|
"create image gallery"
|
|
imgFileList = self.listFilesInDir(path)
|
|
print "Found %i images in %s" % (len(imgFileList), path)
|
|
|
|
while self.galname == "":
|
|
self.galname = raw_input('Enter gallery name: ')
|
|
|
|
self.filepath = os.path.join(os.path.dirname(imgFileList[0]),
|
|
self.galname)
|
|
|
|
print "Create output dir ..."
|
|
try:
|
|
os.makedirs(self.getPath('thumb_dir'))
|
|
except OSError:
|
|
pass
|
|
|
|
if self.params['bigimg']:
|
|
try:
|
|
os.mkdir(self.getPath('bigimg_dir'))
|
|
except OSError:
|
|
pass
|
|
|
|
outFileList = self.processImages(imgFileList)
|
|
|
|
upload = raw_input("Upload images to your FTP server ? (y/[n]) ")
|
|
if upload == 'y':
|
|
self.ftpUpload(outFileList)
|
|
|
|
def processImages(self,imgFileList):
|
|
"prepare images"
|
|
imgFileList.sort()
|
|
outImgList = []
|
|
outThumbList = []
|
|
outBigImgList = []
|
|
|
|
renImg = raw_input("Rename images ('name01.jpg') ? (y/[n]) ")
|
|
if renImg == 'y':
|
|
count = 1
|
|
imgname = raw_input('Enter new image name: ')
|
|
nfill = 2 if (len(imgFileList)<100) else 3
|
|
|
|
if self.params['copyright']:
|
|
copyrightmsg = raw_input('Enter copyright message: ')
|
|
copyrightmsg = '\xa9 ' + copyrightmsg
|
|
|
|
# loop on images
|
|
for f in imgFileList:
|
|
filename = os.path.split(f)[1]
|
|
im = Image.open(f)
|
|
|
|
if renImg == 'y':
|
|
filename = imgname+str(count).zfill(nfill)+'.jpg'
|
|
print "%s > %s" % (os.path.split(f)[1],filename)
|
|
count += 1
|
|
else:
|
|
print "%s" % filename
|
|
|
|
if self.params['bigimg']:
|
|
im.save(os.path.join(self.getPath('bigimg_dir'),filename),
|
|
quality=self.params['jpgquality'])
|
|
outBigImgList.append(os.path.join(self.getPath('bigimg_dir'),
|
|
filename))
|
|
|
|
# resize image
|
|
if im.size[0] > im.size[1]:
|
|
im_size = (self.params['im_width'],self.params['im_height'])
|
|
else:
|
|
im_size = (self.params['im_height'],self.params['im_width'])
|
|
im2 = im.resize(im_size,Image.ANTIALIAS)
|
|
|
|
# create thumbnail
|
|
if self.params['squarethumb']:
|
|
if im.size[0] > im.size[1]:
|
|
offset = (im.size[0] - im.size[1])/2
|
|
box = (offset,0,im.size[0]-offset,im.size[1])
|
|
else:
|
|
offset = (im.size[1] - im.size[0])/2
|
|
box = (0,offset,im.size[0],im.size[1]-offset)
|
|
|
|
im = im.crop(box)
|
|
thumbsize = (self.params['thumb_width'],self.params['thumb_width'])
|
|
else:
|
|
thumbsize = (self.params['thumb_width'],self.params['thumb_height'])
|
|
|
|
im.thumbnail(thumbsize,Image.ANTIALIAS)
|
|
|
|
# copyright
|
|
if self.params['copyright']:
|
|
draw=ImageDraw.Draw(im2)
|
|
draw.text((5,im2.size[1]-15),copyrightmsg)
|
|
|
|
# save
|
|
im.save(os.path.join(self.getPath('thumb_dir'),
|
|
self.params['thumb_prefix']+filename),
|
|
quality=self.params['jpgquality'])
|
|
im2.save(os.path.join(self.filepath,filename),
|
|
quality=self.params['jpgquality'])
|
|
|
|
outThumbList.append(os.path.join(self.getPath('thumb_dir'),
|
|
self.params['thumb_prefix']+filename))
|
|
outImgList.append(os.path.join(self.filepath,filename))
|
|
|
|
# exif metadatas
|
|
if self.params['exif']:
|
|
self.processExif(f, os.path.join(self.filepath,filename))
|
|
|
|
return [outImgList,outThumbList,outBigImgList]
|
|
|
|
def processExif(self, srcfile, dstfile):
|
|
"copy exif metadatas from src to dest images"
|
|
if self.params['exif']:
|
|
try:
|
|
import pyexiv2
|
|
except ImportError:
|
|
self.params['exif']=0
|
|
print "Error: install pyexiv2 module to use exif metadatas."
|
|
return
|
|
|
|
if pyexiv2.version_info[1] == 1:
|
|
src = pyexiv2.Image(srcfile)
|
|
dst = pyexiv2.Image(dstfile)
|
|
src.readMetadata()
|
|
dst.readMetadata()
|
|
try:
|
|
src.copyMetadataTo(dst)
|
|
except:
|
|
print "Error: metadata not copied for %s." % srcfile
|
|
return
|
|
dst.writeMetadata()
|
|
else:
|
|
src = pyexiv2.ImageMetadata(srcfile)
|
|
dst = pyexiv2.ImageMetadata(dstfile)
|
|
src.read()
|
|
dst.read()
|
|
try:
|
|
src.copy(dst)
|
|
except:
|
|
print "Error: metadata not copied for %s." % srcfile
|
|
return
|
|
dst.write()
|
|
|
|
|
|
def ftpUpload(self,imgFileList):
|
|
"Upload images to a FTP server"
|
|
print "Connect to %s ..." % self.params['host']
|
|
try:
|
|
password = getpass.getpass()
|
|
ftp = FTP(self.params['host'],self.params['user'],password)
|
|
except:
|
|
print "FTP connexion error, abort."
|
|
return
|
|
print "Connected !"
|
|
|
|
try:
|
|
ftp.cwd(self.params['piwigo_dir'])
|
|
ftp.cwd('galleries')
|
|
except:
|
|
print "Error: wrong 'galleries' path"
|
|
|
|
print "\nChoose the category in which your gallery will be uploaded:"
|
|
print "- enter a number to go in a sub-category"
|
|
print "- choose '.' for uploading in the current directory"
|
|
|
|
# choose upload dir
|
|
while 1:
|
|
i = 1
|
|
ftpdir = [f for f in ftp.nlst()
|
|
if f not in self.params['fileExclude']]
|
|
print "\n"
|
|
for dir in ftpdir:
|
|
print "%i: %s" % (i,dir)
|
|
i += 1
|
|
|
|
try:
|
|
choice = int(raw_input("Enter directory number: ")) - 1
|
|
if ftpdir[choice] == '.': break
|
|
ftp.cwd(ftpdir[choice])
|
|
except:
|
|
print "Error: invalid choice"
|
|
|
|
print "Upload files to %s directory:" % self.galname
|
|
try:
|
|
ftp.mkd(self.galname)
|
|
except:
|
|
choice = raw_input("Directory exist, continue ? (y/[n]) ")
|
|
if choice != 'y':
|
|
ftp.close()
|
|
return
|
|
|
|
# upload images
|
|
ftp.cwd(self.galname)
|
|
self.fileUpload(ftp,imgFileList[0])
|
|
|
|
# upload thumbnails
|
|
try:
|
|
ftp.mkd(self.params['thumb_dir'])
|
|
except:
|
|
pass
|
|
ftp.cwd(self.params['thumb_dir'])
|
|
self.fileUpload(ftp,imgFileList[1])
|
|
|
|
# upload big images
|
|
if self.params['bigimg']:
|
|
ftp.cwd('..')
|
|
try:
|
|
ftp.mkd(self.params['bigimg_dir'])
|
|
except:
|
|
pass
|
|
ftp.cwd(self.params['bigimg_dir'])
|
|
self.fileUpload(ftp,imgFileList[2])
|
|
|
|
# close FTP connection
|
|
ftp.quit()
|
|
|
|
def fileUpload(self,ftp,imgFileList):
|
|
"Upload list of files in the current working directory of ftp"
|
|
for f in imgFileList:
|
|
print "Upload %s ..." % os.path.basename(f)
|
|
file = open(f, 'rb')
|
|
try:
|
|
ftp.storbinary('STOR '+os.path.basename(f), file)
|
|
except:
|
|
print "Tranfer error !"
|
|
file.close()
|
|
|
|
def listFilesInDir(self, directory):
|
|
"get list of files of particular extensions"
|
|
fileList = [os.path.normcase(f) for f in os.listdir(directory)]
|
|
return [os.path.join(directory, f) for f in fileList \
|
|
if os.path.splitext(f)[1] in self.params['fileExtList']]
|
|
|
|
def readParams(self,configFile):
|
|
"Read params from a config file"
|
|
try:
|
|
print "Reading parameters ..."
|
|
self.params = ConfigObj(configFile,file_error=True)
|
|
except:
|
|
sys.exit("Config file not found, exiting ...")
|
|
|
|
# convert types
|
|
self.params["im_width"] = int(self.params["im_width"])
|
|
self.params["im_height"] = int(self.params["im_height"])
|
|
self.params["thumb_width"] = int(self.params["thumb_width"])
|
|
self.params["thumb_height"] = int(self.params["thumb_height"])
|
|
self.params["bigimg"] = int(self.params["bigimg"])
|
|
self.params["squarethumb"] = int(self.params["squarethumb"])
|
|
self.params["jpgquality"] = int(self.params["jpgquality"])
|
|
self.params["exif"] = int(self.params["exif"])
|
|
self.params["copyright"] = int(self.params["copyright"])
|
|
|
|
if __name__ == "__main__":
|
|
from optparse import OptionParser
|
|
|
|
usage = "usage: %prog [options]"
|
|
version="version %s, %s" % (__version__, __date__)
|
|
parser = OptionParser(usage=usage, version="%prog "+version)
|
|
|
|
parser.add_option("-c", "--config", dest="config",
|
|
help="specify an alternative config file")
|
|
parser.add_option("-i", "--imgpath", dest="imgpath",
|
|
help="specify images path")
|
|
|
|
(options, args) = parser.parse_args()
|
|
|
|
if options.config:
|
|
gallery = pywiUpload(conf=options.config)
|
|
else:
|
|
gallery = pywiUpload()
|
|
|
|
if options.imgpath:
|
|
path = options.imgpath
|
|
else:
|
|
path = os.getcwd()
|
|
|
|
gallery.createGallery(path)
|
|
|
|
print "Finished !\n"
|