def exe():
    makedirs( DIST_DIR )
    shutil.copy( "pyautocore.pyd", DIST_DIR )
    shutil.copy( "__init__.py", DIST_DIR )
    shutil.copy( "pyauto_const.py", DIST_DIR )
    shutil.copy( "pyauto_input.py", DIST_DIR )
    rmtree( DIST_DIR + "/sample" )
    shutil.copytree( "sample", DIST_DIR + "/sample", ignore=shutil.ignore_patterns(".svn","*.pyc","*.pyo") )
    rmtree( DIST_DIR + "/doc" )
    shutil.copytree( "doc/html", DIST_DIR + "/doc", ignore=shutil.ignore_patterns(".svn") )

    if 1:
        os.chdir("dist")
        createZip( "pyauto.zip", DIST_FILES )
        os.chdir("..")
    
    fd = open("dist/pyauto.zip","rb")
    m = hashlib.md5()
    while 1:
        data = fd.read( 1024 * 1024 )
        if not data: break
        m.update(data)
    fd.close()
    print( "" )
    print( m.hexdigest() )

    def prepare(self):
        root_dir = self.get_bindings_root_directory()

        # Create directories
        common.recreate_directory(self.tmp_dir)
        os.makedirs(self.tmp_examples_dir)
        os.makedirs(self.tmp_source_dir)
        os.makedirs(self.tmp_build_dir)

        # Copy blockly and closure-library to build directory
        shutil.copytree(os.path.join(root_dir, '..', '..', 'tvpl-blockly'), self.tmp_build_blockly_dir,
                        ignore=shutil.ignore_patterns('*/.git'))
        shutil.copytree(os.path.join(root_dir, '..', '..', 'tvpl-closure-library'), self.tmp_build_closure_library_dir,
                        ignore=shutil.ignore_patterns('*/.git', '*_test.js'))

        # Copy css/, js/, index.html and programEditor.html
        shutil.copytree(os.path.join(root_dir, 'css'), os.path.join(self.tmp_source_dir, 'css'))
        shutil.copytree(os.path.join(root_dir, 'js'), os.path.join(self.tmp_source_dir, 'js'))
        shutil.copy(os.path.join(root_dir, 'index.html'), self.tmp_source_dir)
        shutil.copy(os.path.join(root_dir, 'programEditor.html'), self.tmp_source_dir)

        # Copy changelog.txt and readme.txt
        shutil.copy(os.path.join(root_dir, 'changelog.txt'),self.tmp_dir)
        shutil.copy(os.path.join(root_dir, 'readme.txt'),self.tmp_dir)

        # Generate JavaScript bindings
        with common.ChangedDirectory(os.path.join(root_dir, '..', 'javascript')):
            common.execute(['python', 'generate_javascript_bindings.py'])
            common.execute(['python', 'generate_javascript_zip.py'])

        shutil.copy(os.path.join(self.tmp_javascript_dir, 'browser', 'source', 'Tinkerforge.js'),
                    os.path.join(self.tmp_source_dir, 'js', 'Tinkerforge.js'))

    def save_firefox_profile(self, remove_old=False):
        """Function to save the firefox profile to the permanant one"""
        self.logger.info("Saving profile from %s to %s" % (self._profile.path, self._profile_path))

        if remove_old:
            if os.path.exists(self._profile_path):
                try:
                    shutil.rmtree(self._profile_path)
                except OSError:
                    pass

            shutil.copytree(os.path.join(self._profile.path), self._profile_path,
                            ignore=shutil.ignore_patterns("parent.lock", "lock", ".parentlock"))
        else:
            for item in os.listdir(self._profile.path):
                if item in ["parent.lock", "lock", ".parentlock"]:
                    continue
                s = os.path.join(self._profile.path, item)
                d = os.path.join(self._profile_path, item)
                if os.path.isdir(s):
                    shutil.copytree(s, d,
                                    ignore=shutil.ignore_patterns("parent.lock", "lock", ".parentlock"))
                else:
                    shutil.copy2(s, d)

        with open(os.path.join(self._profile_path, self._LOCAL_STORAGE_FILE), 'w') as f:
            f.write(dumps(self.get_local_storage()))

