python-peps/pep2html.py

#!/usr/bin/env python
"""Convert PEPs to (X)HTML - courtesy of /F

Usage: %(PROGRAM)s [options] [<peps> ...]

Options:

-u, --user
    python.org username

-b, --browse
    After generating the HTML, direct your web browser to view it
    (using the Python webbrowser module).  If both -i and -b are
    given, this will browse the on-line HTML; otherwise it will
    browse the local HTML.  If no pep arguments are given, this
    will browse PEP 0.

-i, --install
    After generating the HTML, install it and the plaintext source file
    (.txt) on python.org.  In that case the user's name is used in the scp
    and ssh commands, unless "-u username" is given (in which case, it is
    used instead).  Without -i, -u is ignored.

-l, --local
    Same as -i/--install, except install on the local machine.  Use this
    when logged in to the python.org machine (dinsdale).

-q, --quiet
    Turn off verbose messages.

-h, --help
    Print this help message and exit.

The optional arguments ``peps`` are either pep numbers or .txt files.
"""

import sys
import os
import re
import cgi
import glob
import getopt
import errno
import random
import time

REQUIRES = {'python': '2.2',
            'docutils': '0.2.7'}
PROGRAM = sys.argv[0]
RFCURL = 'http://www.faqs.org/rfcs/rfc%d.html'
PEPURL = 'pep-%04d.html'
PEPCVSURL = ('http://svn.python.org/view/peps/trunk/pep-%04d.txt')
PEPDIRRUL = 'http://www.python.org/peps/'


HOST = "dinsdale.python.org"                    # host for update
HDIR = "/data/ftp.python.org/pub/www.python.org/peps" # target host directory
LOCALVARS = "Local Variables:"

COMMENT = """<!--
This HTML is auto-generated.  DO NOT EDIT THIS FILE!  If you are writing a new
PEP, see http://www.python.org/peps/pep-0001.html for instructions and links
to templates.  DO NOT USE THIS HTML FILE AS YOUR TEMPLATE!
-->"""

# The generated HTML doesn't validate -- you cannot use <hr> and <h3> inside
# <pre> tags.  But if I change that, the result doesn't look very nice...
DTD = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"\n'
       '                      "http://www.w3.org/TR/REC-html40/loose.dtd">')

fixpat = re.compile("((https?|ftp):[-_a-zA-Z0-9/.+~:?#$=&,]+)|(pep-\d+(.txt)?)|"
                    "(RFC[- ]?(?P<rfcnum>\d+))|"
                    "(PEP\s+(?P<pepnum>\d+))|"
                    ".")

EMPTYSTRING = ''
SPACE = ' '
COMMASPACE = ', '


def usage(code, msg=''):
    """Print usage message and exit.  Uses stderr if code != 0."""
    if code == 0:
        out = sys.stdout
    else:
        out = sys.stderr
    print >> out, __doc__ % globals()
    if msg:
        print >> out, msg
    sys.exit(code)


def fixanchor(current, match):
    text = match.group(0)
    link = None
    if (text.startswith('http:') or text.startswith('https:')
        or text.startswith('ftp:')):
        # Strip off trailing punctuation.  Pattern taken from faqwiz.
        ltext = list(text)
        while ltext:
            c = ltext.pop()
            if c not in '();:,.?\'"<>':
                ltext.append(c)
                break
        link = EMPTYSTRING.join(ltext)
    elif text.startswith('pep-') and text <> current:
        link = os.path.splitext(text)[0] + ".html"
    elif text.startswith('PEP'):
        pepnum = int(match.group('pepnum'))
        link = PEPURL % pepnum
    elif text.startswith('RFC'):
        rfcnum = int(match.group('rfcnum'))
        link = RFCURL % rfcnum
    if link:
        return '<a href="%s">%s</a>' % (cgi.escape(link), cgi.escape(text))
    return cgi.escape(match.group(0)) # really slow, but it works...


NON_MASKED_EMAILS = [
    'peps@python.org',
    'python-list@python.org',
    'python-dev@python.org',
    ]

def fixemail(address, pepno):
    if address.lower() in NON_MASKED_EMAILS:
        # return hyperlinked version of email address
        return linkemail(address, pepno)
    else:
        # return masked version of email address
        parts = address.split('@', 1)
        return '%s&#32;&#97;t&#32;%s' % (parts[0], parts[1])


def linkemail(address, pepno):
    parts = address.split('@', 1)
    return ('<a href="mailto:%s&#64;%s?subject=PEP%%20%s">'
            '%s&#32;&#97;t&#32;%s</a>'
            % (parts[0], parts[1], pepno, parts[0], parts[1]))


def fixfile(inpath, input_lines, outfile):
    from email.Utils import parseaddr
    basename = os.path.basename(inpath)
    infile = iter(input_lines)
    # convert plaintext pep to minimal XHTML markup
    print >> outfile, DTD
    print >> outfile, '<html>'
    print >> outfile, COMMENT
    print >> outfile, '<head>'
    # head
    header = []
    pep = ""
    title = ""
    for line in infile:
        if not line.strip():
            break
        if line[0].strip():
            if ":" not in line:
                break
            key, value = line.split(":", 1)
            value = value.strip()
            header.append((key, value))
        else:
            # continuation line
            key, value = header[-1]
            value = value + line
            header[-1] = key, value
        if key.lower() == "title":
            title = value
        elif key.lower() == "pep":
            pep = value
    if pep:
        title = "PEP " + pep + " -- " + title
    if title:
        print >> outfile, '  <title>%s</title>' % cgi.escape(title)
    r = random.choice(range(64))
    print >> outfile, (
        '  <link rel="STYLESHEET" href="style.css" type="text/css" />\n'
        '</head>\n'
        '<body bgcolor="white">\n'
        '<table class="navigation" cellpadding="0" cellspacing="0"\n'
        '       width="100%%" border="0">\n'
        '<tr><td class="navicon" width="150" height="35">\n'
        '<a href="../" title="Python Home Page">\n'
        '<img src="../pics/PyBanner%03d.gif" alt="[Python]"\n'
        ' border="0" width="150" height="35" /></a></td>\n'
        '<td class="textlinks" align="left">\n'
        '[<b><a href="../">Python Home</a></b>]' % r)
    if basename <> 'pep-0000.txt':
        print >> outfile, '[<b><a href=".">PEP Index</a></b>]'
    if pep:
        try:
            print >> outfile, ('[<b><a href="pep-%04d.txt">PEP Source</a>'
                               '</b>]' % int(pep))
        except ValueError, error:
            print >> sys.stderr, ('ValueError (invalid PEP number): %s'
                                  % error)
    print >> outfile, '</td></tr></table>'
    print >> outfile, '<div class="header">\n<table border="0">'
    for k, v in header:
        if k.lower() in ('author', 'discussions-to'):
            mailtos = []
            for part in re.split(',\s*', v):
                if '@' in part:
                    realname, addr = parseaddr(part)
                    if k.lower() == 'discussions-to':
                        m = linkemail(addr, pep)
                    else:
                        m = fixemail(addr, pep)
                    mailtos.append('%s &lt;%s&gt;' % (realname, m))
                elif part.startswith('http:'):
                    mailtos.append(
                        '<a href="%s">%s</a>' % (part, part))
                else:
                    mailtos.append(part)
            v = COMMASPACE.join(mailtos)
        elif k.lower() in ('replaces', 'replaced-by', 'requires'):
            otherpeps = ''
            for otherpep in re.split(',?\s+', v):
                otherpep = int(otherpep)
                otherpeps += '<a href="pep-%04d.html">%i</a> ' % (otherpep,
                                                                  otherpep)
            v = otherpeps
        elif k.lower() in ('last-modified',):
            date = v or time.strftime('%d-%b-%Y',
                                      time.localtime(os.stat(inpath)[8]))
            try:
                url = PEPCVSURL % int(pep)
                v = '<a href="%s">%s</a> ' % (url, cgi.escape(date))
            except ValueError, error:
                v = date
        elif k.lower() in ('content-type',):
            url = PEPURL % 9
            pep_type = v or 'text/plain'
            v = '<a href="%s">%s</a> ' % (url, cgi.escape(pep_type))
        else:
            v = cgi.escape(v)
        print >> outfile, '  <tr><th>%s:&nbsp;</th><td>%s</td></tr>' \
              % (cgi.escape(k), v)
    print >> outfile, '</table>'
    print >> outfile, '</div>'
    print >> outfile, '<hr />'
    print >> outfile, '<div class="content">'
    need_pre = 1
    for line in infile:
        if line[0] == '\f':
            continue
        if line.strip() == LOCALVARS:
            break
        if line[0].strip():
            if not need_pre:
                print >> outfile, '</pre>'
            print >> outfile, '<h3>%s</h3>' % line.strip()
            need_pre = 1
        elif not line.strip() and need_pre:
            continue
        else:
            # PEP 0 has some special treatment
            if basename == 'pep-0000.txt':
                parts = line.split()
                if len(parts) > 1 and re.match(r'\s*\d{1,4}', parts[1]):
                    # This is a PEP summary line, which we need to hyperlink
                    url = PEPURL % int(parts[1])
                    if need_pre:
                        print >> outfile, '<pre>'
                        need_pre = 0
                    print >> outfile, re.sub(
                        parts[1],
                        '<a href="%s">%s</a>' % (url, parts[1]),
                        line, 1),
                    continue
                elif parts and '@' in parts[-1]:
                    # This is a pep email address line, so filter it.
                    url = fixemail(parts[-1], pep)
                    if need_pre:
                        print >> outfile, '<pre>'
                        need_pre = 0
                    print >> outfile, re.sub(
                        parts[-1], url, line, 1),
                    continue
            line = fixpat.sub(lambda x, c=inpath: fixanchor(c, x), line)
            if need_pre:
                print >> outfile, '<pre>'
                need_pre = 0
            outfile.write(line)
    if not need_pre:
        print >> outfile, '</pre>'
    print >> outfile, '</div>'
    print >> outfile, '</body>'
    print >> outfile, '</html>'


