# The MIT License
# Copyright (c) 2003 Doug Tolton
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
#

""" unzip.py
    Version: 1.1

    Extract a zip file to the directory provided
    It first creates the directory structure to house the files
    then it extracts the files to it.

    Sample usage:
    Windows command line
    unzip.py -p 10 -z c:\testfile.zip -o c:\testoutput
    
    Linux command line
    unzip.py -p 10 -z /tmp/testfile.zip -o /tmp/testoutput

    Python class:
    import unzip
    un = unzip.unzip()
    un.extract(r'c:\testfile.zip', r'c:\testoutput') # Windows
    un.extract(r'/tmp/testfile.zip', '/tmp/testoutput') # Linux
    
    By Doug Tolton
    
    Taken from http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/252508
    
    Updated by Daniel Jacobs to be OS-neutral and more stable.
"""

import sys
import zipfile
import os
import os.path
import getopt
import errno

class unzip:
    def __init__(self, verbose = False, percent = 10):
        self.verbose = verbose
        self.percent = percent
        
    def extract(self, file, dir):
        """ Extract all the files in the zip file, "file" to the directory "dir" with full path names."""
        if not dir.endswith(':') and not os.path.exists(dir):
            self._makedir(dir)

        zf = zipfile.ZipFile(file)

        # create directory structure to house files
        self._createstructure(file, dir)

        num_files = len(zf.namelist())
        percent = self.percent
        divisions = 100 / percent
        perc = int(num_files / divisions)

        # extract files to directory structure
        for i, name in enumerate(zf.namelist()):

            if self.verbose == True:
                print "Extracting %s" % name
            elif perc > 0 and (i % perc) == 0 and i > 0:
                complete = int (i / perc) * percent
                print "%s%% complete" % complete

            if not name.endswith('/'):
                # Normalise the path so that it is correct for the current OS
                localdirname = os.path.normpath(os.path.join(dir, os.path.dirname(name)))
                
                # Ensure that the directory hierarchy that contains the files exists so that 
                # writing to the file is valid. Note: some zip tools omit directory information 
                # and this will cause problems when trying to write file to non-existent directories.
                self._makedir(localdirname)
                    
                # Write the file
                outfile = open(os.path.join(localdirname, os.path.basename(name)), 'wb')
                outfile.write(zf.read(name))
                outfile.flush()
                outfile.close()
        
        zf.close()


    def _createstructure(self, file, dir):
        self._makedirs(self._listdirs(file), dir)


    def _makedirs(self, directories, basedir):
        """ Create any directories that don't currently exist """
        for dir in directories:
            curdir = os.path.join(basedir, dir)
            # Normalise path for current OS.
            curdir = os.path.normpath(curdir)
            self._makedir(curdir) 
            
    
    def _makedir(self, directory):
        """ Create a directory "safely", catching the "file exists" exception if the 
        directory has been created by another process. Creates all parent directories
        recursively as requied. """
        if not os.path.exists(directory):
            # In multi-threaded uses, it is possible that this directory 
            # has been made in the meantime. Catch this exception.
            try:
                os.makedirs(directory)
            except OSError, aOSError:
                # If the OSError is that the file exists then we are OK - this
                # might occur in a multi-threaded or multi-process environment;
                # otherwise re-raise the exception since it's something else bad.
                if aOSError.errno != errno.EEXIST:
                    raise aOSError

    def _listdirs(self, file):
        """ Grabs all the directories in the zip structure
        This is necessary to create the structure before trying
        to extract the file to it. """
        zf = zipfile.ZipFile(file)

        dirs = []

        for name in zf.namelist():
            if name.endswith('/'):
                if self.verbose == True:
                    print "Directory \"" + name + "\" will be made."
                dirs.append(name)
        
        zf.close()
        return dirs

def usage():
    print """usage: unzip.py -z <zipfile> -o <targetdir>
    <zipfile> is the source zipfile to extract
    <targetdir> is the target destination

    -z zipfile to extract
    -o target location
    -p sets the percentage notification
    -v sets the extraction to verbose (overrides -p)

    long options also work:
    --verbose
    --percent=10
    --zipfile=<zipfile>
    --outdir=<targetdir>"""
    

def main():
    shortargs = 'vhp:z:o:'
    longargs = ['verbose', 'help', 'percent=', 'zipfile=', 'outdir=']

    unzipper = unzip()

    try:
        opts, args = getopt.getopt(sys.argv[1:], shortargs, longargs)
    except getopt.GetoptError:
        usage()
        sys.exit(2)

    zipsource = ""
    zipdest = ""

    for o, a in opts:
        if o in ("-v", "--verbose"):
            unzipper.verbose = True
        if o in ("-p", "--percent"):
            if not unzipper.verbose == True:
                unzipper.percent = int(a)
        if o in ("-z", "--zipfile"):
            zipsource = a
        if o in ("-o", "--outdir"):
            zipdest = a
        if o in ("-h", "--help"):
            usage()
            sys.exit()

    if zipsource == "" or zipdest == "":
        usage()
        sys.exit()
            
    unzipper.extract(zipsource, zipdest)

if __name__ == '__main__': main()