def _perform_utilproc(src, cmd_args,
                      on_cmd=None, include=None, ignore=None, verbose=False):
    if include is None:
        return

    names = os.listdir(src)
    inc_p = ignore_patterns(*include)
    include_names = inc_p(src, names)

    if ignore is None:
        ignore_files = set()
    else:
        patterns = ignore_patterns(*ignore)
        ignore_files = patterns(src, names)

    for name in names:
        if name in ignore_files:
            if verbose:
                cprint.warning('ignored: ', os.path.join(src, name))
            continue

        srcname = os.path.join(src, name)
        if not os.path.isdir(srcname) and name not in include_names:
            if verbose:
                cprint.warning('excluded: ', os.path.join(src, name))
            continue

        try:
            if os.path.isdir(srcname):
                _perform_utilproc(srcname,
                                  cmd_args,
                                  on_cmd=on_cmd,
                                  include=include,
                                  ignore=ignore,
                                  verbose=verbose)
            else:
                args = [a if a != '{FILENAME}' else srcname for a in cmd_args]
                if verbose:
                    cprint.ok(str(' '.join(c for c in args)))

                p = Popen(args, stdout=PIPE, stderr=PIPE)
                stdout, stderr = p.communicate()

                if p.returncode != 0:
                    cprint.error('ERROR PROCESSING: ', '{0} -> {1}'.
                                 format(srcname, args))
                    cprint.error(stderr)
                    continue

                if on_cmd is not None:
                    on_cmd(srcname, stdout)
                elif verbose:
                    cprint(stdout)

        except (IOError, os.error) as err:
            msg = "Failed to perform util on {0}: ".format(srcname, str(err))
            return (False, msg)

    return (True, None)

    def do_copy(self, src, dest, perms=None):
        """Copy the src dir to the dest dir omitting the self.ignore globs."""
        if os.path.isdir(self.dest_path):
            self.copy_if_missing(src, dest, ignore=shutil.ignore_patterns(*self.ignore))
        else:
            shutil.copytree(src, dest, ignore=shutil.ignore_patterns(*self.ignore))

        if perms:
            for dirname, dirnames, filenames in os.walk(dest):
                for filename in filenames:
                    os.chmod(os.path.join(dirname, filename), perms)

def _copy_data_files(rpath, datadir, rdatadir):
    try:
        shutil.copytree(os.path.join(DATA_DIR, rpath), os.path.join(datadir,
                    rpath), ignore=shutil.ignore_patterns('*.pyc', '*.pyo'))
    except FileNotFoundError:
        pass

    try:
        shutil.copytree(os.path.join(RDATA_DIR, rpath), os.path.join(rdatadir,
                    rpath), ignore=shutil.ignore_patterns('*.pyc', '*.pyo'))
    except FileNotFoundError:
        pass

def cmd_co(db, tree_name, path):
    check_path_shape(path)
    curs = db.cursor()

    # sanity checks
    curs.execute("SELECT * FROM checkout WHERE pkgpath = ?", (path, ))
    if len(curs.fetchall()) != 0:
        print("Error: Already checked out in %s" % \
            os.path.join(MYSTUFF_PATH, path))
        exit_nicely(db)

    if tree_name == "wip":
        tree = WIP_PATH
        origin = ORIGIN_WIP
    elif tree_name ==  "main":
        tree = PORTS_PATH
        origin = ORIGIN_PORTS
    else:
        print("Error: Bad tree path. Should be either 'wip' or 'main'")
        exit_nicely(db)

    if os.path.exists(os.path.join(MYSTUFF_PATH, path)):
        print("error: Destination path exists: %s" % \
            os.path.join(MYSTUFF_PATH, path))
        exit_nicely(db)

    if not os.path.exists(os.path.join(tree, path)):
        print("error: Source path does not exist: %s" % \
            os.path.join(tree, path))
        exit_nicely(db)

    # We might have to create the category directory
    category_dir = os.path.dirname(os.path.join(MYSTUFF_PATH, path))
    if not os.path.exists(category_dir):
        os.mkdir(category_dir)

    # Copy in from source
    shutil.copytree( \
        os.path.join(tree, path), os.path.join(MYSTUFF_PATH, path), \
        ignore=shutil.ignore_patterns("CVS"))

    # Archive away a copy for merges
    shutil.copytree(os.path.join(tree, path), os.path.join(ARCHIVE_PATH, path), \
        ignore=shutil.ignore_patterns("CVS"))

    # Update db
    curs.execute("INSERT INTO checkout (pkgpath, origin, flags) VALUES " + \
        "(?, ?, ?)", (path, origin, 0))
    db.commit()

    print("Port checked out into %s" % (os.path.join(MYSTUFF_PATH, path)))