docutils_settings = None
"""Runtime settings object used by Docutils.  Can be set by the client
application when this module is imported."""

def fix_rst_pep(inpath, input_lines, outfile):
    from docutils import core
    output = core.publish_string(
        source=''.join(input_lines),
        source_path=inpath,
        destination_path=outfile.name,
        reader_name='pep',
        parser_name='restructuredtext',
        writer_name='pep_html',
        settings=docutils_settings,
        # Allow Docutils traceback if there's an exception:
        settings_overrides={'traceback': 1})
    outfile.write(output)


def get_pep_type(input_lines):
    """
    Return the Content-Type of the input.  "text/plain" is the default.
    Return ``None`` if the input is not a PEP.
    """
    pep_type = None
    for line in input_lines:
        line = line.rstrip().lower()
        if not line:
            # End of the RFC 2822 header (first blank line).
            break
        elif line.startswith('content-type: '):
            pep_type = line.split()[1] or 'text/plain'
            break
        elif line.startswith('pep: '):
            # Default PEP type, used if no explicit content-type specified:
            pep_type = 'text/plain'
    return pep_type


def get_input_lines(inpath):
    try:
        infile = open(inpath)
    except IOError, e:
        if e.errno <> errno.ENOENT: raise
        print >> sys.stderr, 'Error: Skipping missing PEP file:', e.filename
        sys.stderr.flush()
        return None, None
    lines = infile.read().splitlines(1) # handles x-platform line endings
    infile.close()
    return lines


def find_pep(pep_str):
    """Find the .txt file indicated by a cmd line argument"""
    if os.path.exists(pep_str):
        return pep_str
    num = int(pep_str)
    return "pep-%04d.txt" % num

def make_html(inpath, verbose=0):
    input_lines = get_input_lines(inpath)
    pep_type = get_pep_type(input_lines)
    if pep_type is None:
        print >> sys.stderr, 'Error: Input file %s is not a PEP.' % inpath
        sys.stdout.flush()
        return None
    elif not PEP_TYPE_DISPATCH.has_key(pep_type):
        print >> sys.stderr, ('Error: Unknown PEP type for input file %s: %s'
                              % (inpath, pep_type))
        sys.stdout.flush()
        return None
    elif PEP_TYPE_DISPATCH[pep_type] == None:
        pep_type_error(inpath, pep_type)
        return None
    outpath = os.path.splitext(inpath)[0] + ".html"
    if verbose:
        print inpath, "(%s)" % pep_type, "->", outpath
        sys.stdout.flush()
    outfile = open(outpath, "w")
    PEP_TYPE_DISPATCH[pep_type](inpath, input_lines, outfile)
    outfile.close()
    os.chmod(outfile.name, 0664)
    return outpath

def push_pep(htmlfiles, txtfiles, username, verbose, local=0):
    quiet = ""
    if local:
        if verbose:
            quiet = "-v"
        target = HDIR
        copy_cmd = "cp"
        chmod_cmd = "chmod"
    else:
        if not verbose:
            quiet = "-q"
        if username:
            username = username + "@"
        target = username + HOST + ":" + HDIR
        copy_cmd = "scp"
        chmod_cmd = "ssh %s%s chmod" % (username, HOST)
    files = htmlfiles[:]
    files.extend(txtfiles)
    files.append("style.css")
    files.append("pep.css")
    filelist = SPACE.join(files)
    rc = os.system("%s %s %s %s" % (copy_cmd, quiet, filelist, target))
    if rc:
        sys.exit(rc)
##    rc = os.system("%s 664 %s/*" % (chmod_cmd, HDIR))
##    if rc:
##        sys.exit(rc)


PEP_TYPE_DISPATCH = {'text/plain': fixfile,
                     'text/x-rst': fix_rst_pep}
PEP_TYPE_MESSAGES = {}

def check_requirements():
    # Check Python:
    try:
        from email.Utils import parseaddr
    except ImportError:
        PEP_TYPE_DISPATCH['text/plain'] = None
        PEP_TYPE_MESSAGES['text/plain'] = (
            'Python %s or better required for "%%(pep_type)s" PEP '
            'processing; %s present (%%(inpath)s).'
            % (REQUIRES['python'], sys.version.split()[0]))
    # Check Docutils:
    try:
        import docutils
    except ImportError:
        PEP_TYPE_DISPATCH['text/x-rst'] = None
        PEP_TYPE_MESSAGES['text/x-rst'] = (
            'Docutils not present for "%(pep_type)s" PEP file %(inpath)s.  '
            'See README.txt for installation.')
    else:
        installed = [int(part) for part in docutils.__version__.split('.')]
        required = [int(part) for part in REQUIRES['docutils'].split('.')]
        if installed < required:
            PEP_TYPE_DISPATCH['text/x-rst'] = None
            PEP_TYPE_MESSAGES['text/x-rst'] = (
                'Docutils must be reinstalled for "%%(pep_type)s" PEP '
                'processing (%%(inpath)s).  Version %s or better required; '
                '%s present.  See README.txt for installation.'
                % (REQUIRES['docutils'], docutils.__version__))

