moved to lib/python/third_party

lib/python/docutils/__init__.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.5 $
-# Date: $Date: 2004/06/19 06:33:31 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-This is the Docutils (Python Documentation Utilities) package.
-
-Package Structure
-=================
-
-Modules:
-
-- __init__.py: Contains component base classes, exception classes, and
-  Docutils `__version__`.
-
-- core.py: Contains the ``Publisher`` class and ``publish_*()`` convenience
-  functions.
-
-- frontend.py: Runtime settings (command-line interface, configuration files)
-  processing, for Docutils front-ends.
-
-- io.py: Provides a uniform API for low-level input and output.
-
-- nodes.py: Docutils document tree (doctree) node class library.
-
-- statemachine.py: A finite state machine specialized for
-  regular-expression-based text filters.
-
-- urischemes.py: Contains a complete mapping of known URI addressing
-  scheme names to descriptions.
-
-- utils.py: Contains the ``Reporter`` system warning class and miscellaneous
-  utilities.
-
-Subpackages:
-
-- languages: Language-specific mappings of terms.
-
-- parsers: Syntax-specific input parser modules or packages.
-
-- readers: Context-specific input handlers which understand the data
-  source and manage a parser.
-
-- transforms: Modules used by readers and writers to modify DPS
-  doctrees.
-
-- writers: Format-specific output translators.
-"""
-
-__docformat__ = 'reStructuredText'
-
-__version__ = '0.3.4'
-"""``major.minor.micro`` version number.  The micro number is bumped for API
-changes, for new functionality, and for interim project releases.  The minor
-number is bumped whenever there is a significant project release.  The major
-number will be bumped when the project is feature-complete, and perhaps if
-there is a major change in the design."""
-
-
-class ApplicationError(StandardError): pass
-class DataError(ApplicationError): pass
-
-
-class SettingsSpec:
-
-    """
-    Runtime setting specification base class.
-
-    SettingsSpec subclass objects used by `docutils.frontend.OptionParser`.
-    """
-
-    settings_spec = ()
-    """Runtime settings specification.  Override in subclasses.
-
-    Defines runtime settings and associated command-line options, as used by
-    `docutils.frontend.OptionParser`.  This is a tuple of:
-
-    - Option group title (string or `None` which implies no group, just a list
-      of single options).
-    
-    - Description (string or `None`).
-    
-    - A sequence of option tuples.  Each consists of:
-
-      - Help text (string)
-      
-      - List of option strings (e.g. ``['-Q', '--quux']``).
-      
-      - Dictionary of keyword arguments.  It contains arguments to the
-        OptionParser/OptionGroup ``add_option`` method, possibly with the
-        addition of a 'validator' keyword (see the
-        `docutils.frontend.OptionParser.validators` instance attribute).  Runtime
-        settings names are derived implicitly from long option names
-        ('--a-setting' becomes ``settings.a_setting``) or explicitly from the
-        'dest' keyword argument.  See optparse docs for more details.
-
-    - More triples of group title, description, options, as many times as
-      needed.  Thus, `settings_spec` tuples can be simply concatenated.
-    """
-
-    settings_defaults = None
-    """A dictionary of defaults for settings not in `settings_spec` (internal
-    settings, intended to be inaccessible by command-line and config file).
-    Override in subclasses."""
-
-    settings_default_overrides = None
-    """A dictionary of auxiliary defaults, to override defaults for settings
-    defined in other components.  Override in subclasses."""
-
-    relative_path_settings = ()
-    """Settings containing filesystem paths.  Override in subclasses.
-    Settings listed here are to be interpreted relative to the current working
-    directory."""
-
-    config_section = None
-    """The name of the config file section specific to this component
-    (lowercase, no brackets).  Override in subclasses."""
-
-    config_section_dependencies = None
-    """A list of names of config file sections that are to be applied before
-    `config_section`, in order (from general to specific).  In other words,
-    the settings in `config_section` are to be overlaid on top of the settings
-    from these sections.  The "general" section is assumed implicitly.
-    Override in subclasses."""
-
-
-class TransformSpec:
-
-    """
-    Runtime transform specification base class.
-
-    TransformSpec subclass objects used by `docutils.transforms.Transformer`.
-    """
-
-    default_transforms = ()
-    """Transforms required by this class.  Override in subclasses."""
-    
-    unknown_reference_resolvers = ()
-    """List of functions to try to resolve unknown references.  Unknown
-    references have a 'refname' attribute which doesn't correspond to any
-    target in the document.  Called when FinalCheckVisitor is unable to find a
-    correct target.  The list should contain functions which will try to
-    resolve unknown references, with the following signature::
-
-        def reference_resolver(node):
-            '''Returns boolean: true if resolved, false if not.'''
-
-    If the function is able to resolve the reference, it should also remove
-    the 'refname' attribute and mark the node as resolved::
-
-        del node['refname']
-        node.resolved = 1
-
-    Each function must have a "priority" attribute which will affect the order
-    the unknown_reference_resolvers are run::
-
-        reference_resolver.priority = 100
-
-    Override in subclasses."""
-
-
-class Component(SettingsSpec, TransformSpec):
-
-    """Base class for Docutils components."""
-
-    component_type = None
-    """Name of the component type ('reader', 'parser', 'writer').  Override in
-    subclasses."""
-
-    supported = ()
-    """Names for this component.  Override in subclasses."""
-    
-    def supports(self, format):
-        """
-        Is `format` supported by this component?
-
-        To be used by transforms to ask the dependent component if it supports
-        a certain input context or output format.
-        """
-        return format in self.supported

lib/python/docutils/examples.py

-# Authors: David Goodger
-# Contact: goodger@python.org
-# Revision: $Revision: 1.1.2.1 $
-# Date: $Date: 2004/05/12 19:57:38 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-This module contains practical examples of Docutils client code.
-
-Importing this module is not recommended; its contents are subject to change
-in future Docutils releases.  Instead, it is recommended that you copy and
-paste the parts you need into your own code, modifying as necessary.
-"""
-
-from docutils import core
-
-
-def html_parts(input_string, source_path=None, destination_path=None,
-               input_encoding='unicode', doctitle=1, initial_header_level=1):
-    """
-    Given an input string, returns a dictionary of HTML document parts.
-
-    Dictionary keys are the names of parts, and values are Unicode strings;
-    encoding is up to the client.
-
-    Parameters:
-
-    - `input_string`: A multi-line text string; required.
-    - `source_path`: Path to the source file or object.  Optional, but useful
-      for diagnostic output (system messages).
-    - `destination_path`: Path to the file or object which will receive the
-      output; optional.  Used for determining relative paths (stylesheets,
-      source links, etc.).
-    - `input_encoding`: The encoding of `input_string`.  If it is an encoded
-      8-bit string, provide the correct encoding.  If it is a Unicode string,
-      use "unicode", the default.
-    - `doctitle`: Disable the promotion of a lone top-level section title to
-      document title (and subsequent section title to document subtitle
-      promotion); enabled by default.
-    - `initial_header_level`: The initial level for header elements (e.g. 1
-      for "<h1>").
-    """
-    overrides = {'input_encoding': input_encoding,
-                 'doctitle_xform': doctitle,
-                 'initial_header_level': initial_header_level}
-    parts = core.publish_parts(
-        source=input_string, source_path=source_path,
-        destination_path=destination_path,
-        writer_name='html', settings_overrides=overrides)
-    return parts
-
-def html_fragment(input_string, source_path=None, destination_path=None,
-                  input_encoding='unicode', output_encoding='unicode',
-                  doctitle=1, initial_header_level=1):
-    """
-    Given an input string, returns an HTML fragment as a string.
-
-    The return value is the contents of the <body> tag, less the title,
-    subtitle, and docinfo.
-
-    Parameters (see `html_parts()` for the remainder):
-
-    - `output_encoding`: The desired encoding of the output.  If a Unicode
-      string is desired, use the default value of "unicode" .
-    """
-    parts = html_parts(
-        input_string=input_string, source_path=source_path,
-        destination_path=destination_path,
-        input_encoding=input_encoding, doctitle=doctitle,
-        initial_header_level=initial_header_level)
-    fragment = parts['fragment']
-    if output_encoding != 'unicode':
-        fragment = fragment.encode(output_encoding)
-    return fragment