def copy_dirs():
	if os.path.exists("dist") == False:
		os.mkdir("dist")
		
	if os.path.exists(os.path.join("dist", "docs")):
		shutil.rmtree(os.path.join("dist", "docs"))
	if os.path.exists(os.path.join("dist", "bin")):
		shutil.rmtree(os.path.join("dist", "bin"))
	if os.path.exists(os.path.join("dist", "etc")):
		shutil.rmtree(os.path.join("dist", "etc"))
	if os.path.exists(os.path.join("dist", "interface")):
		shutil.rmtree(os.path.join("dist", "interface"))
	if os.path.exists(os.path.join("dist", "lib")):
		shutil.rmtree(os.path.join("dist", "lib"))
	if os.path.exists(os.path.join("dist", "pixmaps")):
		shutil.rmtree(os.path.join("dist", "pixmaps"))
	if os.path.exists(os.path.join("dist", "share")):
		shutil.rmtree(os.path.join("dist", "share"))
	if os.path.exists(os.path.join("dist", "po")):
		shutil.rmtree(os.path.join("dist", "po"))
		
	shutil.copytree("docs", os.path.join("dist", "docs"), ignore=shutil.ignore_patterns('.git*'))
	shutil.copytree("bin", os.path.join("dist", "bin"), ignore=shutil.ignore_patterns('.git*'))
	shutil.copytree("etc", os.path.join("dist", "etc"), ignore=shutil.ignore_patterns('.git*'))
	shutil.copytree("interface", os.path.join("dist", "interface"), ignore=shutil.ignore_patterns('.git*'))
	shutil.copytree("lib", os.path.join("dist", "lib"), ignore=shutil.ignore_patterns('.git*'))
	shutil.copytree("pixmaps", os.path.join("dist", "pixmaps"), ignore=shutil.ignore_patterns('.git*'))
	shutil.copytree("share", os.path.join("dist", "share"), ignore=shutil.ignore_patterns('.git*'))
	shutil.copytree("po", os.path.join("dist", "po"), ignore=shutil.ignore_patterns('.git*'))

def copy_application(src, dst):

    application_name = os.path.basename(src)

    if not os.path.exists(dst):
        shutil.copytree(src, dst, ignore=shutil.ignore_patterns(IGNORE_PATTERNS))
        os.remove(dst+"/__init__.py")
        os.remove(dst+"/__init__.pyc")
        
        app_files = os.listdir(dst+"/application/")
        app_files = [dst+"/application/"+filename for filename in app_files]
        
        for file in app_files:
            shutil.move(file, dst)
    
        os.rmdir(dst+"/application/")

        #every wordpress plugin becomes a new application
        if (dst.find("wordpress") != -1 and os.path.exists(dst+"/plugins/")):
            plugins = os.listdir(dst+"/plugins/")

            if(".DS_Store" in plugins):
                plugins.remove(".DS_Store")

            plugins = [dst+"/plugins/"+filename for filename in plugins]
            
            for plugin in plugins:
                
                plugin_name = os.path.basename(plugin)
                plugin_dst = settings.applications_path+application_name+"_"+plugin_name
                
                shutil.copytree(dst,plugin_dst, ignore=shutil.ignore_patterns(IGNORE_PATTERNS))
                
                os.makedirs(plugin_dst+"/wp-content/plugins/"+plugin_name.split("_")[0]+"/")

                if(os.path.isfile(plugin_dst+"/plugins/"+plugin_name+"/database.sql")):
                    shutil.move(plugin_dst+"/plugins/"+plugin_name+"/database.sql", plugin_dst+"/wp-content/plugins/"+plugin_name.split("_")[0]+"/")
                
                plugin_files = os.listdir(plugin_dst+"/plugins/"+plugin_name+"/plugin/")
                plugin_files = [plugin_dst+"/plugins/"+plugin_name+"/plugin/"+filename for filename in plugin_files]
                
                for plugin_file in plugin_files:
                    shutil.move(plugin_file, plugin_dst+"/wp-content/plugins/"+plugin_name.split("_")[0]+"/")

                shutil.rmtree(plugin_dst+"/plugins/")
                generate_configuration(application_name+"_"+plugin_name, plugin_name=plugin_name)

    else:
        print("application " +dst+ " already imported")

    def install(self, spec, prefix):
        """Install under the projectdir (== prefix/name-version)"""
        self.build(spec, prefix)  # Should be a separate phase
        opts = self.wm_options

        # Fairly ugly since intermediate targets are scattered inside sources
        appdir = 'applications'
        mkdirp(self.projectdir, join_path(self.projectdir, appdir))

        # Retain build log file
        out = "spack-build.out"
        if isfile(out):
            install(out, join_path(self.projectdir, "log." + opts))

        # All top-level files, except spack build info and possibly Allwmake
        if '+source' in spec:
            ignored = re.compile(r'^spack-.*')
        else:
            ignored = re.compile(r'^(Allclean|Allwmake|spack-).*')

        files = [
            f for f in glob.glob("*") if isfile(f) and not ignored.search(f)
        ]
        for f in files:
            install(f, self.projectdir)

        # Install directories. install applications/bin directly
        for d in ['bin', 'etc', 'wmake', 'lib', join_path(appdir, 'bin')]:
            install_tree(
                d,
                join_path(self.projectdir, d))

        if '+source' in spec:
            subitem = join_path(appdir, 'Allwmake')
            install(subitem, join_path(self.projectdir, subitem))

            ignored = [opts]  # Intermediate targets
            for d in ['src', 'tutorials']:
                install_tree(
                    d,
                    join_path(self.projectdir, d),
                    ignore=shutil.ignore_patterns(*ignored))

            for d in ['solvers', 'utilities']:
                install_tree(
                    join_path(appdir, d),
                    join_path(self.projectdir, appdir, d),
                    ignore=shutil.ignore_patterns(*ignored))