def pep_type_error(inpath, pep_type):
    print >> sys.stderr, 'Error: ' + PEP_TYPE_MESSAGES[pep_type] % locals()
    sys.stdout.flush()


def browse_file(pep):
    import webbrowser
    file = find_pep(pep)
    if file.endswith(".txt"):
        file = file[:-3] + "html"
    file = os.path.abspath(file)
    url = "file:" + file
    webbrowser.open(url)

def browse_remote(pep):
    import webbrowser
    file = find_pep(pep)
    if file.endswith(".txt"):
        file = file[:-3] + "html"
    url = PEPDIRRUL + file
    webbrowser.open(url)


def main(argv=None):
    # defaults
    update = 0
    local = 0
    username = ''
    verbose = 1
    browse = 0

    check_requirements()

    if argv is None:
        argv = sys.argv[1:]

    try:
        opts, args = getopt.getopt(
            argv, 'bilhqu:',
            ['browse', 'install', 'local', 'help', 'quiet', 'user='])
    except getopt.error, msg:
        usage(1, msg)

    for opt, arg in opts:
        if opt in ('-h', '--help'):
            usage(0)
        elif opt in ('-i', '--install'):
            update = 1
        elif opt in ('-l', '--local'):
            update = 1
            local = 1
        elif opt in ('-u', '--user'):
            username = arg
        elif opt in ('-q', '--quiet'):
            verbose = 0
        elif opt in ('-b', '--browse'):
            browse = 1

    if args:
        peptxt = []
        html = []
        for pep in args:
            file = find_pep(pep)
            peptxt.append(file)
            newfile = make_html(file, verbose=verbose)
            if newfile:
                html.append(newfile)
            if browse and not update:
                browse_file(pep)
    else:
        # do them all
        peptxt = []
        html = []
        files = glob.glob("pep-*.txt")
        files.sort()
        for file in files:
            peptxt.append(file)
            newfile = make_html(file, verbose=verbose)
            if newfile:
                html.append(newfile)
        if browse and not update:
            browse_file("0")

    if update:
        push_pep(html, peptxt, username, verbose, local=local)
        if browse:
            if args:
                for pep in args:
                    browse_remote(pep)
            else:
                browse_remote("0")


if __name__ == "__main__":
    main()
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								#!/usr/bin/env python
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								"""Convert PEPs to (X)HTML - courtesy of /F
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								Usage: %(PROGRAM)s [options] [<peps> ...]
-												new usage to support conversion of only specified PEPs

Usage: %(PROGRAM)s [options] [peps]
Notes:
    The optional argument peps can be either pep numbers or .txt files.
Options:
    -u/--user
        SF username
    [rest is the same]

											
										
										
											2000-08-28 12:00:49 -04:00
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								Options:
-												Revise the generated HTML to be a little nicer, but still pretty simple.
Also add a -n option to suppress installing the generated HTML at
SourceForge to allow local use.

											
										
										
											2000-07-24 23:51:44 -04:00
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								-u, --user
 								    python.org username
-												new usage to support conversion of only specified PEPs

Usage: %(PROGRAM)s [options] [peps]
Notes:
    The optional argument peps can be either pep numbers or .txt files.
Options:
    -u/--user
        SF username
    [rest is the same]

											
										
										
											2000-08-28 12:00:49 -04:00
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								-b, --browse
 								    After generating the HTML, direct your web browser to view it
 								    (using the Python webbrowser module).  If both -i and -b are
 								    given, this will browse the on-line HTML; otherwise it will
 								    browse the local HTML.  If no pep arguments are given, this
 								    will browse PEP 0.
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								-i, --install
 								    After generating the HTML, install it and the plaintext source file
 								    (.txt) on python.org.  In that case the user's name is used in the scp
 								    and ssh commands, unless "-u username" is given (in which case, it is
 								    used instead).  Without -i, -u is ignored.
-												Revise the generated HTML to be a little nicer, but still pretty simple.
Also add a -n option to suppress installing the generated HTML at
SourceForge to allow local use.

											
										
										
											2000-07-24 23:51:44 -04:00
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								-l, --local
 								    Same as -i/--install, except install on the local machine.  Use this
-												Use new www server hostname

											
										
										
											2005-10-12 12:08:28 -04:00
+								    when logged in to the python.org machine (dinsdale).
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								-q, --quiet
 								    Turn off verbose messages.
-												Document -q/--quiet in the module docstring.

											
										
										
											2000-11-03 10:43:28 -05:00
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								-h, --help
 								    Print this help message and exit.
-												Slight rewording of docstring.

											
										
										
											2001-11-12 09:58:07 -05:00
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								The optional arguments ``peps`` are either pep numbers or .txt files.
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								"""
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								import sys
 								import os
 								import re
 								import cgi
 								import glob
 								import getopt
-												fixpat: Recognize current preferred usage for PEP references in body,
e.g. "PEP 1".

fixanchor(): Turn preferred usage for PEP references into PEP url
using the new PEPURL template (which uses the canonical
www.python.org/peps url instead of the sourceforge.net site).
(Also, get rid of base argument in int() calls; base 10 is default.)

fixfile(): If we can't open the input file, print an error message and
continue on.

											
										
										
											2001-07-05 14:44:20 -04:00
+								import errno
-												Move the publication site for PEPs to python.org.

											
										
										
											2002-04-02 18:07:13 -05:00
+								import random
-												Added support for Last-Modified header and its (possibly automatic)
generation.

											
										
										
											2002-03-01 14:07:46 -05:00
+								import time
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								REQUIRES = {'python': '2.2',
-												Updated for new ``publish_string()`` convenience function.

											
										
										
											2002-10-18 21:33:12 -04:00
+								            'docutils': '0.2.7'}
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								PROGRAM = sys.argv[0]
-												fixanchor(): Use a module global RFCURL template for RFC urls.  Change
this template to point at the nice faqs.org html-ified RFCs.

											
										
										
											2001-06-05 13:21:19 -04:00
+								RFCURL = 'http://www.faqs.org/rfcs/rfc%d.html'
-												fixpat: Recognize current preferred usage for PEP references in body,
e.g. "PEP 1".

fixanchor(): Turn preferred usage for PEP references into PEP url
using the new PEPURL template (which uses the canonical
www.python.org/peps url instead of the sourceforge.net site).
(Also, get rid of base argument in int() calls; base 10 is default.)

fixfile(): If we can't open the input file, print an error message and
continue on.

											
										
										
											2001-07-05 14:44:20 -04:00
+								PEPURL = 'pep-%04d.html'
-												- Fix the link to the svn equivalent of viewcvs.
- Expand keywords in PEP 352.txt.

											
										
										
											2005-10-31 19:17:41 -05:00
+								PEPCVSURL = ('http://svn.python.org/view/peps/trunk/pep-%04d.txt')
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
+								PEPDIRRUL = 'http://www.python.org/peps/'
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
-												Use new www server hostname

											
										
										
											2005-10-12 12:08:28 -04:00
+								HOST = "dinsdale.python.org"                    # host for update
-												The root of the tree on dinsdale is /data, not /ftp.

											
										
										
											2005-10-13 17:04:15 -04:00
+								HDIR = "/data/ftp.python.org/pub/www.python.org/peps" # target host directory
-												Moved "Local Variables:" string farther away from the end of the file,
so Emacs doesn't think this actually indicates the beginning of a
local variable section!

											
										
										
											2000-07-28 02:40:10 -04:00
+								LOCALVARS = "Local Variables:"
-												try to change rights of peps to rw-rw-r--

											
										
										
											2000-07-25 00:12:28 -04:00
-												Added "DO NOT EDIT" comment.  Updated from Docutils.

											
										
										
											2002-11-07 22:43:48 -05:00
