Python库 | plib.io-0.9.tar.gz

#!/usr/bin/env python """ Module SETUPUTILS -- Utilities to automate boilerplate in Python setup scripts Copyright (C) 2012 by Peter A. Donis Released under the Python Software Foundation License. The purpose of this module is to help automate away much of the boilerplate that goes into Python setup scripts. Typical usage: # declare variables here, for example... name = "myprog" description = "My Python Program" # other variables depending on what you need, but the autodiscovery # capabilities of setuputils remove the need for a lot of manual # declarations, or at least make them easier if __name__ == '__main__': from distutils.core import setup from setuputils import setup_vars setup(**setup_vars(globals())) Or, you can take more fine-grained control over things by only invoking particular sub-functions, for example: if __name__ == '__main__': from distutils.core import setup from setuputils import autodiscover_packages setup( name="myprog", description="My Python Program", packages=autodiscover_packages(globals()), # other args ) You can even mix the two methods, disabling general autodiscovery but using it for particular things: from setuputils import autodiscover_packages, setup_vars name = "myprog" description = "My Python Program" packages = autodiscover_packages(globals()) if __name__ == '__main__': from distutils.core import setup setup(**setup_vars(globals(), autodiscover=False)) See the docstrings of the individual functions below for more information. """ import os from datetime import datetime from distutils.core import Extension from functools import partial from itertools import chain, dropwhile, islice, izip, takewhile def underline(line, underline='~'): """Return an underline string for ``line``. Intended for use with level 3 and lower headings. Note that the default for ``underline`` assumes that the level 1 and 2 underlines are the standard ``=`` and ``-``. You can pass a different underline character to this function if needed. """ if line.endswith('\n'): line = line[:-1] return "{}\n".format(underline * len(line)) h3_prefix = '### ' def _rst_from_md(basename, template=None, startline=None, **kwds): # Convert Markdown text from file named basename.md to RST # text saved to file named basename with open("{}.md".format(basename), 'rU') as f: lines = f.readlines() outlines = [] # Allow adding a header to the RST version (which can # be filtered out when generating PKG_INFO if desired) if template: outlines.extend( "{}\n".format(line) for line in template.format(basename=basename, **kwds).splitlines() ) # Normally you will want to pass an integer in as the # startline keyword argument, since the Markdown file # will probably have a title at the start, and the RST # files used to provide PKG_INFO to PyPI should not have # title lines (since PyPI adds a title itself) for line in islice(lines, startline, None): is_h3line = line.startswith(h3_prefix) if is_h3line: line = line[len(h3_prefix):] outlines.append(line) if is_h3line: outlines.append(underline(line)) with open(basename, 'w') as f: f.writelines(outlines) def convert_md_to_rst(template=None, dirname=".", mdnames=None, **kwds): """Convert Markdown text files to RST text files. Useful for projects where "official" releases are on PyPI but development source is visible somewhere else that uses Markdown instead of ReStructuredText as its default text doc format, such as github. The ``mdnames`` parameter gives the base names of files to be converted; this defaults to every text file in directory ``dirname`` (which defaults to the directory your setup script is run from) with an ``.md`` extension. """ if mdnames is None: mdnames = [ os.path.splitext(basename)[0] for basename in os.listdir(dirname) if os.path.splitext(basename)[1] == ".md" ] for basename in mdnames: _rst_from_md(basename, template=template, **kwds) def current_date(fmt): return datetime.now().strftime(fmt) def long_description(varmap, filename="README", startline=None, startspec=None, endline=None, endspec=None): """Extract long description suitable for PyPI from RST text file. Useful to automate generating the ``long_description`` setup parameter. Looks in ``filename``, which should be a ReStructuredText file, and returns all the text from the given starting line (which is included in the result) to the given ending line (which is not included in the result). Lines can be specified either by line number (``startline`` or ``endline``) or a string the line starts with (``startspec`` or ``endspec``). Defaults to using the ``README`` file. """ startline = startline or varmap.get('startline') startspec = startspec or varmap.get('startspec') endline = endline or varmap.get('endline') endspec = endspec or varmap.get('endspec') with open(filename, 'rU') as f: lines = f.readlines() if startline or endline: innerlines = islice(lines, startline, endline) else: innerlines = lines if startspec: inner = dropwhile( lambda line: not line.startswith(startspec), innerlines ) else: inner = innerlines if endspec: desclines = takewhile( lambda line: not line.startswith(endspec), inner ) else: desclines = inner return "".join(desclines) def pypi_url(varmap): """Return the PyPI URL for program ``name`` from the setup vars. """ return "http://pypi.python.org/pypi/{}".format(varmap['name']) def provides(varmap): """Return a minimal ``provides`` list from the setup vars. """ try: return ["{} ({})".format(varmap['name'], varmap['version'])] except KeyError: return [varmap['name']] def add_vars(varmap): """Automate adding ``long_description``, ``url``, and ``provides`` setup vars. """ if 'long_description' not in varmap: varmap['long_description'] = long_description(varmap) if 'url' not in varmap: varmap['url'] = pypi_url(varmap) if 'provides' not in varmap: varmap['provides'] = provides(varmap) def convert_lists(varmap, listnames=('classifiers', 'requires', 'provides', 'obsoletes')): """Convert long strings to lists of strings. Allows variable names in ``listnames`` to be specified as long strings instead of lists, for easier typing. The ``license_map`` and ``devstatus_trove`` strings below give examples of the kind of long strings that can be used. """ listnames = varmap.get('listnames', listnames) for listname in listnames: try: var = varmap[listname] except KeyError: pass else: if isinstance(var, basestring): varmap[listname] = var.strip().splitlines() def add_classifier_python(varmap): """Automate adding the Python language classifier. Since most programs using this module will be Python programs, this makes it easy to ensure that the Python language Trove classifier is present. """ classifiers = varmap.setdefault('classifiers', []) if all(not c.startswith("Programming Language ::") for c in classifiers): classifiers.append("Programming Language :: Python") license_map = d