def virtualenv(tmpdir, monkeypatch):
    """
    Return a virtual environment which is unique to each test function
    invocation created inside of a sub directory of the test function's
    temporary directory. The returned object is a
    ``tests.lib.venv.VirtualEnvironment`` object.
    """
    # Force shutil to use the older method of rmtree that didn't use the fd
    # functions. These seem to fail on Travis (and only on Travis).
    monkeypatch.setattr(shutil, "_use_fd_functions", False, raising=False)

    # Copy over our source tree so that each virtual environment is self
    # contained
    pip_src = tmpdir.join("pip_src").abspath
    shutil.copytree(
        SRC_DIR,
        pip_src,
        ignore=shutil.ignore_patterns(
            "*.pyc", "tests", "pip.egg-info", "build", "dist", ".tox",
        ),
    )

    # Create the virtual environment
    venv = VirtualEnvironment.create(
        tmpdir.join("workspace", "venv"),
        pip_source_dir=pip_src,
    )

    # Undo our monkeypatching of shutil
    monkeypatch.undo()

    return venv

    def __init__(self,profile_directory=None):
        """
        Initialises a new instance of a Firefox Profile

        :args:
         - profile_directory: Directory of profile that you want to use.
           This defaults to None and will create a new
           directory when object is created.
        """
        self.default_preferences = copy.deepcopy(
            FirefoxProfile.DEFAULT_PREFERENCES)
        self.profile_dir = profile_directory
        self.tempfolder = None
        if self.profile_dir is None:
            self.profile_dir = self._create_tempfolder()
        else:
            self.tempfolder = tempfile.mkdtemp()
            newprof = os.path.join(self.tempfolder,
                "webdriver-py-profilecopy")
            shutil.copytree(self.profile_dir, newprof,
                ignore=shutil.ignore_patterns("parent.lock", "lock", ".parentlock"))
            self.profile_dir = newprof
            self._read_existing_userjs()
        self.extensionsDir = os.path.join(self.profile_dir, "extensions")
        self.userPrefs = os.path.join(self.profile_dir, "user.js")