+								COMMENT = """<!--
 								This HTML is auto-generated.  DO NOT EDIT THIS FILE!  If you are writing a new
 								PEP, see http://www.python.org/peps/pep-0001.html for instructions and links
 								to templates.  DO NOT USE THIS HTML FILE AS YOUR TEMPLATE!
 								-->"""
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								# The generated HTML doesn't validate -- you cannot use <hr> and <h3> inside
 								# <pre> tags.  But if I change that, the result doesn't look very nice...
-												Revise the generated HTML to be a little nicer, but still pretty simple.
Also add a -n option to suppress installing the generated HTML at
SourceForge to allow local use.

											
										
										
											2000-07-24 23:51:44 -04:00
+								DTD = ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"\n'
 								       '                      "http://www.w3.org/TR/REC-html40/loose.dtd">')
-												incorporating changes from /F

not including pep-0000.txt -> index.html (a symbolic link does just fine)

											
										
										
											2000-07-20 18:44:36 -04:00
-												allow https URI scheme in links

											
										
										
											2004-07-19 15:02:14 -04:00
+								fixpat = re.compile("((https?|ftp):[-_a-zA-Z0-9/.+~:?#$=&,]+)|(pep-\d+(.txt)?)|"
-												fixpat: Recognize current preferred usage for PEP references in body,
e.g. "PEP 1".

fixanchor(): Turn preferred usage for PEP references into PEP url
using the new PEPURL template (which uses the canonical
www.python.org/peps url instead of the sourceforge.net site).
(Also, get rid of base argument in int() calls; base 10 is default.)

fixfile(): If we can't open the input file, print an error message and
continue on.

											
										
										
											2001-07-05 14:44:20 -04:00
+								                    "(RFC[- ]?(?P<rfcnum>\d+))|"
 								                    "(PEP\s+(?P<pepnum>\d+))|"
 								                    ".")
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
-												fixpat: Add , to the list of punctuation allowable in a url.

fixanchor(): Adopt the algorithm for url recognition from faqwiz after
    suggestion by Guido.  Strip any trailing punctuation from the end
    of the url.

    Also, use .startswith() where appropriate.

											
										
										
											2001-08-14 17:42:39 -04:00
+								EMPTYSTRING = ''
 								SPACE = ' '
-												Note!  Python 2.2 is now required (you need the email package).

fixfile(): Modify the Author: and Discussions-To: header handling for
the new required format.  Since this uses Python 2.2's email package,
it should normalize either old style or new style addresses to the new
style for the web page.

											
										
										
											2002-07-30 12:17:11 -04:00
+								COMMASPACE = ', '
-												fixpat: Add , to the list of punctuation allowable in a url.

fixanchor(): Adopt the algorithm for url recognition from faqwiz after
    suggestion by Guido.  Strip any trailing punctuation from the end
    of the url.

    Also, use .startswith() where appropriate.

											
										
										
											2001-08-14 17:42:39 -04:00
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
 								def usage(code, msg=''):
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								    """Print usage message and exit.  Uses stderr if code != 0."""
 								    if code == 0:
 								        out = sys.stdout
 								    else:
 								        out = sys.stderr
 								    print >> out, __doc__ % globals()
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								    if msg:
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								        print >> out, msg
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								    sys.exit(code)
-												Revise the generated HTML to be a little nicer, but still pretty simple.
Also add a -n option to suppress installing the generated HTML at
SourceForge to allow local use.

											
										
										
											2000-07-24 23:51:44 -04:00
+								def fixanchor(current, match):
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								    text = match.group(0)
 								    link = None
-												allow https URI scheme in links, continued

											
										
										
											2004-07-19 15:05:01 -04:00
+								    if (text.startswith('http:') or text.startswith('https:')
 								        or text.startswith('ftp:')):
-												fixpat: Add , to the list of punctuation allowable in a url.

fixanchor(): Adopt the algorithm for url recognition from faqwiz after
    suggestion by Guido.  Strip any trailing punctuation from the end
    of the url.

    Also, use .startswith() where appropriate.

											
										
										
											2001-08-14 17:42:39 -04:00
+								        # Strip off trailing punctuation.  Pattern taken from faqwiz.
 								        ltext = list(text)
 								        while ltext:
 								            c = ltext.pop()
 								            if c not in '();:,.?\'"<>':
 								                ltext.append(c)
 								                break
 								        link = EMPTYSTRING.join(ltext)
 								    elif text.startswith('pep-') and text <> current:
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								        link = os.path.splitext(text)[0] + ".html"
-												fixpat: Add , to the list of punctuation allowable in a url.

fixanchor(): Adopt the algorithm for url recognition from faqwiz after
    suggestion by Guido.  Strip any trailing punctuation from the end
    of the url.

    Also, use .startswith() where appropriate.

											
										
										
											2001-08-14 17:42:39 -04:00
+								    elif text.startswith('PEP'):
-												fixpat: Recognize current preferred usage for PEP references in body,
e.g. "PEP 1".

fixanchor(): Turn preferred usage for PEP references into PEP url
using the new PEPURL template (which uses the canonical
www.python.org/peps url instead of the sourceforge.net site).
(Also, get rid of base argument in int() calls; base 10 is default.)

fixfile(): If we can't open the input file, print an error message and
continue on.

											
										
										
											2001-07-05 14:44:20 -04:00
+								        pepnum = int(match.group('pepnum'))
 								        link = PEPURL % pepnum
-												fixpat: Add , to the list of punctuation allowable in a url.

fixanchor(): Adopt the algorithm for url recognition from faqwiz after
    suggestion by Guido.  Strip any trailing punctuation from the end
    of the url.

    Also, use .startswith() where appropriate.

											
										
										
											2001-08-14 17:42:39 -04:00
+								    elif text.startswith('RFC'):
-												fixpat: Recognize current preferred usage for PEP references in body,
e.g. "PEP 1".

fixanchor(): Turn preferred usage for PEP references into PEP url
using the new PEPURL template (which uses the canonical
www.python.org/peps url instead of the sourceforge.net site).
(Also, get rid of base argument in int() calls; base 10 is default.)

fixfile(): If we can't open the input file, print an error message and
continue on.

											
										
										
											2001-07-05 14:44:20 -04:00
+								        rfcnum = int(match.group('rfcnum'))
-												fixanchor(): Use a module global RFCURL template for RFC urls.  Change
this template to point at the nice faqs.org html-ified RFCs.

											
										
										
											2001-06-05 13:21:19 -04:00
+								        link = RFCURL % rfcnum
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								    if link:
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								        return '<a href="%s">%s</a>' % (cgi.escape(link), cgi.escape(text))
-												incorporating changes from /F

not including pep-0000.txt -> index.html (a symbolic link does just fine)

											
										
										
											2000-07-20 18:44:36 -04:00
+								    return cgi.escape(match.group(0)) # really slow, but it works...
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
-												Change the handling of email addresses to be somewhat more difficult for
spam harvesters to collect, and limit those that are actually turned into
hyperlinks.

											
										
										
											2002-05-28 11:46:24 -04:00
 								NON_MASKED_EMAILS = [
 								    'peps@python.org',
 								    'python-list@python.org',
 								    'python-dev@python.org',
 								    ]
 								def fixemail(address, pepno):
 								    if address.lower() in NON_MASKED_EMAILS:
 								        # return hyperlinked version of email address
 								        return linkemail(address, pepno)
 								    else:
 								        # return masked version of email address
 								        parts = address.split('@', 1)
 								        return '%s&#32;&#97;t&#32;%s' % (parts[0], parts[1])
 								def linkemail(address, pepno):
 								    parts = address.split('@', 1)
 								    return ('<a href="mailto:%s&#64;%s?subject=PEP%%20%s">'
 								            '%s&#32;&#97;t&#32;%s</a>'
 								            % (parts[0], parts[1], pepno, parts[0], parts[1]))
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								def fixfile(inpath, input_lines, outfile):
 								    from email.Utils import parseaddr
 								    basename = os.path.basename(inpath)
 								    infile = iter(input_lines)
