root/develop/pkg_setup.py

"""pkg_setup: utilities for the build phase of python setup.py scripts

svn propset svn:externals 'develop http:://svn.wiretooth.com/svn/open/pkg_setup' .

"""

import sys, os
from distutils.util import convert_path
from fnmatch import fnmatchcase

__all__ = '''\
find_data get_descriptors_rst oswalk_sources 
packages_standard_exclude
data_standard_exclude data_standard_exclude_directories 
install_new_module'''.split()

def get_descriptors_rst(
    filename,
    short=':Abstract:', 
    long='',
    version='',
    other=[],
    includeprefix=[],
    excludeprefix=[]):
    f = file(filename)
    seeksections=other[:] # last entry is terminator.
    if long: seeksections.insert(0,long)
    if short: seeksections.insert(0,short)
    if version: seeksections.insert(0,version)
    lines,section,sectionlines,sections = [],None,[],{}
    try:
        for line in f:
            #line = line.strip()
            for candidate in seeksections:
                if line.startswith(candidate):
                    if section:
                        sections[section]=sectionlines
                        sectionlines=[]
                    if candidate == seeksections[-1]:
                        for section, lines in sections.items():
                            sections[section]=''.join(lines)
                        short=sections.pop(short,'')
                        long=sections.pop(long,'')
                        #version=float(sections.pop(version,'0.0').split()[-1])
                        version=sections.pop(version,'0.0'
                            ).strip().split()[-1].strip()
                        return dict(short=short, long=long, version=version,
                            other='\n'.join(sections.values()))
                    section=candidate
                    break
            for include,exclude in zip(includeprefix,excludeprefix):
                if line.startswith(include):
                    sectionlines.append(line)
                    break
                elif line.startswith(exclude):
                    line=None
                    break
            line and sectionlines.append(line)
    finally:
        f.close()
    return sections 
def install_new_module(packagename, basemodulename):
    """Dynamicaly installs a new package.
    
    Note: take care with this one, for example don't pass in __name__ as
    package name, unless you want to replace your own module right under
    your feet!"""
    try:
        packagemod = sys.modules[packagename]
    except KeyError:
        packagemod = new.module(packagename)
        sys.modules[packagename] = packagemod
    modulename = '.'.join([packagename, basemodulename])
    mod = new.module(modulename)
    # if packagename == __name__ then your probably buggered. 
    setattr(packagemod, basemodulename, mod)
    sys.modules[modulename] = getattr(packagemod, basemodulename)
    return mod 


def oswalk_sources(basepath, destpath, excludedirs, mkdestdirs=True):
    absbasepath = os.path.abspath(basepath)    
    for root, dirs, files in os.walk(basepath):
        dirs[:]=[d for d in dirs if d not in excludedirs]
        destroot = os.path.join(destpath, root[len(basepath):])
        for fn in files:
            dst = os.path.join(destroot, '', fn)
            src = os.path.join(root, fn)
            yield (dst, src, destroot)


# Provided as an attribute, so you can append to these instead
# of replicating them:
packages_standard_exclude = ('ez_setup',)

data_standard_exclude = ('setup.cfg', '#*', '*.py', '*.pyc', '*~', '.*', 
    '*.bak', '*.in')
data_standard_exclude_directories = ('.*', 'CVS', '_darcs', './build',
                                './dist', './ez_setup', 'EGG-INFO', '*.egg-info')
def find_data(
    where='.', package='', package_data=True,
    exclude=data_standard_exclude,
    exclude_directories=data_standard_exclude_directories,
    only_in_packages=False,
    show_ignored=False):
    """
    find your distributions data.

    If package_data is true: Return a dictionary suitable for use in
    ``package_data`` in a distutils ``setup.py`` file.
    Otherwise: Return a data_files compatible list of tuples.

    The package data dictionary looks like::

        {'package': [files]}

    Where ``files`` is a list of all the files in that package that
    don't match anything in ``exclude``.

    The data_files tuple list looks like::

        [('', datadir1),...]
        
    Note that egg distributions bundle all data in your egg file. So using
    pkg_resources, you access you data using paths relative to your egg_base
    directory. If you are supporting instalation using distutils you should 
    post process this list and convert empty target dirs to the desired data 
    install location for that set of files. see distutils documentation
    for more information.

    If ``only_in_packages`` is true, the default is false, then top-level 
    directories that are not packages won't be included (but directories under 
    packages will).

    Directories matching any pattern in ``exclude_directories`` will
    be ignored; by default directories with leading ``.``, ``CVS``,
    and ``_darcs`` will be ignored.

    If ``show_ignored`` is true, then all the files that aren't
    included in package data are shown on stderr (for debugging
    purposes).

    Note patterns use wildcards, or can be exact paths (including
    leading ``./``), and all searching is case-insensitive.
    """
    
    out = {}
    stack = [(convert_path(where), '', package, only_in_packages)]
    while stack:
        where, prefix, package, only_in_packages = stack.pop(0)
        for name in os.listdir(where):
            fn = os.path.join(where, name)
            if os.path.isdir(fn):
                bad_name = False
                for pattern in exclude_directories:
                    if (fnmatchcase(name, pattern)
                        or fn.lower() == pattern.lower()):
                        bad_name = True
                        if show_ignored:
                            print >> sys.stderr, (
                                "Directory %s ignored by pattern %s"
                                % (fn, pattern))
                        break
                if bad_name:
                    continue
                if not package:
                    new_package = name
                else:
                    new_package = package + '.' + name
                if os.path.isfile(os.path.join(fn, '__init__.py')):
                    stack.append((fn, '', new_package, False))
                elif not package_data:
                    stack.append((fn, prefix + name + '/', 
                        new_package, only_in_packages))
                else:
                    stack.append((fn, prefix + name + '/', 
                        package, only_in_packages))
            elif package or not only_in_packages:
                # is a file
                bad_name = False
                for pattern in exclude:
                    if (fnmatchcase(name, pattern)
                        or fn.lower() == pattern.lower()):
                        bad_name = True
                        if show_ignored:
                            print >> sys.stderr, (
                                "File %s ignored by pattern %s"
                                % (fn, pattern))
                        break
                if bad_name:
                    continue
                out.setdefault(package, []).append(prefix+name)
    if not package_data:
        out = [('/'.join(fakepackage.split('.')), datadir)
                for fakepackage, datadir in out.items()]
    return out