lib/python/docutils/io.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:38 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-I/O classes provide a uniform API for low-level input and output.  Subclasses
-will exist for a variety of input/output mechanisms.
-"""
-
-__docformat__ = 'reStructuredText'
-
-import sys
-try:
-    import locale
-except:
-    pass
-from types import UnicodeType
-from docutils import TransformSpec
-
-
-class Input(TransformSpec):
-
-    """
-    Abstract base class for input wrappers.
-    """
-
-    component_type = 'input'
-
-    default_source_path = None
-
-    def __init__(self, source=None, source_path=None, encoding=None):
-        self.encoding = encoding
-        """Text encoding for the input source."""
-
-        self.source = source
-        """The source of input data."""
-
-        self.source_path = source_path
-        """A text reference to the source."""
-
-        if not source_path:
-            self.source_path = self.default_source_path
-
-    def __repr__(self):
-        return '%s: source=%r, source_path=%r' % (self.__class__, self.source,
-                                                  self.source_path)
-
-    def read(self):
-        raise NotImplementedError
-
-    def decode(self, data):
-        """
-        Decode a string, `data`, heuristically.
-        Raise UnicodeError if unsuccessful.
-
-        The client application should call ``locale.setlocale`` at the
-        beginning of processing::
-
-            locale.setlocale(locale.LC_ALL, '')
-        """
-        if (self.encoding and self.encoding.lower() == 'unicode'
-            or isinstance(data, UnicodeType)):
-            return unicode(data)
-        encodings = [self.encoding, 'utf-8']
-        try:
-            encodings.append(locale.nl_langinfo(locale.CODESET))
-        except:
-            pass
-        try:
-            encodings.append(locale.getlocale()[1])
-        except:
-            pass
-        try:
-            encodings.append(locale.getdefaultlocale()[1])
-        except:
-            pass
-        encodings.append('latin-1')
-        for enc in encodings:
-            if not enc:
-                continue
-            try:
-                return unicode(data, enc)
-            except (UnicodeError, LookupError):
-                pass
-        raise UnicodeError(
-            'Unable to decode input data.  Tried the following encodings: %s.'
-            % ', '.join([repr(enc) for enc in encodings if enc]))
-
-
-class Output(TransformSpec):
-
-    """
-    Abstract base class for output wrappers.
-    """
-
-    component_type = 'output'
-
-    default_destination_path = None
-
-    def __init__(self, destination=None, destination_path=None,
-                 encoding=None, error_handler='strict'):
-        self.encoding = encoding
-        """Text encoding for the output destination."""
-
-        self.error_handler = error_handler or 'strict'
-        """Text encoding error handler."""
-
-        self.destination = destination
-        """The destination for output data."""
-
-        self.destination_path = destination_path
-        """A text reference to the destination."""
-
-        if not destination_path:
-            self.destination_path = self.default_destination_path
-
-    def __repr__(self):
-        return ('%s: destination=%r, destination_path=%r'
-                % (self.__class__, self.destination, self.destination_path))
-
-    def write(self, data):
-        """`data` is a Unicode string, to be encoded by `self.encode`."""
-        raise NotImplementedError
-
-    def encode(self, data):
-        if self.encoding and self.encoding.lower() == 'unicode':
-            return data
-        else:
-            try:
-                return data.encode(self.encoding, self.error_handler)
-            except ValueError:
-                # ValueError is raised if there are unencodable chars
-                # in data and the error_handler isn't found.
-                if self.error_handler == 'xmlcharrefreplace':
-                    # We are using xmlcharrefreplace with a Python
-                    # version that doesn't support it (2.1 or 2.2), so
-                    # we emulate its behavior.
-                    return ''.join([self.xmlcharref_encode(char) for char in data])
-                else:
-                    raise
-
-    def xmlcharref_encode(self, char):
-        """Emulate Python 2.3's 'xmlcharrefreplace' encoding error handler."""
-        try:
-            return char.encode(self.encoding, 'strict')
-        except UnicodeError:
-            return '&#%i;' % ord(char)
-
-
-class FileInput(Input):
-
-    """
-    Input for single, simple file-like objects.
-    """
-
-    def __init__(self, source=None, source_path=None,
-                 encoding=None, autoclose=1, handle_io_errors=1):
-        """
-        :Parameters:
-            - `source`: either a file-like object (which is read directly), or
-              `None` (which implies `sys.stdin` if no `source_path` given).
-            - `source_path`: a path to a file, which is opened and then read.
-            - `autoclose`: close automatically after read (boolean); always
-              false if `sys.stdin` is the source.
-        """
-        Input.__init__(self, source, source_path, encoding)
-        self.autoclose = autoclose
-        self.handle_io_errors = handle_io_errors
-        if source is None:
-            if source_path:
-                try:
-                    self.source = open(source_path)
-                except IOError, error:
-                    if not handle_io_errors:
-                        raise
-                    print >>sys.stderr, '%s: %s' % (error.__class__.__name__,
-                                                    error)
-                    print >>sys.stderr, (
-                        'Unable to open source file for reading (%r).  Exiting.'
-                        % source_path)
-                    sys.exit(1)
-            else:
-                self.source = sys.stdin
-                self.autoclose = None
-        if not source_path:
-            try:
-                self.source_path = self.source.name
-            except AttributeError:
-                pass
-
-    def read(self):
-        """
-        Read and decode a single file and return the data (Unicode string).
-        """
-        data = self.source.read()
-        if self.autoclose:
-            self.close()
-        return self.decode(data)
-
-    def close(self):
-        self.source.close()
-
-
-class FileOutput(Output):
-
-    """
-    Output for single, simple file-like objects.
-    """
-
-    def __init__(self, destination=None, destination_path=None,
-                 encoding=None, error_handler='strict', autoclose=1,
-                 handle_io_errors=1):
-        """
-        :Parameters:
-            - `destination`: either a file-like object (which is written
-              directly) or `None` (which implies `sys.stdout` if no
-              `destination_path` given).
-            - `destination_path`: a path to a file, which is opened and then
-              written.
-            - `autoclose`: close automatically after write (boolean); always
-              false if `sys.stdout` is the destination.
-        """
-        Output.__init__(self, destination, destination_path,
-                        encoding, error_handler)
-        self.opened = 1
-        self.autoclose = autoclose
-        self.handle_io_errors = handle_io_errors
-        if destination is None:
-            if destination_path:
-                self.opened = None
-            else:
-                self.destination = sys.stdout
-                self.autoclose = None
-        if not destination_path:
-            try:
-                self.destination_path = self.destination.name
-            except AttributeError:
-                pass
-
-    def open(self):
-        try:
-            self.destination = open(self.destination_path, 'w')
-        except IOError, error:
-            if not self.handle_io_errors:
-                raise
-            print >>sys.stderr, '%s: %s' % (error.__class__.__name__,
-                                            error)
-            print >>sys.stderr, ('Unable to open destination file for writing '
-                                 '(%r).  Exiting.' % self.destination_path)
-            sys.exit(1)
-        self.opened = 1
-
-    def write(self, data):
-        """Encode `data`, write it to a single file, and return it."""
-        output = self.encode(data)
-        if not self.opened:
-            self.open()
-        self.destination.write(output)
-        if self.autoclose:
-            self.close()
-        return output
-
-    def close(self):
-        self.destination.close()
-        self.opened = None
-
-
-class StringInput(Input):
-
-    """
-    Direct string input.
-    """
-
-    default_source_path = '<string>'
-
-    def read(self):
-        """Decode and return the source string."""
-        return self.decode(self.source)
-
-
-class StringOutput(Output):
-
-    """
-    Direct string output.
-    """
-
-    default_destination_path = '<string>'
-
-    def write(self, data):
-        """Encode `data`, store it in `self.destination`, and return it."""
-        self.destination = self.encode(data)
-        return self.destination
-
-
-class NullInput(Input):
-
-    """
-    Degenerate input: read nothing.
-    """
-
-    default_source_path = 'null input'
-
-    def read(self):
-        """Return a null string."""
-        return u''
-
-
-class NullOutput(Output):
-
-    """
-    Degenerate output: write nothing.
-    """
-
-    default_destination_path = 'null output'
-
-    def write(self, data):
-        """Do nothing ([don't even] send data to the bit bucket)."""
-        pass