-												Added an exception handler for a bad PEP number.  Updated docstrings.

											
										
										
											2002-08-29 23:22:58 -04:00
+								    # convert plaintext pep to minimal XHTML markup
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								    print >> outfile, DTD
 								    print >> outfile, '<html>'
-												Moved comment inside <head> to appease MSIE.

											
										
										
											2002-11-12 00:36:09 -05:00
+								    print >> outfile, COMMENT
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								    print >> outfile, '<head>'
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								    # head
 								    header = []
-												incorporating changes from /F

not including pep-0000.txt -> index.html (a symbolic link does just fine)

											
										
										
											2000-07-20 18:44:36 -04:00
+								    pep = ""
 								    title = ""
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								    for line in infile:
-												Handle RFC822-style continuation lines.  One of these appeared in PEP-0001.

											
										
										
											2000-07-27 15:18:59 -04:00
+								        if not line.strip():
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								            break
-												Handle RFC822-style continuation lines.  One of these appeared in PEP-0001.

											
										
										
											2000-07-27 15:18:59 -04:00
+								        if line[0].strip():
 								            if ":" not in line:
 								                break
 								            key, value = line.split(":", 1)
 								            value = value.strip()
 								            header.append((key, value))
 								        else:
 								            # continuation line
 								            key, value = header[-1]
 								            value = value + line
 								            header[-1] = key, value
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								        if key.lower() == "title":
-												incorporating changes from /F

not including pep-0000.txt -> index.html (a symbolic link does just fine)

											
										
										
											2000-07-20 18:44:36 -04:00
+								            title = value
-												Handle RFC822-style continuation lines.  One of these appeared in PEP-0001.

											
										
										
											2000-07-27 15:18:59 -04:00
+								        elif key.lower() == "pep":
-												incorporating changes from /F

not including pep-0000.txt -> index.html (a symbolic link does just fine)

											
										
										
											2000-07-20 18:44:36 -04:00
+								            pep = value
 								    if pep:
 								        title = "PEP " + pep + " -- " + title
 								    if title:
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        print >> outfile, '  <title>%s</title>' % cgi.escape(title)
-												Move the publication site for PEPs to python.org.

											
										
										
											2002-04-02 18:07:13 -05:00
+								    r = random.choice(range(64))
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								    print >> outfile, (
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								        '  <link rel="STYLESHEET" href="style.css" type="text/css" />\n'
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        '</head>\n'
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								        '<body bgcolor="white">\n'
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        '<table class="navigation" cellpadding="0" cellspacing="0"\n'
 								        '       width="100%%" border="0">\n'
 								        '<tr><td class="navicon" width="150" height="35">\n'
 								        '<a href="../" title="Python Home Page">\n'
 								        '<img src="../pics/PyBanner%03d.gif" alt="[Python]"\n'
 								        ' border="0" width="150" height="35" /></a></td>\n'
 								        '<td class="textlinks" align="left">\n'
 								        '[<b><a href="../">Python Home</a></b>]' % r)
-												fixfile(): Added special casing to handle the new PEP 0 format, which
    eliminates the "filename" field in favor of just the unadorned PEP
    number.

											
										
										
											2001-08-14 12:45:19 -04:00
+								    if basename <> 'pep-0000.txt':
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        print >> outfile, '[<b><a href=".">PEP Index</a></b>]'
-												Fix for the case when no PEP title is given.

											
										
										
											2002-02-16 05:44:32 -05:00
+								    if pep:
-												Added an exception handler for a bad PEP number.  Updated docstrings.

											
										
										
											2002-08-29 23:22:58 -04:00
+								        try:
 								            print >> outfile, ('[<b><a href="pep-%04d.txt">PEP Source</a>'
 								                               '</b>]' % int(pep))
 								        except ValueError, error:
 								            print >> sys.stderr, ('ValueError (invalid PEP number): %s'
-												removed tab

											
										
										
											2002-08-30 00:30:40 -04:00
+								                                  % error)
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								    print >> outfile, '</td></tr></table>'
 								    print >> outfile, '<div class="header">\n<table border="0">'
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
+								    for k, v in header:
-												fixfile(): Do the mailto: hacking on both the Author: and
Discussions-To: headers.  Also, apply SF patch #410223 by Andrew
Kuchling, which does the PEP# href wrapping for Replaces: and
Replaced-By: headers.

											
										
										
											2001-03-21 12:26:05 -05:00
+								        if k.lower() in ('author', 'discussions-to'):
-												Linkify the Author: fields with mailto urls.

											
										
										
											2000-08-17 00:27:04 -04:00
+								            mailtos = []
-												Note!  Python 2.2 is now required (you need the email package).

fixfile(): Modify the Author: and Discussions-To: header handling for
the new required format.  Since this uses Python 2.2's email package,
it should normalize either old style or new style addresses to the new
style for the web page.

											
										
										
											2002-07-30 12:17:11 -04:00
+								            for part in re.split(',\s*', v):
 								                if '@' in part:
 								                    realname, addr = parseaddr(part)
-												Change the handling of email addresses to be somewhat more difficult for
spam harvesters to collect, and limit those that are actually turned into
hyperlinks.

											
										
										
											2002-05-28 11:46:24 -04:00
+								                    if k.lower() == 'discussions-to':
 								                        m = linkemail(addr, pep)
 								                    else:
 								                        m = fixemail(addr, pep)
-												Note!  Python 2.2 is now required (you need the email package).

fixfile(): Modify the Author: and Discussions-To: header handling for
the new required format.  Since this uses Python 2.2's email package,
it should normalize either old style or new style addresses to the new
style for the web page.

											
										
										
											2002-07-30 12:17:11 -04:00
+								                    mailtos.append('%s &lt;%s&gt;' % (realname, m))
 								                elif part.startswith('http:'):
-												fixfile(): Discussions-To: can contain an address or a url.  Adjust
the text accordingly.

											
										
										
											2001-03-21 13:59:03 -05:00
+								                    mailtos.append(
-												Note!  Python 2.2 is now required (you need the email package).

fixfile(): Modify the Author: and Discussions-To: header handling for
the new required format.  Since this uses Python 2.2's email package,
it should normalize either old style or new style addresses to the new
style for the web page.

											
										
										
											2002-07-30 12:17:11 -04:00
+								                        '<a href="%s">%s</a>' % (part, part))
-												Linkify the Author: fields with mailto urls.

											
										
										
											2000-08-17 00:27:04 -04:00
+								                else:
-												Note!  Python 2.2 is now required (you need the email package).

fixfile(): Modify the Author: and Discussions-To: header handling for
the new required format.  Since this uses Python 2.2's email package,
it should normalize either old style or new style addresses to the new
style for the web page.

											
										
										
											2002-07-30 12:17:11 -04:00
+								                    mailtos.append(part)
 								            v = COMMASPACE.join(mailtos)
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        elif k.lower() in ('replaces', 'replaced-by', 'requires'):
-												Added support for Last-Modified header and its (possibly automatic)
generation.

											
										
										
											2002-03-01 14:07:46 -05:00