def packaging(src):
	"""
		reading install.rdf and packaging a xpi file. 
		for example: 
			xxx-0.1.xpi
	"""
	work_copy = osp.dirname(src)
	
	addon_info = "".join(open(work_copy + osp.sep + "install.rdf"))
	addon_name = re.search("(?<=em\:name\=\").*(?=\")",addon_info).group(0)
	addon_version =  re.search("(?<=em\:version\=\").*(?=\")",addon_info).group(0)

	temp_copy_base = tempfile.mkdtemp()
	temp_copy = osp.join(temp_copy_base,addon_name)
	
	xpi_name = "%s-%s.xpi" % (addon_name,addon_version)
	xpi_fullpath = osp.join(work_copy,xpi_name);
	
	print """
	Add-on    : %s
	Version   : %s
	Work Copy : %s
	Temp Copy : %s
	XPI File  : %s
	""" % (addon_name,addon_version,work_copy,temp_copy, xpi_name)

	print "copying work to temp dir..."
	copytree(work_copy,temp_copy,ignore=ignore_patterns('scriptdemo','*.xpi','.*','*.bat','*.py','*LOG','*~','*.swp'))

	print "packaging xpi..."
	compress(temp_copy,xpi_fullpath);

	print "cleaning..."
	rmtree(temp_copy_base)

def _writeInputsFunction(i, f, epoch, inputpath, coorname):
    regex = re.compile('(e\d+s\d+)_')
    frameNum = f.frame
    piece = f.piece
    if f.sim.parent is None:
        currSim = f.sim
    else:
        currSim = f.sim.parent

    traj = currSim.trajectory[piece]
    if currSim.input is None:
        raise NameError('Could not find input folder in simulation lists. Cannot create new simulations.')

    wuName = _simName(traj)
    res = regex.search(wuName)
    if res:  # If we are running on top of adaptive, use the first name part for the next sim name
        wuName = res.group(1)

    # create new job directory
    newName = 'e' + str(epoch) + 's' + str(i + 1) + '_' + wuName + 'p' + str(piece) + 'f' + str(frameNum)
    newDir = path.join(inputpath, newName, '')

    # copy previous input directory including input files
    copytree(currSim.input, newDir, symlinks=False, ignore=ignore_patterns('*.coor', '*.rst', '*.out', *_IGNORE_EXTENSIONS))

    # overwrite input file with new one. frameNum + 1 as catdcd does 1 based indexing

    mol = Molecule(currSim.molfile)  # Always read the mol file, otherwise it does not work if we need to save a PDB as coorname
    mol.read(traj)
    mol.dropFrames(keep=frameNum)  # Making sure only specific frame to write is kept
    mol.write(path.join(newDir, coorname))

    def _init(self):
        from natsort import natsorted
        folders = natsorted(glob(path.join(self.generatorspath, '*', ''))) # I need the extra ''  to add a finishing /
        if len(folders) == 0:
            logger.info('Generators folder has no subdirectories, using folder itself')
            folders.append(self.generatorspath)

        numF = len(folders)
        numCopies = np.ones(numF, dtype=int) * int(np.floor(self.nmax / numF))
        numExtra = np.mod(self.nmax, numF)
        extraChoices = np.random.choice(numF, numExtra, replace=False) # draw the extra
        numCopies[extraChoices] += 1
        # numCopies = numCopies + np.random.multinomial(numExtra, [1/numF]*numF)  # draw the extra equally from a flat distribution
        if not path.exists(self.inputpath):
            makedirs(self.inputpath)

        # Check if epoch 1 directories already exist in the input folder
        existing = glob(path.join(self.inputpath, 'e1s*'))
        if len(existing) != 0:
            raise NameError('Epoch 1 directories already exist.')

        k = 1
        for i in range(numF):
            for j in range(numCopies[i]):
                name = _simName(folders[i])
                inputdir = path.join(self.inputpath, 'e1s' + str(k) + '_' + name)
                #src = path.join(self.generatorspath, name, '*')
                src = folders[i]
                copytree(src, inputdir, symlinks=True, ignore=ignore_patterns(*_IGNORE_EXTENSIONS))
                k += 1

def svn_source(meta):
    """ Download a source from SVN repo. """

    def parse_bool(s):
        return str(s).lower().strip() in ("yes", "true", "1", "on")

    svn = external.find_executable("svn")
    if not svn:
        sys.exit("Error: svn is not installed")
    svn_url = meta["svn_url"]
    svn_revision = meta.get("svn_rev") or "head"
    svn_ignore_externals = parse_bool(meta.get("svn_ignore_externals") or "no")
    if not isdir(SVN_CACHE):
        os.makedirs(SVN_CACHE)
    svn_dn = svn_url.split(":", 1)[-1].replace("/", "_").replace(":", "_")
    cache_repo = join(SVN_CACHE, svn_dn)
    if svn_ignore_externals:
        extra_args = ["--ignore-externals"]
    else:
        extra_args = []
    if isdir(cache_repo):
        check_call([svn, "up", "-r", svn_revision] + extra_args, cwd=cache_repo)
    else:
        check_call([svn, "co", "-r", svn_revision] + extra_args + [svn_url, cache_repo])
        assert isdir(cache_repo)

    # now copy into work directory
    copytree(cache_repo, WORK_DIR, ignore=ignore_patterns(".svn"))
    return WORK_DIR

