golden hour

/lib64/python2.7/distutils/command

File/Folder	Size	Actions
__init__.py	822 B
__init__.pyc	665 B
__init__.pyo	665 B
bdist.py	5.46 KB
bdist.pyc	5.1 KB
bdist.pyo	5.1 KB
bdist_dumb.py	5.07 KB
bdist_dumb.pyc	4.92 KB
bdist_dumb.pyo	4.92 KB
bdist_msi.py	34.37 KB
bdist_msi.pyc	23.45 KB
bdist_msi.pyo	23.35 KB
bdist_rpm.py	20.55 KB
bdist_rpm.pyc	17.32 KB
bdist_rpm.pyo	17.24 KB
bdist_wininst.py	14.65 KB
bdist_wininst.pyc	10.55 KB
bdist_wininst.pyo	10.47 KB
build.py	5.31 KB
build.pyc	5.03 KB
build.pyo	5.03 KB
build_clib.py	7.94 KB
build_clib.pyc	6.28 KB
build_clib.pyo	6.28 KB
build_ext.py	31.75 KB
build_ext.py.debug-build	31.53 KB
build_ext.pyc	19.09 KB
build_ext.pyo	19.09 KB
build_py.py	15.92 KB
build_py.pyc	11.24 KB
build_py.pyo	11.17 KB
build_scripts.py	4.49 KB
build_scripts.pyc	4.43 KB
build_scripts.pyo	4.43 KB
check.py	5.43 KB
check.pyc	6.08 KB
check.pyo	6.08 KB
clean.py	2.75 KB
clean.pyc	3.1 KB
clean.pyo	3.1 KB
command_template	719 B
config.py	12.82 KB
config.pyc	12.39 KB
config.pyo	12.39 KB
install.py	25.65 KB
install.pyc	16.5 KB
install.pyo	16.5 KB
install_data.py	2.78 KB
install_data.pyc	3.09 KB
install_data.pyo	3.09 KB
install_egg_info.py	2.53 KB
install_egg_info.pyc	3.68 KB
install_egg_info.pyo	3.68 KB
install_headers.py	1.31 KB
install_headers.pyc	2.24 KB
install_headers.pyo	2.24 KB
install_lib.py	8.14 KB
install_lib.pyc	6.63 KB
install_lib.pyo	6.63 KB
install_scripts.py	2.02 KB
install_scripts.pyc	2.93 KB
install_scripts.pyo	2.93 KB
register.py	11.56 KB
register.pyc	9.98 KB
register.pyo	9.98 KB
sdist.py	18.12 KB
sdist.pyc	16.31 KB
sdist.pyo	16.31 KB
upload.py	6.84 KB
upload.pyc	6.13 KB
upload.pyo	6.13 KB
wininst-6.0.exe	60 KB
wininst-7.1.exe	64 KB
wininst-8.0.exe	60 KB
wininst-9.0-amd64.exe	218.5 KB
wininst-9.0.exe	191.5 KB

Edit: check.py

"""distutils.command.check

Implements the Distutils 'check' command.
"""
__revision__ = "$Id$"

from distutils.core import Command
from distutils.dist import PKG_INFO_ENCODING
from distutils.errors import DistutilsSetupError

try:
    # docutils is installed
    from docutils.utils import Reporter
    from docutils.parsers.rst import Parser
    from docutils import frontend
    from docutils import nodes
    from StringIO import StringIO

class SilentReporter(Reporter):

def __init__(self, source, report_level, halt_level, stream=None,
                     debug=0, encoding='ascii', error_handler='replace'):
            self.messages = []
            Reporter.__init__(self, source, report_level, halt_level, stream,
                              debug, encoding, error_handler)

def system_message(self, level, message, *children, **kwargs):
            self.messages.append((level, message, children, kwargs))
            return nodes.system_message(message, level=level,
                                        type=self.levels[level],
                                        *children, **kwargs)

HAS_DOCUTILS = True
except ImportError:
    # docutils is not installed
    HAS_DOCUTILS = False

class check(Command):
    """This command checks the meta-data of the package.
    """
    description = ("perform some checks on the package")
    user_options = [('metadata', 'm', 'Verify meta-data'),
                    ('restructuredtext', 'r',
                     ('Checks if long string meta-data syntax '
                      'are reStructuredText-compliant')),
                    ('strict', 's',
                     'Will exit with an error if a check fails')]

boolean_options = ['metadata', 'restructuredtext', 'strict']

def initialize_options(self):
        """Sets default values for options."""
        self.restructuredtext = 0
        self.metadata = 1
        self.strict = 0
        self._warnings = 0

def finalize_options(self):
        pass

def warn(self, msg):
        """Counts the number of warnings that occurs."""
        self._warnings += 1
        return Command.warn(self, msg)

def run(self):
        """Runs the command."""
        # perform the various tests
        if self.metadata:
            self.check_metadata()
        if self.restructuredtext:
            if HAS_DOCUTILS:
                self.check_restructuredtext()
            elif self.strict:
                raise DistutilsSetupError('The docutils package is needed.')

# let's raise an error in strict mode, if we have at least
        # one warning
        if self.strict and self._warnings > 0:
            raise DistutilsSetupError('Please correct your package.')

def check_metadata(self):
        """Ensures that all required elements of meta-data are supplied.

name, version, URL, (author and author_email) or
        (maintainer and maintainer_email)).

Warns if any are missing.
        """
        metadata = self.distribution.metadata

missing = []
        for attr in ('name', 'version', 'url'):
            if not (hasattr(metadata, attr) and getattr(metadata, attr)):
                missing.append(attr)

if missing:
            self.warn("missing required meta-data: %s"  % ', '.join(missing))
        if metadata.author:
            if not metadata.author_email:
                self.warn("missing meta-data: if 'author' supplied, " +
                          "'author_email' must be supplied too")
        elif metadata.maintainer:
            if not metadata.maintainer_email:
                self.warn("missing meta-data: if 'maintainer' supplied, " +
                          "'maintainer_email' must be supplied too")
        else:
            self.warn("missing meta-data: either (author and author_email) " +
                      "or (maintainer and maintainer_email) " +
                      "must be supplied")

def check_restructuredtext(self):
        """Checks if the long string fields are reST-compliant."""
        data = self.distribution.get_long_description()
        if not isinstance(data, unicode):
            data = data.decode(PKG_INFO_ENCODING)
        for warning in self._check_rst_data(data):
            line = warning[-1].get('line')
            if line is None:
                warning = warning[1]
            else:
                warning = '%s (line %s)' % (warning[1], line)
            self.warn(warning)

def _check_rst_data(self, data):
        """Returns warnings when the provided data doesn't compile."""
        source_path = StringIO()
        parser = Parser()
        settings = frontend.OptionParser().get_default_values()
        settings.tab_width = 4
        settings.pep_references = None
        settings.rfc_references = None
        reporter = SilentReporter(source_path,
                          settings.report_level,
                          settings.halt_level,
                          stream=settings.warning_stream,
                          debug=settings.debug,
                          encoding=settings.error_encoding,
                          error_handler=settings.error_encoding_error_handler)

document = nodes.document(settings, reporter, source=source_path)
        document.note_source(source_path, -1)
        try:
            parser.parse(data, document)
        except AttributeError:
            reporter.messages.append((-1, 'Could not finish the parsing.',
                                      '', {}))

return reporter.messages