+								            otherpeps = ''
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								            for otherpep in re.split(',?\s+', v):
-												Added support for Last-Modified header and its (possibly automatic)
generation.

											
										
										
											2002-03-01 14:07:46 -05:00
+								                otherpep = int(otherpep)
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								                otherpeps += '<a href="pep-%04d.html">%i</a> ' % (otherpep,
-												Added support for Last-Modified header and its (possibly automatic)
generation.

											
										
										
											2002-03-01 14:07:46 -05:00
+								                                                                  otherpep)
 								            v = otherpeps
 								        elif k.lower() in ('last-modified',):
 								            date = v or time.strftime('%d-%b-%Y',
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								                                      time.localtime(os.stat(inpath)[8]))
-												Added an exception handler for a bad PEP number.  Updated docstrings.

											
										
										
											2002-08-29 23:22:58 -04:00
+								            try:
 								                url = PEPCVSURL % int(pep)
 								                v = '<a href="%s">%s</a> ' % (url, cgi.escape(date))
 								            except ValueError, error:
 								                v = date
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        elif k.lower() in ('content-type',):
 								            url = PEPURL % 9
 								            pep_type = v or 'text/plain'
 								            v = '<a href="%s">%s</a> ' % (url, cgi.escape(pep_type))
-												Linkify the Author: fields with mailto urls.

											
										
										
											2000-08-17 00:27:04 -04:00
+								        else:
 								            v = cgi.escape(v)
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        print >> outfile, '  <tr><th>%s:&nbsp;</th><td>%s</td></tr>' \
-												Move the publication site for PEPs to python.org.

											
										
										
											2002-04-02 18:07:13 -05:00
+								              % (cgi.escape(k), v)
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								    print >> outfile, '</table>'
 								    print >> outfile, '</div>'
 								    print >> outfile, '<hr />'
 								    print >> outfile, '<div class="content">'
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								    need_pre = 1
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								    for line in infile:
-												fixfile(): Added special casing to handle the new PEP 0 format, which
    eliminates the "filename" field in favor of just the unadorned PEP
    number.

											
										
										
											2001-08-14 12:45:19 -04:00
+								        if line[0] == '\f':
 								            continue
 								        if line.strip() == LOCALVARS:
 								            break
 								        if line[0].strip():
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								            if not need_pre:
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								                print >> outfile, '</pre>'
 								            print >> outfile, '<h3>%s</h3>' % line.strip()
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								            need_pre = 1
 								        elif not line.strip() and need_pre:
 								            continue
-												fixfile(): Added special casing to handle the new PEP 0 format, which
    eliminates the "filename" field in favor of just the unadorned PEP
    number.

											
										
										
											2001-08-14 12:45:19 -04:00
+								        else:
 								            # PEP 0 has some special treatment
 								            if basename == 'pep-0000.txt':
 								                parts = line.split()
 								                if len(parts) > 1 and re.match(r'\s*\d{1,4}', parts[1]):
 								                    # This is a PEP summary line, which we need to hyperlink
 								                    url = PEPURL % int(parts[1])
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								                    if need_pre:
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								                        print >> outfile, '<pre>'
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								                        need_pre = 0
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								                    print >> outfile, re.sub(
-												fixfile(): Added special casing to handle the new PEP 0 format, which
    eliminates the "filename" field in favor of just the unadorned PEP
    number.

											
										
										
											2001-08-14 12:45:19 -04:00
+								                        parts[1],
 								                        '<a href="%s">%s</a>' % (url, parts[1]),
 								                        line, 1),
 								                    continue
 								                elif parts and '@' in parts[-1]:
-												Change the handling of email addresses to be somewhat more difficult for
spam harvesters to collect, and limit those that are actually turned into
hyperlinks.

											
										
										
											2002-05-28 11:46:24 -04:00
+								                    # This is a pep email address line, so filter it.
 								                    url = fixemail(parts[-1], pep)
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								                    if need_pre:
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								                        print >> outfile, '<pre>'
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								                        need_pre = 0
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								                    print >> outfile, re.sub(
-												fixfile(): Added special casing to handle the new PEP 0 format, which
    eliminates the "filename" field in favor of just the unadorned PEP
    number.

											
										
										
											2001-08-14 12:45:19 -04:00
+								                        parts[-1], url, line, 1),
 								                    continue
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								            line = fixpat.sub(lambda x, c=inpath: fixanchor(c, x), line)
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								            if need_pre:
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								                print >> outfile, '<pre>'
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								                need_pre = 0
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								            outfile.write(line)
-												Do not open <pre> sections until we need them; this avoids empty <pre>
elements at the top of the content and removes leading blank lines inside
<pre> sections.

											
										
										
											2002-04-04 10:42:20 -05:00
+								    if not need_pre:
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        print >> outfile, '</pre>'
 								    print >> outfile, '</div>'
 								    print >> outfile, '</body>'
 								    print >> outfile, '</html>'
-												converts pep-*.txt to pep-*.html and loads them up with the help of scp

it would be nice if you could call it after committing changes on a pep

Syntax: python pep2html [sf_username]

											
										
										
											2000-07-20 18:29:24 -04:00
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
-												updated for Docutils API changes

											
										
										
											2002-10-18 01:19:08 -04:00
+								docutils_settings = None
 								"""Runtime settings object used by Docutils.  Can be set by the client
 								application when this module is imported."""
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
 								def fix_rst_pep(inpath, input_lines, outfile):
-												Added "DO NOT EDIT" comment.  Updated from Docutils.

											
										
										
											2002-11-07 22:43:48 -05:00
+								    from docutils import core
-												Updated for new ``publish_string()`` convenience function.

											
										
										
											2002-10-18 21:33:12 -04:00
+								    output = core.publish_string(
 								        source=''.join(input_lines),
 								        source_path=inpath,
 								        destination_path=outfile.name,
 								        reader_name='pep',
 								        parser_name='restructuredtext',
 								        writer_name='pep_html',
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								        settings=docutils_settings,
 								        # Allow Docutils traceback if there's an exception:
 								        settings_overrides={'traceback': 1})
-												Updated for new ``publish_string()`` convenience function.

											
										
										
											2002-10-18 21:33:12 -04:00
+								    outfile.write(output)
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
 								def get_pep_type(input_lines):
 								    """
 								    Return the Content-Type of the input.  "text/plain" is the default.
 								    Return ``None`` if the input is not a PEP.
 								    """
 								    pep_type = None
 								    for line in input_lines:
 								        line = line.rstrip().lower()
 								        if not line:
 								            # End of the RFC 2822 header (first blank line).
 								            break
 								        elif line.startswith('content-type: '):
 								            pep_type = line.split()[1] or 'text/plain'
 								            break
 								        elif line.startswith('pep: '):
 								            # Default PEP type, used if no explicit content-type specified:
 								            pep_type = 'text/plain'
 								    return pep_type
 								def get_input_lines(inpath):
 								    try:
 								        infile = open(inpath)
 								    except IOError, e:
 								        if e.errno <> errno.ENOENT: raise
 								        print >> sys.stderr, 'Error: Skipping missing PEP file:', e.filename
 								        sys.stderr.flush()
 								        return None, None
 								    lines = infile.read().splitlines(1) # handles x-platform line endings
 								    infile.close()
 								    return lines
-												fixfile(): Added special casing to handle the new PEP 0 format, which
    eliminates the "filename" field in favor of just the unadorned PEP
    number.

											
										
										
											2001-08-14 12:45:19 -04:00
-												new usage to support conversion of only specified PEPs

Usage: %(PROGRAM)s [options] [peps]
Notes:
    The optional argument peps can be either pep numbers or .txt files.