def copy_packages(packages_names, dest, create_links=False, extra_ignores=None):
    """Copy python packages ``packages_names`` to ``dest``, spurious data.

    Copy will happen without tests, testdata, mercurial data or C extension module source with it.
    ``py2app`` include and exclude rules are **quite** funky, and doing this is the only reliable
    way to make sure we don't end up with useless stuff in our app.
    """
    if ISWINDOWS:
        create_links = False
    if not extra_ignores:
        extra_ignores = []
    ignore = shutil.ignore_patterns('.hg*', 'tests', 'testdata', 'modules', 'docs', 'locale', *extra_ignores)
    for package_name in packages_names:
        if op.exists(package_name):
            source_path = package_name
        else:
            mod = __import__(package_name)
            source_path = mod.__file__
            if mod.__file__.endswith('__init__.py'):
                source_path = op.dirname(source_path)
        dest_name = op.basename(source_path)
        dest_path = op.join(dest, dest_name)
        if op.exists(dest_path):
            if op.islink(dest_path):
                os.unlink(dest_path)
            else:
                shutil.rmtree(dest_path)
        print("Copying package at {0} to {1}".format(source_path, dest_path))
        if create_links:
            os.symlink(op.abspath(source_path), dest_path)
        else:
            if op.isdir(source_path):
                shutil.copytree(source_path, dest_path, ignore=ignore)
            else:
                shutil.copy(source_path, dest_path)

    def createJar(self, jarName=None):
        if jarName is None:
            jarName = "%s.jar" % self.basename

        chromeDir = os.path.join(self.buildDir, 'chrome')
        if not os.path.exists(chromeDir):
            os.makedirs(chromeDir)
        jarFile = zipfile.ZipFile(os.path.join(chromeDir, jarName), 'w', zipfile.ZIP_STORED, False)

        ignore = shutil.ignore_patterns('.*')
        jarDirs = self.manifest.jarDirs()

        for dir in jarDirs:
            shutil.copytree(os.path.join(self.dataDir, dir), os.path.join(self.buildDir, dir), False, ignore)
            for dirpath, dirs, files in os.walk(os.path.join(self.buildDir, dir)):
                if dirpath != chromeDir:
                    for fileName in files:
                        relPath = os.path.join(dirpath, fileName)
                        zipPath = os.path.join(os.path.relpath(dirpath, self.buildDir), fileName)
                        jarFile.write(relPath, zipPath)
        jarFile.close()

        # Remove redundant directories
        for dir in jarDirs:
            shutil.rmtree(os.path.join(self.buildDir, dir))
        self.manifest.setJar(jarName)

def js():
    """Combine and minify RequireJS modules"""

    if (env.is_remote):
        abort('You cannot build js files remotely!\n'
              'This should be done in your local development env.')

    import os
    from shutil import copytree, rmtree, ignore_patterns
    collect_js()

    proj_path = os.path.join(os.path.dirname(__file__), '../mootiro_maps')
    build_path = os.path.join(proj_path, '../.build')
    local('r.js -o {}'.format(os.path.join(proj_path, '../app.build.js')))
    from_ = os.path.join(build_path, 'min')
    to = os.path.join(proj_path, 'static', 'js.build')
    try:
        rmtree(to)
    except OSError:
        pass
    logging.info('copying compiled javascripts to {}'.format(to))
    copytree(from_, to, ignore=ignore_patterns('*.coffee', '*~'))

    # Removes the build dir
    rmtree(build_path)

    test_js()

 def copy_files(scripts_sub_dir):
     src = os.path.join(self.pylucid_dir, "scripts", scripts_sub_dir)
     print "%s -> %s" % (src, self.dest_package_dir)
     try:
         copytree2(src, self.dest_package_dir, ignore=shutil.ignore_patterns(*COPYTREE_IGNORE_FILES))
     except OSError, why:
         print "copytree2 error: %s" % why