lib/python/docutils/languages/__init__.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# Internationalization details are documented in
-# <http://docutils.sf.net/spec/howto/i18n.html>.
-
-"""
-This package contains modules for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-_languages = {}
-
-def get_language(language_code):
-    if _languages.has_key(language_code):
-        return _languages[language_code]
-    try:
-        module = __import__(language_code, globals(), locals())
-    except ImportError:
-        return None
-    _languages[language_code] = module
-    return module

lib/python/docutils/languages/af.py

-# Author: Jannie Hofmeyr
-# Contact: jhsh@sun.ac.za
-# Revision: $Revision: 1.1.2.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Afrikaans-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      'author': 'Auteur',
-      'authors': 'Auteurs',
-      'organization': 'Organisasie',
-      'address': 'Adres',
-      'contact': 'Kontak',
-      'version': 'Weergawe',
-      'revision': 'Revisie',
-      'status': 'Status',
-      'date': 'Datum',
-      'copyright': 'Kopiereg',
-      'dedication': 'Opdrag',
-      'abstract': 'Opsomming',
-      'attention': 'Aandag!',
-      'caution': 'Wees versigtig!',
-      'danger': '!GEVAAR!',
-      'error': 'Fout',
-      'hint': 'Wenk',
-      'important': 'Belangrik',
-      'note': 'Nota',
-      'tip': 'Tip', # hint and tip both have the same translation: wenk
-      'warning': 'Waarskuwing',
-      'contents': 'Inhoud'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      'auteur': 'author',
-      'auteurs': 'authors',
-      'organisasie': 'organization',
-      'adres': 'address',
-      'kontak': 'contact',
-      'weergawe': 'version',
-      'revisie': 'revision',
-      'status': 'status',
-      'datum': 'date',
-      'kopiereg': 'copyright',
-      'opdrag': 'dedication',
-      'opsomming': 'abstract'}
-"""Afrikaans (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/cs.py

-# Author: Marek Blaha
-# Contact: mb@dat.cz
-# Revision: $Revision: 1.1.2.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Czech-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      # fixed: language-dependent
-      'author': u'Autor',
-      'authors': u'Auto\u0159i',
-      'organization': u'Organizace',
-      'address': u'Adresa',
-      'contact': u'Kontakt',
-      'version': u'Verze',
-      'revision': u'Revize',
-      'status': u'Stav',
-      'date': u'Datum',
-      'copyright': u'Copyright',
-      'dedication': u'V\u011Bnov\u00E1n\u00ED',
-      'abstract': u'Abstrakt',
-      'attention': u'Pozor!',
-      'caution': u'Opatrn\u011B!',
-      'danger': u'!NEBEZPE\u010C\u00CD!',
-      'error': u'Chyba',
-      'hint': u'Rada',
-      'important': u'D\u016Fle\u017Eit\u00E9',
-      'note': u'Pozn\u00E1mka',
-      'tip': u'Tip',
-      'warning': u'Varov\u00E1n\u00ED',
-      'contents': u'Obsah'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      # language-dependent: fixed
-      u'autor': 'author',
-      u'auto\u0159i': 'authors',
-      u'organizace': 'organization',
-      u'adresa': 'address',
-      u'kontakt': 'contact',
-      u'verze': 'version',
-      u'revize': 'revision',
-      u'stav': 'status',
-      u'datum': 'date',
-      u'copyright': 'copyright',
-      u'v\u011Bnov\u00E1n\u00ED': 'dedication',
-      u'abstrakt': 'abstract'}
-"""Czech (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/de.py

-# Authors:   David Goodger; Gunnar Schwant
-# Contact:   goodger@users.sourceforge.net
-# Revision:  $Revision: 1.2.10.3.8.1 $
-# Date:      $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-German language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-    'author': 'Autor',
-    'authors': 'Autoren',
-    'organization': 'Organisation',
-    'address': 'Adresse',
-    'contact': 'Kontakt',
-    'version': 'Version',
-    'revision': 'Revision',
-    'status': 'Status',
-    'date': 'Datum',
-    'dedication': 'Widmung',
-    'copyright': 'Copyright',
-    'abstract': 'Zusammenfassung',
-    'attention': 'Achtung!',
-    'caution': 'Vorsicht!',
-    'danger': '!GEFAHR!',
-    'error': 'Fehler',
-    'hint': 'Hinweis',
-    'important': 'Wichtig',
-    'note': 'Bemerkung',
-    'tip': 'Tipp',
-    'warning': 'Warnung',
-    'contents': 'Inhalt'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-    'autor': 'author',
-    'autoren': 'authors',
-    'organisation': 'organization',
-    'adresse': 'address',
-    'kontakt': 'contact',
-    'version': 'version',
-    'revision': 'revision',
-    'status': 'status',
-    'datum': 'date',
-    'copyright': 'copyright',
-    'widmung': 'dedication',
-    'zusammenfassung': 'abstract'}
-"""German (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/en.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-English-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      # fixed: language-dependent
-      'author': 'Author',
-      'authors': 'Authors',
-      'organization': 'Organization',
-      'address': 'Address',
-      'contact': 'Contact',
-      'version': 'Version',
-      'revision': 'Revision',
-      'status': 'Status',
-      'date': 'Date',
-      'copyright': 'Copyright',
-      'dedication': 'Dedication',
-      'abstract': 'Abstract',
-      'attention': 'Attention!',
-      'caution': 'Caution!',
-      'danger': '!DANGER!',
-      'error': 'Error',
-      'hint': 'Hint',
-      'important': 'Important',
-      'note': 'Note',
-      'tip': 'Tip',
-      'warning': 'Warning',
-      'contents': 'Contents'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      # language-dependent: fixed
-      'author': 'author',
-      'authors': 'authors',
-      'organization': 'organization',
-      'address': 'address',
-      'contact': 'contact',
-      'version': 'version',
-      'revision': 'revision',
-      'status': 'status',
-      'date': 'date',
-      'copyright': 'copyright',
-      'dedication': 'dedication',
-      'abstract': 'abstract'}
-"""English (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/eo.py

-# Author: Marcelo Huerta San Martin
-# Contact: richieadler@users.sourceforge.net
-# Revision: $Revision: 1.1.2.1.8.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Esperanto-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      # fixed: language-dependent
-      'author': u'A\u016dtoro',
-      'authors': u'A\u016dtoroj',
-      'organization': u'Organizo',
-      'address': u'Adreso',
-      'contact': u'Kontakto',
-      'version': u'Versio',
-      'revision': u'Revido',
-      'status': u'Stato',
-      'date': u'Dato',
-      # 'copyright': u'Kopirajto',
-      'copyright': u'A\u016dtorrajto',
-      'dedication': u'Dedi\u0109o',
-      'abstract': u'Resumo',
-      'attention': u'Atentu!',
-      'caution': u'Zorgu!',
-      'danger': u'DAN\u011cERO!',
-      'error': u'Eraro',
-      'hint': u'Spuro',
-      'important': u'Grava',
-      'note': u'Noto',
-      'tip': u'Helpeto',
-      'warning': u'Averto',
-      'contents': u'Enhavo'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      # language-dependent: fixed
-      'a\u016dtoro': 'author',
-      'a\u016dtoroj': 'authors',
-      'organizo': 'organization',
-      'adreso': 'address',
-      'kontakto': 'contact',
-      'versio': 'version',
-      'revido': 'revision',
-      'stato': 'status',
-      'dato': 'date',
-      'a\u016dtorrajto': 'copyright',
-      'dedi\u0109o': 'dedication',
-      'resumo': 'abstract'}
-"""Esperanto (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/es.py

-# -*- coding: iso-8859-1 -*-
-# Author: Marcelo Huerta San Martn
-# Contact: mghsm@uol.com.ar
-# Revision: $Revision: 1.1.2.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Spanish-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      'author': u'Autor',
-      'authors': u'Autores',
-      'organization': u'Organizaci\u00f3n',
-      'address': u'Direcci\u00f3n',
-      'contact': u'Contacto',
-      'version': u'Versi\u00f3n',
-      'revision': u'Revisi\u00f3n',
-      'status': u'Estado',
-      'date': u'Fecha',
-      'copyright': u'Copyright',
-      'dedication': u'Dedicatoria',
-      'abstract': u'Resumen',
-      'attention': u'\u00a1Atenci\u00f3n!',
-      'caution': u'\u00a1Precauci\u00f3n!',
-      'danger': u'\u00a1PELIGRO!',
-      'error': u'Error',
-      'hint': u'Sugerencia',
-      'important': u'Importante',
-      'note': u'Nota',
-      'tip': u'Consejo',
-      'warning': u'Advertencia',
-      'contents': u'Contenido'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      u'autor': 'author',
-      u'autores': 'authors',
-      u'organizaci\u00f3n': 'organization',
-      u'direcci\u00f3n': 'address',
-      u'contacto': 'contact',
-      u'versi\u00f3n': 'version',
-      u'revisi\u00f3n': 'revision',
-      u'estado': 'status',
-      u'fecha': 'date',
-      u'copyright': 'copyright',
-      u'dedicatoria': 'dedication',
-      u'resumen': 'abstract'}
-"""Spanish (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/fr.py

-# Author: Stefane Fermigier
-# Contact: sf@fermigier.com
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-French-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      u'author': u'Auteur',
-      u'authors': u'Auteurs',
-      u'organization': u'Organisation',
-      u'address': u'Adresse',
-      u'contact': u'Contact',
-      u'version': u'Version',
-      u'revision': u'R\u00e9vision',
-      u'status': u'Statut',
-      u'date': u'Date',
-      u'copyright': u'Copyright',
-      u'dedication': u'D\u00e9dicace',
-      u'abstract': u'R\u00e9sum\u00e9',
-      u'attention': u'Attention!',
-      u'caution': u'Avertissement!',
-      u'danger': u'!DANGER!',
-      u'error': u'Erreur',
-      u'hint': u'Indication',
-      u'important': u'Important',
-      u'note': u'Note',
-      u'tip': u'Astuce',
-      u'warning': u'Avis',
-      u'contents': u'Sommaire'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      u'auteur': u'author',
-      u'auteurs': u'authors',
-      u'organisation': u'organization',
-      u'adresse': u'address',
-      u'contact': u'contact',
-      u'version': u'version',
-      u'r\u00e9vision': u'revision',
-      u'statut': u'status',
-      u'date': u'date',
-      u'copyright': u'copyright',
-      u'd\u00e9dicace': u'dedication',
-      u'r\u00e9sum\u00e9': u'abstract'}
-"""French (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/it.py

-# Author: Nicola Larosa
-# Contact: docutils@tekNico.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Italian-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      'author': 'Autore',
-      'authors': 'Autori',
-      'organization': 'Organizzazione',
-      'address': 'Indirizzo',
-      'contact': 'Contatti',
-      'version': 'Versione',
-      'revision': 'Revisione',
-      'status': 'Status',
-      'date': 'Data',
-      'copyright': 'Copyright',
-      'dedication': 'Dedica',
-      'abstract': 'Riassunto',
-      'attention': 'Attenzione!',
-      'caution': 'Cautela!',
-      'danger': '!PERICOLO!',
-      'error': 'Errore',
-      'hint': 'Suggerimento',
-      'important': 'Importante',
-      'note': 'Nota',
-      'tip': 'Consiglio',
-      'warning': 'Avvertenza',
-      'contents': 'Indice'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      'autore': 'author',
-      'autori': 'authors',
-      'organizzazione': 'organization',
-      'indirizzo': 'address',
-      'contatti': 'contact',
-      'versione': 'version',
-      'revisione': 'revision',
-      'status': 'status',
-      'data': 'date',
-      'copyright': 'copyright',
-      'dedica': 'dedication',
-      'riassunto': 'abstract'}
-"""Italian (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/pt_br.py

-# -*- coding: iso-8859-1 -*-
-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.1.2.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Brazilian Portuguese-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      # fixed: language-dependent
-      'author': u'Autor',
-      'authors': u'Autores',
-      'organization': u'Organiza\u00E7\u00E3o',
-      'address': u'Endere\u00E7o',
-      'contact': u'Contato',
-      'version': u'Vers\u00E3o',
-      'revision': u'Revis\u00E3o',
-      'status': u'Estado',
-      'date': u'Data',
-      'copyright': u'Copyright',
-      'dedication': u'Dedicat\u00F3ria',
-      'abstract': u'Resumo',
-      'attention': u'Atten\u00E7\u00E3o!',
-      'caution': u'Cuidado!',
-      'danger': u'PERIGO!',
-      'error': u'Erro',
-      'hint': u'Sugest\u00E3o',
-      'important': u'Importante',
-      'note': u'Nota',
-      'tip': u'Dica',
-      'warning': u'Aviso',
-      'contents': u'Sum\u00E1rio'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      # language-dependent: fixed
-      u'autor': 'author',
-      u'autores': 'authors',
-      u'organiza\u00E7\u00E3o': 'organization',
-      u'endere\u00E7o': 'address',
-      u'contato': 'contact',
-      u'vers\u00E3o': 'version',
-      u'revis\u00E3o': 'revision',
-      u'estado': 'status',
-      u'data': 'date',
-      u'copyright': 'copyright',
-      u'dedicat\u00F3ria': 'dedication',
-      u'resumo': 'abstract'}
-"""Brazilian Portuguese (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/ru.py

-# Author: Roman Suzi
-# Contact: rnd@onego.ru
-# Revision: $Revision: 1.1.2.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Russian-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      u'abstract': u'\u0410\u043d\u043d\u043e\u0442\u0430\u0446\u0438\u044f',
-      u'address': u'\u0410\u0434\u0440\u0435\u0441',
-      u'attention': u'\u0412\u043d\u0438\u043c\u0430\u043d\u0438\u0435!',
-      u'author': u'\u0410\u0432\u0442\u043e\u0440',
-      u'authors': u'\u0410\u0432\u0442\u043e\u0440\u044b',
-      u'caution': u'\u041e\u0441\u0442\u043e\u0440\u043e\u0436\u043d\u043e!',
-      u'contact': u'\u041a\u043e\u043d\u0442\u0430\u043a\u0442',
-      u'contents':
-      u'\u0421\u043e\u0434\u0435\u0440\u0436\u0430\u043d\u0438\u0435',
-      u'copyright': u'\u041f\u0440\u0430\u0432\u0430 '
-      u'\u043a\u043e\u043f\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u044f',
-      u'danger': u'\u041e\u041f\u0410\u0421\u041d\u041e!',
-      u'date': u'\u0414\u0430\u0442\u0430',
-      u'dedication':
-      u'\u041f\u043e\u0441\u0432\u044f\u0449\u0435\u043d\u0438\u0435',
-      u'error': u'\u041e\u0448\u0438\u0431\u043a\u0430',
-      u'hint': u'\u0421\u043e\u0432\u0435\u0442',
-      u'important': u'\u0412\u0430\u0436\u043d\u043e',
-      u'note': u'\u041f\u0440\u0438\u043c\u0435\u0447\u0430\u043d\u0438\u0435',
-      u'organization':
-      u'\u041e\u0440\u0433\u0430\u043d\u0438\u0437\u0430\u0446\u0438\u044f',
-      u'revision': u'\u0420\u0435\u0434\u0430\u043a\u0446\u0438\u044f',
-      u'status': u'\u0421\u0442\u0430\u0442\u0443\u0441',
-      u'tip': u'\u041f\u043e\u0434\u0441\u043a\u0430\u0437\u043a\u0430',
-      u'version': u'\u0412\u0435\u0440\u0441\u0438\u044f',
-      u'warning': u'\u041f\u0440\u0435\u0434\u0443\u043f\u0440\u0435\u0436'
-      u'\u0434\u0435\u043d\u0438\u0435'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      u'\u0410\u043d\u043d\u043e\u0442\u0430\u0446\u0438\u044f': u'abstract',
-      u'\u0410\u0434\u0440\u0435\u0441': u'address',
-      u'\u0410\u0432\u0442\u043e\u0440': u'author',
-      u'\u0410\u0432\u0442\u043e\u0440\u044b': u'authors',
-      u'\u041a\u043e\u043d\u0442\u0430\u043a\u0442': u'contact',
-      u'\u041f\u0440\u0430\u0432\u0430 \u043a\u043e\u043f\u0438\u0440\u043e'
-      u'\u0432\u0430\u043d\u0438\u044f': u'copyright',
-      u'\u0414\u0430\u0442\u0430': u'date',
-      u'\u041f\u043e\u0441\u0432\u044f\u0449\u0435\u043d\u0438\u0435':
-      u'dedication',
-      u'\u041e\u0440\u0433\u0430\u043d\u0438\u0437\u0430\u0446\u0438\u044f':
-      u'organization',
-      u'\u0420\u0435\u0434\u0430\u043a\u0446\u0438\u044f': u'revision',
-      u'\u0421\u0442\u0430\u0442\u0443\u0441': u'status',
-      u'\u0412\u0435\u0440\u0441\u0438\u044f': u'version'}
-"""Russian (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators =  [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/sk.py

-# :Author: Miroslav Vasko
-# :Contact: zemiak@zoznam.sk
-# :Revision: $Revision: 1.2.10.3.8.1 $
-# :Date: $Date: 2004/05/12 19:57:42 $
-# :Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Slovak-language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-      'author': u'Autor',
-      'authors': u'Autori',
-      'organization': u'Organiz\u00E1cia',
-      'address': u'Adresa',
-      'contact': u'Kontakt',
-      'version': u'Verzia',
-      'revision': u'Rev\u00EDzia',
-      'status': u'Stav',
-      'date': u'D\u00E1tum',
-      'copyright': u'Copyright',
-      'dedication': u'Venovanie',
-      'abstract': u'Abstraktne',
-      'attention': u'Pozor!',
-      'caution': u'Opatrne!',
-      'danger': u'!NEBEZPE\u010cENSTVO!',
-      'error': u'Chyba',
-      'hint': u'Rada',
-      'important': u'D\u00F4le\u017Eit\u00E9',
-      'note': u'Pozn\u00E1mka',
-      'tip': u'Tip',
-      'warning': u'Varovanie',
-      'contents': u'Obsah'}
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-      u'autor': 'author',
-      u'autori': 'authors',
-      u'organiz\u00E1cia': 'organization',
-      u'adresa': 'address',
-      u'kontakt': 'contact',
-      u'verzia': 'version',
-      u'rev\u00EDzia': 'revision',
-      u'stav': 'status',
-      u'd\u00E1tum': 'date',
-      u'copyright': 'copyright',
-      u'venovanie': 'dedication',
-      u'abstraktne': 'abstract'}
-"""Slovak (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/languages/sv.py

-# Author:    Adam Chodorowski
-# Contact:   chodorowski@users.sourceforge.net
-# Revision:  $Revision: 1.2.10.3.8.1 $
-# Date:      $Date: 2004/05/12 19:57:42 $
-# Copyright: This module has been placed in the public domain.
-
-# New language mappings are welcome.  Before doing a new translation, please
-# read <http://docutils.sf.net/spec/howto/i18n.html>.  Two files must be
-# translated for each language: one in docutils/languages, the other in
-# docutils/parsers/rst/languages.
-
-"""
-Swedish language mappings for language-dependent features of Docutils.
-"""
-
-__docformat__ = 'reStructuredText'
-
-labels = {
-    'author':       u'F\u00f6rfattare',
-    'authors':      u'F\u00f6rfattare',
-    'organization': u'Organisation',
-    'address':      u'Adress',
-    'contact':      u'Kontakt',
-    'version':      u'Version',
-    'revision':     u'Revision',
-    'status':       u'Status',
-    'date':         u'Datum',
-    'copyright':    u'Copyright',
-    'dedication':   u'Dedikation',
-    'abstract':     u'Sammanfattning',
-    'attention':    u'Observera!',
-    'caution':      u'Varning!',
-    'danger':       u'FARA!',
-    'error':        u'Fel',
-    'hint':         u'V\u00e4gledning',
-    'important':    u'Viktigt',
-    'note':         u'Notera',
-    'tip':          u'Tips',
-    'warning':      u'Varning',
-    'contents':     u'Inneh\u00e5ll' }
-"""Mapping of node class name to label text."""
-
-bibliographic_fields = {
-    # 'Author' and 'Authors' identical in Swedish; assume the plural:
-    u'f\u00f6rfattare': 'authors',
-    u' n/a':            'author',
-    u'organisation':    'organization',
-    u'adress':          'address',
-    u'kontakt':         'contact',
-    u'version':         'version',
-    u'revision':        'revision',
-    u'status':          'status',
-    u'datum':           'date',
-    u'copyright':       'copyright',
-    u'dedikation':      'dedication', 
-    u'sammanfattning':  'abstract' }
-"""Swedish (lowcased) to canonical name mapping for bibliographic fields."""
-
-author_separators = [';', ',']
-"""List of separator strings for the 'Authors' bibliographic field. Tried in
-order."""

lib/python/docutils/parsers/__init__.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:45 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-This package contains Docutils parser modules.
-"""
-
-__docformat__ = 'reStructuredText'
-
-from docutils import Component
-
-
-class Parser(Component):
-
-    component_type = 'parser'
-    config_section = 'parsers'
-
-    def parse(self, inputstring, document):
-        """Override to parse `inputstring` into document tree `document`."""
-        raise NotImplementedError('subclass must override this method')
-
-    def setup_parse(self, inputstring, document):
-        """Initial parse setup.  Call at start of `self.parse()`."""
-        self.inputstring = inputstring
-        self.document = document
-        document.reporter.attach_observer(document.note_parse_message)
-
-    def finish_parse(self):
-        """Finalize parse details.  Call at end of `self.parse()`."""
-        self.document.reporter.detach_observer(
-            self.document.note_parse_message)
-
-
-_parser_aliases = {
-      'restructuredtext': 'rst',
-      'rest': 'rst',
-      'restx': 'rst',
-      'rtxt': 'rst',}
-
-def get_parser_class(parser_name):
-    """Return the Parser class from the `parser_name` module."""
-    parser_name = parser_name.lower()
-    if _parser_aliases.has_key(parser_name):
-        parser_name = _parser_aliases[parser_name]
-    module = __import__(parser_name, globals(), locals())
-    return module.Parser

lib/python/docutils/parsers/rst/__init__.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:46 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-This is ``docutils.parsers.rst`` package. It exports a single class, `Parser`,
-the reStructuredText parser.
-
-
-Usage
-=====
-
-1. Create a parser::
-
-       parser = docutils.parsers.rst.Parser()
-
-   Several optional arguments may be passed to modify the parser's behavior.
-   Please see `Customizing the Parser`_ below for details.
-
-2. Gather input (a multi-line string), by reading a file or the standard
-   input::
-
-       input = sys.stdin.read()
-
-3. Create a new empty `docutils.nodes.document` tree::
-
-       document = docutils.utils.new_document(source, settings)
-
-   See `docutils.utils.new_document()` for parameter details.
-
-4. Run the parser, populating the document tree::
-
-       parser.parse(input, document)
-
-
-Parser Overview
-===============
-
-The reStructuredText parser is implemented as a state machine, examining its
-input one line at a time. To understand how the parser works, please first
-become familiar with the `docutils.statemachine` module, then see the
-`states` module.
-
-
-Customizing the Parser
-----------------------
-
-Anything that isn't already customizable is that way simply because that type
-of customizability hasn't been implemented yet.  Patches welcome!
-
-When instantiating an object of the `Parser` class, two parameters may be
-passed: ``rfc2822`` and ``inliner``.  Pass ``rfc2822=1`` to enable an initial
-RFC-2822 style header block, parsed as a "field_list" element (with "class"
-attribute set to "rfc2822").  Currently this is the only body-level element
-which is customizable without subclassing.  (Tip: subclass `Parser` and change
-its "state_classes" and "initial_state" attributes to refer to new classes.
-Contact the author if you need more details.)
-
-The ``inliner`` parameter takes an instance of `states.Inliner` or a subclass.
-It handles inline markup recognition.  A common extension is the addition of
-further implicit hyperlinks, like "RFC 2822".  This can be done by subclassing
-`states.Inliner`, adding a new method for the implicit markup, and adding a
-``(pattern, method)`` pair to the "implicit_dispatch" attribute of the
-subclass.  See `states.Inliner.implicit_inline()` for details.  Explicit
-inline markup can be customized in a `states.Inliner` subclass via the
-``patterns.initial`` and ``dispatch`` attributes (and new methods as
-appropriate).
-"""
-
-__docformat__ = 'reStructuredText'
-
-
-import docutils.parsers
-import docutils.statemachine
-from docutils.parsers.rst import states
-from docutils import frontend
-
-
-class Parser(docutils.parsers.Parser):
-
-    """The reStructuredText parser."""
-
-    supported = ('restructuredtext', 'rst', 'rest', 'restx', 'rtxt', 'rstx')
-    """Aliases this parser supports."""
-
-    settings_spec = (
-        'reStructuredText Parser Options',
-        None,
-        (('Recognize and link to standalone PEP references (like "PEP 258").',
-          ['--pep-references'],
-          {'action': 'store_true', 'validator': frontend.validate_boolean}),
-         ('Base URL for PEP references '
-          '(default "http://www.python.org/peps/").',
-          ['--pep-base-url'],
-          {'metavar': '<URL>', 'default': 'http://www.python.org/peps/',
-           'validator': frontend.validate_url_trailing_slash}),
-         ('Recognize and link to standalone RFC references (like "RFC 822").',
-          ['--rfc-references'],
-          {'action': 'store_true', 'validator': frontend.validate_boolean}),
-         ('Base URL for RFC references (default "http://www.faqs.org/rfcs/").',
-          ['--rfc-base-url'],
-          {'metavar': '<URL>', 'default': 'http://www.faqs.org/rfcs/',
-           'validator': frontend.validate_url_trailing_slash}),
-         ('Set number of spaces for tab expansion (default 8).',
-          ['--tab-width'],
-          {'metavar': '<width>', 'type': 'int', 'default': 8}),
-         ('Remove spaces before footnote references.',
-          ['--trim-footnote-reference-space'],
-          {'action': 'store_true', 'validator': frontend.validate_boolean}),))
-
-    config_section = 'restructuredtext parser'
-    config_section_dependencies = ('parsers',)
-
-    def __init__(self, rfc2822=None, inliner=None):
-        if rfc2822:
-            self.initial_state = 'RFC2822Body'
-        else:
-            self.initial_state = 'Body'
-        self.state_classes = states.state_classes
-        self.inliner = inliner
-
-    def parse(self, inputstring, document):
-        """Parse `inputstring` and populate `document`, a document tree."""
-        self.setup_parse(inputstring, document)
-        debug = document.reporter[''].debug
-        self.statemachine = states.RSTStateMachine(
-              state_classes=self.state_classes,
-              initial_state=self.initial_state,
-              debug=debug)
-        inputlines = docutils.statemachine.string2lines(
-              inputstring, tab_width=document.settings.tab_width,
-              convert_whitespace=1)
-        self.statemachine.run(inputlines, document, inliner=self.inliner)
-        self.finish_parse()

lib/python/docutils/parsers/rst/directives/admonitions.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:48 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-Admonition directives.
-"""
-
-__docformat__ = 'reStructuredText'
-
-
-from docutils.parsers.rst import states, directives
-from docutils import nodes
-
-
-def make_admonition(node_class, name, arguments, options, content, lineno,
-                       content_offset, block_text, state, state_machine):
-    if not content:
-        error = state_machine.reporter.error(
-            'The "%s" admonition is empty; content required.' % (name),
-            nodes.literal_block(block_text, block_text), line=lineno)
-        return [error]
-    text = '\n'.join(content)
-    admonition_node = node_class(text)
-    if arguments:
-        title_text = arguments[0]
-        textnodes, messages = state.inline_text(title_text, lineno)
-        admonition_node += nodes.title(title_text, '', *textnodes)
-        admonition_node += messages
-        if options.has_key('class'):
-            class_value = options['class']
-        else:
-            class_value = 'admonition-' + nodes.make_id(title_text)
-        admonition_node.set_class(class_value)
-    state.nested_parse(content, content_offset, admonition_node)
-    return [admonition_node]
-
-def admonition(*args):
-    return make_admonition(nodes.admonition, *args)
-
-admonition.arguments = (1, 0, 1)
-admonition.options = {'class': directives.class_option}
-admonition.content = 1
-
-def attention(*args):
-    return make_admonition(nodes.attention, *args)
-
-attention.content = 1
-
-def caution(*args):
-    return make_admonition(nodes.caution, *args)
-
-caution.content = 1
-
-def danger(*args):
-    return make_admonition(nodes.danger, *args)
-
-danger.content = 1
-
-def error(*args):
-    return make_admonition(nodes.error, *args)
-
-error.content = 1
-
-def hint(*args):
-    return make_admonition(nodes.hint, *args)
-
-hint.content = 1
-
-def important(*args):
-    return make_admonition(nodes.important, *args)
-
-important.content = 1
-
-def note(*args):
-    return make_admonition(nodes.note, *args)
-
-note.content = 1
-
-def tip(*args):
-    return make_admonition(nodes.tip, *args)
-
-tip.content = 1
-
-def warning(*args):
-    return make_admonition(nodes.warning, *args)
-
-warning.content = 1

lib/python/docutils/parsers/rst/directives/body.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:48 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-Directives for additional body elements.
-"""
-
-__docformat__ = 'reStructuredText'
-
-
-import sys
-from docutils import nodes
-from docutils.parsers.rst import directives
-
-              
-def topic(name, arguments, options, content, lineno,
-          content_offset, block_text, state, state_machine,
-          node_class=nodes.topic):
-    if not state_machine.match_titles:
-        error = state_machine.reporter.error(
-              'The "%s" directive may not be used within topics, sidebars, '
-              'or body elements.' % name,
-              nodes.literal_block(block_text, block_text), line=lineno)
-        return [error]
-    if not content:
-        warning = state_machine.reporter.warning(
-            'Content block expected for the "%s" directive; none found.'
-            % name, nodes.literal_block(block_text, block_text),
-            line=lineno)
-        return [warning]
-    title_text = arguments[0]
-    textnodes, messages = state.inline_text(title_text, lineno)
-    titles = [nodes.title(title_text, '', *textnodes)]
-    # sidebar uses this code
-    if options.has_key('subtitle'):
-        textnodes, more_messages = state.inline_text(options['subtitle'],
-                                                     lineno)
-        titles.append(nodes.subtitle(options['subtitle'], '', *textnodes))
-        messages.extend(more_messages)
-    text = '\n'.join(content)
-    node = node_class(text, *(titles + messages))
-    if options.has_key('class'):
-        node.set_class(options['class'])
-    if text:
-        state.nested_parse(content, content_offset, node)
-    return [node]
-
-topic.arguments = (1, 0, 1)
-topic.options = {'class': directives.class_option}
-topic.content = 1
-
-def sidebar(name, arguments, options, content, lineno,
-            content_offset, block_text, state, state_machine):
-    return topic(name, arguments, options, content, lineno,
-                 content_offset, block_text, state, state_machine,
-                 node_class=nodes.sidebar)
-
-sidebar.arguments = (1, 0, 1)
-sidebar.options = {'subtitle': directives.unchanged_required,
-                   'class': directives.class_option}
-sidebar.content = 1
-
-def line_block(name, arguments, options, content, lineno,
-               content_offset, block_text, state, state_machine,
-               node_class=nodes.line_block):
-    if not content:
-        warning = state_machine.reporter.warning(
-            'Content block expected for the "%s" directive; none found.'
-            % name, nodes.literal_block(block_text, block_text), line=lineno)
-        return [warning]
-    text = '\n'.join(content)
-    text_nodes, messages = state.inline_text(text, lineno)
-    node = node_class(text, '', *text_nodes, **options)
-    node.line = content_offset + 1
-    return [node] + messages
-
-line_block.options = {'class': directives.class_option}
-line_block.content = 1
-
-def parsed_literal(name, arguments, options, content, lineno,
-                   content_offset, block_text, state, state_machine):
-    return line_block(name, arguments, options, content, lineno,
-                      content_offset, block_text, state, state_machine,
-                      node_class=nodes.literal_block)
-
-parsed_literal.options = {'class': directives.class_option}
-parsed_literal.content = 1
-
-def rubric(name, arguments, options, content, lineno,
-             content_offset, block_text, state, state_machine):
-    rubric_text = arguments[0]
-    textnodes, messages = state.inline_text(rubric_text, lineno)
-    rubric = nodes.rubric(rubric_text, '', *textnodes, **options)
-    return [rubric] + messages
-
-rubric.arguments = (1, 0, 1)
-rubric.options = {'class': directives.class_option}
-
-def epigraph(name, arguments, options, content, lineno,
-             content_offset, block_text, state, state_machine):
-    block_quote, messages = state.block_quote(content, content_offset)
-    block_quote.set_class('epigraph')
-    return [block_quote] + messages
-
-epigraph.content = 1
-
-def highlights(name, arguments, options, content, lineno,
-             content_offset, block_text, state, state_machine):
-    block_quote, messages = state.block_quote(content, content_offset)
-    block_quote.set_class('highlights')
-    return [block_quote] + messages
-
-highlights.content = 1
-
-def pull_quote(name, arguments, options, content, lineno,
-             content_offset, block_text, state, state_machine):
-    block_quote, messages = state.block_quote(content, content_offset)
-    block_quote.set_class('pull-quote')
-    return [block_quote] + messages
-
-pull_quote.content = 1

lib/python/docutils/parsers/rst/directives/html.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:48 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-Directives for typically HTML-specific constructs.
-"""
-
-__docformat__ = 'reStructuredText'
-
-import sys
-from docutils import nodes, utils
-from docutils.parsers.rst import states
-from docutils.transforms import components
-
-
-def meta(name, arguments, options, content, lineno,
-         content_offset, block_text, state, state_machine):
-    node = nodes.Element()
-    if content:
-        new_line_offset, blank_finish = state.nested_list_parse(
-              content, content_offset, node, initial_state='MetaBody',
-              blank_finish=1, state_machine_kwargs=metaSMkwargs)
-        if (new_line_offset - content_offset) != len(content):
-            # incomplete parse of block?
-            error = state_machine.reporter.error(
-                'Invalid meta directive.',
-                nodes.literal_block(block_text, block_text), line=lineno)
-            node += error
-    else:
-        error = state_machine.reporter.error(
-            'Empty meta directive.',
-            nodes.literal_block(block_text, block_text), line=lineno)
-        node += error
-    return node.get_children()
-
-meta.content = 1
-
-def imagemap(name, arguments, options, content, lineno,
-             content_offset, block_text, state, state_machine):
-    return []
-
-
-class MetaBody(states.SpecializedBody):
-
-    class meta(nodes.Special, nodes.PreBibliographic, nodes.Element):
-        """HTML-specific "meta" element."""
-        pass
-
-    def field_marker(self, match, context, next_state):
-        """Meta element."""
-        node, blank_finish = self.parsemeta(match)
-        self.parent += node
-        return [], next_state, []
-
-    def parsemeta(self, match):
-        name = self.parse_field_marker(match)
-        indented, indent, line_offset, blank_finish = \
-              self.state_machine.get_first_known_indented(match.end())
-        node = self.meta()
-        pending = nodes.pending(components.Filter,
-                                {'component': 'writer',
-                                 'format': 'html',
-                                 'nodes': [node]})
-        node['content'] = ' '.join(indented)
-        if not indented:
-            line = self.state_machine.line
-            msg = self.reporter.info(
-                  'No content for meta tag "%s".' % name,
-                  nodes.literal_block(line, line),
-                  line=self.state_machine.abs_line_number())
-            return msg, blank_finish
-        tokens = name.split()
-        try:
-            attname, val = utils.extract_name_value(tokens[0])[0]
-            node[attname.lower()] = val
-        except utils.NameValueError:
-            node['name'] = tokens[0]
-        for token in tokens[1:]:
-            try:
-                attname, val = utils.extract_name_value(token)[0]
-                node[attname.lower()] = val
-            except utils.NameValueError, detail:
-                line = self.state_machine.line
-                msg = self.reporter.error(
-                      'Error parsing meta tag attribute "%s": %s.'
-                      % (token, detail), nodes.literal_block(line, line),
-                      line=self.state_machine.abs_line_number())
-                return msg, blank_finish
-        self.document.note_pending(pending)
-        return pending, blank_finish
-
-
-metaSMkwargs = {'state_classes': (MetaBody,)}

lib/python/docutils/parsers/rst/directives/images.py

-# Author: David Goodger
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:48 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-Directives for figures and simple images.
-"""
-
-__docformat__ = 'reStructuredText'
-
-
-import sys
-from docutils import nodes, utils
-from docutils.parsers.rst import directives, states
-from docutils.nodes import whitespace_normalize_name
-
-try:
-    import Image                        # PIL
-except ImportError:
-    Image = None
-
-align_values = ('top', 'middle', 'bottom', 'left', 'center', 'right')
-
-def align(argument):
-    return directives.choice(argument, align_values)
-
-def image(name, arguments, options, content, lineno,
-          content_offset, block_text, state, state_machine):
-    messages = []
-    reference = ''.join(arguments[0].split('\n'))
-    if reference.find(' ') != -1:
-        error = state_machine.reporter.error(
-              'Image URI contains whitespace.',
-              nodes.literal_block(block_text, block_text), line=lineno)
-        return [error]
-    options['uri'] = reference
-    reference_node = None
-    if options.has_key('target'):
-        block = states.escape2null(options['target']).splitlines()
-        block = [line for line in block]
-        target_type, data = state.parse_target(block, block_text, lineno)
-        if target_type == 'refuri':
-            reference_node = nodes.reference(refuri=data)
-        elif target_type == 'refname':
-            reference_node = nodes.reference(
-                refname=data, name=whitespace_normalize_name(options['target']))
-            state.document.note_refname(reference_node)
-        else:                           # malformed target
-            messages.append(data)       # data is a system message
-        del options['target']
-    image_node = nodes.image(block_text, **options)
-    if reference_node:
-        reference_node += image_node
-        return messages + [reference_node]
-    else:
-        return messages + [image_node]
-
-image.arguments = (1, 0, 1)
-image.options = {'alt': directives.unchanged,
-                 'height': directives.nonnegative_int,
-                 'width': directives.nonnegative_int,
-                 'scale': directives.nonnegative_int,
-                 'align': align,
-                 'target': directives.unchanged_required,
-                 'class': directives.class_option}
-
-def figure(name, arguments, options, content, lineno,
-           content_offset, block_text, state, state_machine):
-    figwidth = options.setdefault('figwidth')
-    figclass = options.setdefault('figclass')
-    del options['figwidth']
-    del options['figclass']
-    (image_node,) = image(name, arguments, options, content, lineno,
-                         content_offset, block_text, state, state_machine)
-    if isinstance(image_node, nodes.system_message):
-        return [image_node]
-    figure_node = nodes.figure('', image_node)
-    if figwidth == 'image':
-        if Image:
-            # PIL doesn't like Unicode paths:
-            try:
-                i = Image.open(str(image_node['uri']))
-            except (IOError, UnicodeError):
-                pass
-            else:
-                figure_node['width'] = i.size[0]
-    elif figwidth is not None:
-        figure_node['width'] = figwidth
-    if figclass:
-        figure_node.set_class(figclass)
-    if content:
-        node = nodes.Element()          # anonymous container for parsing
-        state.nested_parse(content, content_offset, node)
-        first_node = node[0]
-        if isinstance(first_node, nodes.paragraph):
-            caption = nodes.caption(first_node.rawsource, '',
-                                    *first_node.children)
-            figure_node += caption
-        elif not (isinstance(first_node, nodes.comment)
-                  and len(first_node) == 0):
-            error = state_machine.reporter.error(
-                  'Figure caption must be a paragraph or empty comment.',
-                  nodes.literal_block(block_text, block_text), line=lineno)
-            return [figure_node, error]
-        if len(node) > 1:
-            figure_node += nodes.legend('', *node[1:])
-    return [figure_node]
-
-def figwidth_value(argument):
-    if argument.lower() == 'image':
-        return 'image'
-    else:
-        return directives.nonnegative_int(argument)
-
-figure.arguments = (1, 0, 1)
-figure.options = {'figwidth': figwidth_value,
-                  'figclass': directives.class_option}
-figure.options.update(image.options)
-figure.content = 1

lib/python/docutils/parsers/rst/directives/references.py

-# Author: David Goodger, Dmitry Jemerov
-# Contact: goodger@users.sourceforge.net
-# Revision: $Revision: 1.2.10.3.8.1 $
-# Date: $Date: 2004/05/12 19:57:48 $
-# Copyright: This module has been placed in the public domain.
-
-"""
-Directives for references and targets.
-"""
-
-__docformat__ = 'reStructuredText'
-
-from docutils import nodes
-from docutils.transforms import references
-
-
-def target_notes(name, arguments, options, content, lineno,
-                 content_offset, block_text, state, state_machine):
-    """Target footnote generation."""
-    pending = nodes.pending(references.TargetNotes)
-    state_machine.document.note_pending(pending)
-    nodelist = [pending]
-    return nodelist