Options:
    -u/--user
        SF username
    [rest is the same]

											
										
										
											2000-08-28 12:00:49 -04:00
 								def find_pep(pep_str):
 								    """Find the .txt file indicated by a cmd line argument"""
 								    if os.path.exists(pep_str):
 								        return pep_str
 								    num = int(pep_str)
 								    return "pep-%04d.txt" % num
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								def make_html(inpath, verbose=0):
 								    input_lines = get_input_lines(inpath)
 								    pep_type = get_pep_type(input_lines)
 								    if pep_type is None:
 								        print >> sys.stderr, 'Error: Input file %s is not a PEP.' % inpath
 								        sys.stdout.flush()
 								        return None
 								    elif not PEP_TYPE_DISPATCH.has_key(pep_type):
 								        print >> sys.stderr, ('Error: Unknown PEP type for input file %s: %s'
 								                              % (inpath, pep_type))
 								        sys.stdout.flush()
 								        return None
 								    elif PEP_TYPE_DISPATCH[pep_type] == None:
 								        pep_type_error(inpath, pep_type)
 								        return None
 								    outpath = os.path.splitext(inpath)[0] + ".html"
-												Added a -q/--quiet option to suppress the per-file progress message.
Fixed the branch for files specified from the command line to only update
the Web server if the -u/--update option was used.

											
										
										
											2000-09-06 21:26:46 -04:00
+								    if verbose:
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        print inpath, "(%s)" % pep_type, "->", outpath
 								        sys.stdout.flush()
 								    outfile = open(outpath, "w")
 								    PEP_TYPE_DISPATCH[pep_type](inpath, input_lines, outfile)
 								    outfile.close()
 								    os.chmod(outfile.name, 0664)
 								    return outpath
-												Revise the generated HTML to be a little nicer, but still pretty simple.
Also add a -n option to suppress installing the generated HTML at
SourceForge to allow local use.

											
										
										
											2000-07-24 23:51:44 -04:00
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								def push_pep(htmlfiles, txtfiles, username, verbose, local=0):
 								    quiet = ""
 								    if local:
 								        if verbose:
 								            quiet = "-v"
 								        target = HDIR
 								        copy_cmd = "cp"
 								        chmod_cmd = "chmod"
-												push_html():  New function; handles the mechanics of actually pushing the
              generated HTML to SourceForge.

main():  Adjust to use push_html(), and simplify the logic so it only
         gets called from one place.

											
										
										
											2000-09-08 11:31:36 -04:00
+								    else:
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								        if not verbose:
 								            quiet = "-q"
 								        if username:
 								            username = username + "@"
 								        target = username + HOST + ":" + HDIR
 								        copy_cmd = "scp"
 								        chmod_cmd = "ssh %s%s chmod" % (username, HOST)
-												push_html() -> push_pep()

push_pep(), main(): Arrange for the .txt source file to also be scp
uploaded to SF when the -i/--install flag is given.

											
										
										
											2001-03-20 10:07:21 -05:00
+								    files = htmlfiles[:]
 								    files.extend(txtfiles)
-												push_html():  New function; handles the mechanics of actually pushing the
              generated HTML to SourceForge.

main():  Adjust to use push_html(), and simplify the logic so it only
         gets called from one place.

											
										
										
											2000-09-08 11:31:36 -04:00
+								    files.append("style.css")
-												push_pep(): Be sure the reST pep.css file gets pushed out too.

											
										
										
											2002-08-26 13:02:09 -04:00
+								    files.append("pep.css")
-												push_html() -> push_pep()

push_pep(), main(): Arrange for the .txt source file to also be scp
uploaded to SF when the -i/--install flag is given.

											
										
										
											2001-03-20 10:07:21 -05:00
+								    filelist = SPACE.join(files)
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								    rc = os.system("%s %s %s %s" % (copy_cmd, quiet, filelist, target))
-												push_html():  New function; handles the mechanics of actually pushing the
              generated HTML to SourceForge.

main():  Adjust to use push_html(), and simplify the logic so it only
         gets called from one place.

											
										
										
											2000-09-08 11:31:36 -04:00
+								    if rc:
 								        sys.exit(rc)
-												Disable the 'chmod' commands since these don't work since the move to dinsdale.

											
										
										
											2005-10-14 11:22:30 -04:00
+								##    rc = os.system("%s 664 %s/*" % (chmod_cmd, HDIR))
 								##    if rc:
 								##        sys.exit(rc)
-												push_html():  New function; handles the mechanics of actually pushing the
              generated HTML to SourceForge.

main():  Adjust to use push_html(), and simplify the logic so it only
         gets called from one place.

											
										
										
											2000-09-08 11:31:36 -04:00
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
 								PEP_TYPE_DISPATCH = {'text/plain': fixfile,
 								                     'text/x-rst': fix_rst_pep}
 								PEP_TYPE_MESSAGES = {}
 								def check_requirements():
 								    # Check Python:
 								    try:
 								        from email.Utils import parseaddr
 								    except ImportError:
 								        PEP_TYPE_DISPATCH['text/plain'] = None
 								        PEP_TYPE_MESSAGES['text/plain'] = (
 								            'Python %s or better required for "%%(pep_type)s" PEP '
 								            'processing; %s present (%%(inpath)s).'
 								            % (REQUIRES['python'], sys.version.split()[0]))
 								    # Check Docutils:
 								    try:
 								        import docutils
 								    except ImportError:
 								        PEP_TYPE_DISPATCH['text/x-rst'] = None
 								        PEP_TYPE_MESSAGES['text/x-rst'] = (
 								            'Docutils not present for "%(pep_type)s" PEP file %(inpath)s.  '
 								            'See README.txt for installation.')
 								    else:
-												changes from Docutils project: reformatted docstring/help; send -h/--help output to stdout not stderr; enable exception tracebacks from Docutils; improved version checking

											
										
										
											2004-04-02 14:20:13 -05:00
+								        installed = [int(part) for part in docutils.__version__.split('.')]
 								        required = [int(part) for part in REQUIRES['docutils'].split('.')]
 								        if installed < required:
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								            PEP_TYPE_DISPATCH['text/x-rst'] = None
 								            PEP_TYPE_MESSAGES['text/x-rst'] = (
 								                'Docutils must be reinstalled for "%%(pep_type)s" PEP '
 								                'processing (%%(inpath)s).  Version %s or better required; '
 								                '%s present.  See README.txt for installation.'
 								                % (REQUIRES['docutils'], docutils.__version__))
 								def pep_type_error(inpath, pep_type):
 								    print >> sys.stderr, 'Error: ' + PEP_TYPE_MESSAGES[pep_type] % locals()
 								    sys.stdout.flush()
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
 								def browse_file(pep):
 								    import webbrowser
 								    file = find_pep(pep)
 								    if file.endswith(".txt"):
 								        file = file[:-3] + "html"
 								    file = os.path.abspath(file)
 								    url = "file:" + file
 								    webbrowser.open(url)
 								def browse_remote(pep):
 								    import webbrowser
 								    file = find_pep(pep)
 								    if file.endswith(".txt"):
 								        file = file[:-3] + "html"
 								    url = PEPDIRRUL + file
 								    webbrowser.open(url)
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								def main(argv=None):
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								    # defaults
 								    update = 0
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								    local = 0
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								    username = ''
-												Added a -q/--quiet option to suppress the per-file progress message.
Fixed the branch for files specified from the command line to only update
the Web server if the -u/--update option was used.

											
										
										
											2000-09-06 21:26:46 -04:00
