~juliank/ftpsync/main

# Copyright (C) 2007 Julian Andres Klode <jak@jak-linux.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, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 

'''Core of ftpsync'''

__version__ = '0.1'

__copyright__ = 'Copyright (C) 2007 Julian Andres Klode'

 

from os.path import getsize as filesize

from os.path import exists as path_exists

from sha import new as newsum

 

def fsum(filename):

        '''Return the hex digest of a file without loading it all into memory'''

        fh = open(filename)

        digest = newsum()

        while 1:

                buf = fh.read(8192)

                if buf == "":

                        break

                digest.update(buf)

        fh.close()

        return digest.hexdigest()

 

def size(f):

        i=filesize(f)

        '''Return a human readable size'''

        if i >= (1024*1024*1024): 

                return str(i / 1024) + "G"

        elif i >= (1024*1024): 

                return str(i / 1024) + "M"

        elif i >= 1024: 

                return str(i / 1024) + "K"

        else:

                return str(i) + "B"

 

class conf:

        def __init__(self, fname):

                if path_exists(fname):

                        self.obj  = open(fname, 'r+')

                else:

                        open(fname, 'w').close()

                        self.obj  = open(fname, 'r+')

                self.data = {}

                self.read()

        def read(self, fname=None):

                if fname: 

                        if not path_exists(fname): return False

                        obj = file(fname)

                else:

                        obj = self.obj

                for key,val in (line.strip().split(':', 1) for line in obj):

                        self.data[key.strip()] = val.strip()

                if obj != self.obj: obj.close()

                return True

        def write(self, data=None):

                if data: self.append(data)

                for key,val in sorted(self.data.items()):

                        self.obj.write('%s: %s\n' % (key, val))

        def __setitem__(self, key, val):

                self.data[key] = val

        def __getitem__(self, key):

                return self.data[key]

        def items(self):

                return self.data.items()

        def append(self, data):

                for k,v in data.items():

                        if v: self.data[k] = str(v).strip()

 

 

class progressBar:

        """Print a progress bar

        Based on work by Randy Pargman

        Original Version at:

                http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/168639

        """

        def __init__(self, minValue = 0, maxValue = 10, totalWidth=24):

                self.progBar = "[]"   # This holds the progress bar string

                self.min = minValue

                self.max = maxValue

                self.span = maxValue - minValue

                self.width = totalWidth

                self.amount = 0       # When amount == max, we are 100% done 

                self.updateAmount(0)  # Build progress bar string

 

        def increaseAmount(self, newAmount = 0, text=""):

                return self.updateAmount(self.amount + newAmount, text)

 

        def updateAmount(self, newAmount = 0,text=""):

                if newAmount < self.min: newAmount = self.min

                if newAmount > self.max: newAmount = self.max

                self.amount = newAmount

 

                # Figure out the new percent done, round to an integer

                diffFromMin = float(self.amount - self.min)

                percentDone = (diffFromMin / float(self.span)) * 100.0

                percentDone = round(percentDone)

                percentDone = int(percentDone)

 

                # Figure out how many hash bars the percentage should be

                allFull = self.width - 2

                numHashes = (percentDone / 100.0) * allFull

                numHashes = int(round(numHashes))

 

                # build a progress bar with hashes and spaces

                self.progBar = "[" + '#'*numHashes + ' '*(allFull-numHashes) + "]"

 

                # figure out where to put the percentage, roughly centered

                percentPlace = (len(self.progBar) / 2) - len(str(percentDone)) 

                percentString = str(percentDone) + "%"

 

                # slice the percentage into the bar

                self.progBar = self.progBar[0:percentPlace] + percentString + self.progBar[percentPlace+len(percentString):] + text

 

        def __str__(self):

                return str(self.progBar)