+								    verbose = 1
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
+								    browse = 0
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								    check_requirements()
 								    if argv is None:
 								        argv = sys.argv[1:]
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								    try:
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
+								        opts, args = getopt.getopt(
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								            argv, 'bilhqu:',
 								            ['browse', 'install', 'local', 'help', 'quiet', 'user='])
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
+								    except getopt.error, msg:
 								        usage(1, msg)
 								    for opt, arg in opts:
 								        if opt in ('-h', '--help'):
 								            usage(0)
 								        elif opt in ('-i', '--install'):
 								            update = 1
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								        elif opt in ('-l', '--local'):
 								            update = 1
 								            local = 1
-												new usage to support conversion of only specified PEPs

Usage: %(PROGRAM)s [options] [peps]
Notes:
    The optional argument peps can be either pep numbers or .txt files.
Options:
    -u/--user
        SF username
    [rest is the same]

											
										
										
											2000-08-28 12:00:49 -04:00
+								        elif opt in ('-u', '--user'):
-												push_html():  New function; handles the mechanics of actually pushing the
              generated HTML to SourceForge.

main():  Adjust to use push_html(), and simplify the logic so it only
         gets called from one place.

											
										
										
											2000-09-08 11:31:36 -04:00
+								            username = arg
-												Added a -q/--quiet option to suppress the per-file progress message.
Fixed the branch for files specified from the command line to only update
the Web server if the -u/--update option was used.

											
										
										
											2000-09-06 21:26:46 -04:00
+								        elif opt in ('-q', '--quiet'):
 								            verbose = 0
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
+								        elif opt in ('-b', '--browse'):
 								            browse = 1
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
-												new usage to support conversion of only specified PEPs

Usage: %(PROGRAM)s [options] [peps]
Notes:
    The optional argument peps can be either pep numbers or .txt files.
Options:
    -u/--user
        SF username
    [rest is the same]

											
										
										
											2000-08-28 12:00:49 -04:00
+								    if args:
-												push_html() -> push_pep()

push_pep(), main(): Arrange for the .txt source file to also be scp
uploaded to SF when the -i/--install flag is given.

											
										
										
											2001-03-20 10:07:21 -05:00
+								        peptxt = []
-												new usage to support conversion of only specified PEPs

Usage: %(PROGRAM)s [options] [peps]
Notes:
    The optional argument peps can be either pep numbers or .txt files.
Options:
    -u/--user
        SF username
    [rest is the same]

											
										
										
											2000-08-28 12:00:49 -04:00
+								        html = []
 								        for pep in args:
 								            file = find_pep(pep)
-												push_html() -> push_pep()

push_pep(), main(): Arrange for the .txt source file to also be scp
uploaded to SF when the -i/--install flag is given.

											
										
										
											2001-03-20 10:07:21 -05:00
+								            peptxt.append(file)
-												Added a -q/--quiet option to suppress the per-file progress message.
Fixed the branch for files specified from the command line to only update
the Web server if the -u/--update option was used.

											
										
										
											2000-09-06 21:26:46 -04:00
+								            newfile = make_html(file, verbose=verbose)
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								            if newfile:
 								                html.append(newfile)
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
+								            if browse and not update:
 								                browse_file(pep)
-												new usage to support conversion of only specified PEPs

Usage: %(PROGRAM)s [options] [peps]
Notes:
    The optional argument peps can be either pep numbers or .txt files.
Options:
    -u/--user
        SF username
    [rest is the same]

											
										
										
											2000-08-28 12:00:49 -04:00
+								    else:
 								        # do them all
-												push_html() -> push_pep()

push_pep(), main(): Arrange for the .txt source file to also be scp
uploaded to SF when the -i/--install flag is given.

											
										
										
											2001-03-20 10:07:21 -05:00
+								        peptxt = []
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								        html = []
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
+								        files = glob.glob("pep-*.txt")
 								        files.sort()
 								        for file in files:
-												push_html() -> push_pep()

push_pep(), main(): Arrange for the .txt source file to also be scp
uploaded to SF when the -i/--install flag is given.

											
										
										
											2001-03-20 10:07:21 -05:00
+								            peptxt.append(file)
-												David Goodger writes:

* Refactored the file I/O model throughout, to support multiple
  processing paths.  PEP source text is now read into a list of lines.

* In ``fixfile()``:

  - Updated its parameters for the new I/O model.
  - Changed ``fo`` to ``outfile``, ``fi`` to ``inpath`` and
    ``input_lines``.
  - Input is read in by iterating over the list of input lines, rather
    than using "readlines()".
  - Opening and closing of files is done by the caller, "make_html()".
  - Added PEP number processing in Requires header.
  - Linked "Content-Type: text/plain" to PEP 9.

* Added ``fix_rst_pep()``, which imports and calls Docutils code.

* Added ``get_pep_type()``, which checks for a Content-Type header and
  returns the value, defaulting to "text/plain".  If no PEP header is
  found, ``None`` is returned: input is not a PEP.

* Added ``get_input_lines()`` to read input file into a list.

* Expanded ``make_html()`` to catch errors and process the different
  PEP formats via the new ``PEP_TYPE_DISPATCH`` dict.

* Added ``check_requirements()`` to check both Python and Docutils
  requirements.  ``pep_type_error()`` is called if the required
  software is not available.

* In ``main()``:

  - Added an ``argv`` parameter, so that pep2html.py can be imported
    and command-line options passed in.  Yes, I use this functionality
    in the Docutils "buildhtml.py" front end.
  - Files skipped (due to an error) are not pushed onto the server.

											
										
										
											2002-08-26 12:54:54 -04:00
+								            newfile = make_html(file, verbose=verbose)
 								            if newfile:
 								                html.append(newfile)
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
+								        if browse and not update:
 								            browse_file("0")
-												Revise the generated HTML to be a little nicer, but still pretty simple.
Also add a -n option to suppress installing the generated HTML at
SourceForge to allow local use.

											
										
										
											2000-07-24 23:51:44 -04:00
+								    if update:
-												Added --local/-l option to make my life easier on creosote.  Removed bogus <body> attributes.

											
										
										
											2002-11-11 19:56:27 -05:00
+								        push_pep(html, peptxt, username, verbose, local=local)
-												Add -b/--browse option, which uses the webbrowser module to show the
generated HTML in your browser.  (The local HTML without -i, the
remote HTML with -i; PEP 0 when no pep argument is given.)

Fix the help text for -i (referenced sf_username which wasn't
defined).

Sort the files when processing all of them (glob doesn't sort, alas).

											
										
										
											2002-03-15 13:14:39 -05:00
+								        if browse:
 								            if args:
 								                for pep in args:
 								                    browse_remote(pep)
 								            else:
 								                browse_remote("0")
-												Revise the generated HTML to be a little nicer, but still pretty simple.
Also add a -n option to suppress installing the generated HTML at
SourceForge to allow local use.

											
										
										
											2000-07-24 23:51:44 -04:00
-												fixfile(): Added special casing to handle the new PEP 0 format, which
    eliminates the "filename" field in favor of just the unadorned PEP
    number.

											
										
										
											2001-08-14 12:45:19 -04:00
-												Changed the sense of the default behavior.  No longer installs the
.html files in SF by default; you must explicitly include the
-i/--install option in order to upload.

Also, added -h/--help and migrated to getopt for switch parsing.
Included a usage() function.

Some cosmetic changes.

											
										
										
											2000-08-15 01:53:19 -04:00
-												Revise the generated HTML to be a little nicer, but still pretty simple.
Also add a -n option to suppress installing the generated HTML at
SourceForge to allow local use.

											
										
										
											2000-07-24 23:51:44 -04:00
+								if __name__ == "__main__":
 								    main()