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, .rst or .txt files.
"""

from __future__ import print_function, unicode_literals

import sys
import os
import re
import glob
import getopt
import errno
import random
import time
from io import open
try:
    from html import escape
except ImportError:
    from cgi import escape

REQUIRES = {'python': '2.6',
            'docutils': '0.2.7'}
PROGRAM = sys.argv[0]
RFCURL = 'http://www.faqs.org/rfcs/rfc%d.html'
PEPURL = 'pep-%04d.html'
PEPCVSURL = ('https://hg.python.org/peps/file/tip/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|.rst)?)|"
                    "(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(__doc__ % globals(), file=out)
    if msg:
        print(msg, file=out)
    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>' % (escape(link), escape(text))
    return 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):
    try:
        from email.Utils import parseaddr
    except ImportError:
        from email.utils import parseaddr
    basename = os.path.basename(inpath)
    infile = iter(input_lines)
    # convert plaintext pep to minimal XHTML markup
    print(DTD, file=outfile)
    print('<html>', file=outfile)
    print(COMMENT, file=outfile)
    print('<head>', file=outfile)
    # 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('  <title>%s</title>' % escape(title), file=outfile)
    r = random.choice(list(range(64)))
    print((
        '  <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), file=outfile)
    if basename != 'pep-0000.txt':
        print('[<b><a href=".">PEP Index</a></b>]', file=outfile)
    if pep:
        try:
            print(('[<b><a href="pep-%04d.txt">PEP Source</a>'
                               '</b>]' % int(pep)), file=outfile)
        except ValueError as error:
            print(('ValueError (invalid PEP number): %s'
                                  % error), file=sys.stderr)
    print('</td></tr></table>', file=outfile)
    print('<div class="header">\n<table border="0">', file=outfile)
    for k, v in header:
        if k.lower() in ('author', 'bdfl-delegate', '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]))
            if date.startswith('$' 'Date: ') and date.endswith(' $'):
                date = date[6:-2]
            if basename == 'pep-0000.txt':
                v = date
            else:
                try:
                    url = PEPCVSURL % int(pep)
                    v = '<a href="%s">%s</a> ' % (url, escape(date))
                except ValueError as 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, escape(pep_type))
        elif k.lower() == 'version':
            if v.startswith('$' 'Revision: ') and v.endswith(' $'):
                v = escape(v[11:-2])
        else:
            v = escape(v)
        print('  <tr><th>%s:&nbsp;</th><td>%s</td></tr>' \
              % (escape(k), v), file=outfile)
    print('</table>', file=outfile)
    print('</div>', file=outfile)
    print('<hr />', file=outfile)
    print('<div class="content">', file=outfile)
    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('</pre>', file=outfile)
            print('<h3>%s</h3>' % line.strip(), file=outfile)
            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('<pre>', file=outfile)
                        need_pre = 0
                    print(re.sub(
                        parts[1],
                        '<a href="%s">%s</a>' % (url, parts[1]),
                        line, 1), end=' ', file=outfile)
                    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('<pre>', file=outfile)
                        need_pre = 0
                    print(re.sub(
                        parts[-1], url, line, 1), end=' ', file=outfile)
                    continue
            line = fixpat.sub(lambda x, c=inpath: fixanchor(c, x), line)
            if need_pre:
                print('<pre>', file=outfile)
                need_pre = 0
            outfile.write(line)
    if not need_pre:
        print('</pre>', file=outfile)
    print('</div>', file=outfile)
    print('</body>', file=outfile)
    print('</html>', file=outfile)


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
    from docutils.transforms.peps import Headers
    Headers.pep_cvs_url = PEPCVSURL
    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.decode('utf-8'))


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, encoding='utf-8')
    except IOError as e:
        if e.errno != errno.ENOENT: raise
        print('Error: Skipping missing PEP file:', e.filename, file=sys.stderr)
        sys.stderr.flush()
        return None
    lines = infile.read().splitlines(1) # handles x-platform line endings
    infile.close()
    return lines


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

def make_html(inpath, verbose=0):
    input_lines = get_input_lines(inpath)
    if input_lines is None:
        return None
    pep_type = get_pep_type(input_lines)
    if pep_type is None:
        print('Error: Input file %s is not a PEP.' % inpath, file=sys.stderr)
        sys.stdout.flush()
        return None
    elif pep_type not in PEP_TYPE_DISPATCH:
        print(('Error: Unknown PEP type for input file %s: %s'
                              % (inpath, pep_type)), file=sys.stderr)
        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", encoding='utf-8')
    PEP_TYPE_DISPATCH[pep_type](inpath, input_lines, outfile)
    outfile.close()
    os.chmod(outfile.name, 0o664)
    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:
    # This is pretty much covered by the __future__ imports...
    if sys.version_info < (2, 6, 0):
        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.rst 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.rst for installation.'
                % (REQUIRES['docutils'], docutils.__version__))

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


def browse_file(pep):
    import webbrowser
    file = find_pep(pep)
    if file.startswith('pep-') and file.endswith((".txt", '.rst')):
        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.startswith('pep-') and file.endswith((".txt", '.rst')):
        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 as 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:
        pep_list = []
        html = []
        for pep in args:
            file = find_pep(pep)
            pep_list.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
        pep_list = []
        html = []
        files = glob.glob("pep-*.txt") + glob.glob("pep-*.rst")
        files.sort()
        for file in files:
            pep_list.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, pep_list, 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
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								The optional arguments ``peps`` are either pep numbers, .rst 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
+								"""
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								from __future__ import print_function, unicode_literals
-												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 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
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								from io import open
-												cgi.escape is deprecated, use html.escape instead.

											
										
										
											2016-05-03 03:51:13 -04:00
+								try:
 								    from html import escape
 								except ImportError:
 								    from cgi import escape
-												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
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								REQUIRES = {'python': '2.6',
-												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'
-												give https link

											
										
										
											2014-10-07 16:04:45 -04:00
+								PEPCVSURL = ('https://hg.python.org/peps/file/tip/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
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								fixpat = re.compile("((https?|ftp):[-_a-zA-Z0-9/.+~:?#$=&,]+)|(pep-\d+(.txt|.rst)?)|"
-												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
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    print(__doc__ % globals(), file=out)
-												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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								        print(msg, file=out)
-												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)
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    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:
-												cgi.escape is deprecated, use html.escape instead.

											
										
										
											2016-05-03 03:51:13 -04:00
+								        return '<a href="%s">%s</a>' % (escape(link), escape(text))
 								    return 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):
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    try:
 								        from email.Utils import parseaddr
 								    except ImportError:
 								        from email.utils import parseaddr
-												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
+								    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
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    print(DTD, file=outfile)
 								    print('<html>', file=outfile)
 								    print(COMMENT, file=outfile)
 								    print('<head>', file=outfile)
-												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:
-												cgi.escape is deprecated, use html.escape instead.

											
										
										
											2016-05-03 03:51:13 -04:00
+								        print('  <title>%s</title>' % escape(title), file=outfile)
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    r = random.choice(list(range(64)))
 								    print((
-												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'
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								        '[<b><a href="../">Python Home</a></b>]' % r), file=outfile)
 								    if basename != 'pep-0000.txt':
 								        print('[<b><a href=".">PEP Index</a></b>]', file=outfile)
-												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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								            print(('[<b><a href="pep-%04d.txt">PEP Source</a>'
 								                               '</b>]' % int(pep)), file=outfile)
 								        except ValueError as error:
 								            print(('ValueError (invalid PEP number): %s'
 								                                  % error), file=sys.stderr)
 								    print('</td></tr></table>', file=outfile)
 								    print('<div class="header">\n<table border="0">', file=outfile)
-												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:
-												obscure the email address in bdfl-delegate, too

											
										
										
											2013-06-05 15:03:27 -04:00
+								        if k.lower() in ('author', 'bdfl-delegate', '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]))
-												cleanup date field after keyword expansion

											
										
										
											2014-10-07 12:11:48 -04:00
+								            if date.startswith('$' 'Date: ') and date.endswith(' $'):
 								                date = date[6:-2]
-												Issue #19110: Surpress Last-Modified link in PEP 0 html

											
										
										
											2013-09-28 15:10:28 -04:00
+								            if basename == 'pep-0000.txt':
-												Added an exception handler for a bad PEP number.  Updated docstrings.

											
										
										
											2002-08-29 23:22:58 -04:00
+								                v = date
-												Issue #19110: Surpress Last-Modified link in PEP 0 html

											
										
										
											2013-09-28 15:10:28 -04:00
+								            else:
 								                try:
 								                    url = PEPCVSURL % int(pep)
-												cgi.escape is deprecated, use html.escape instead.

											
										
										
											2016-05-03 03:51:13 -04:00
+								                    v = '<a href="%s">%s</a> ' % (url, escape(date))
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								                except ValueError as error:
-												Issue #19110: Surpress Last-Modified link in PEP 0 html

											
										
										
											2013-09-28 15:10:28 -04:00
+								                    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'
-												cgi.escape is deprecated, use html.escape instead.

											
										
										
											2016-05-03 03:51:13 -04:00
+								            v = '<a href="%s">%s</a> ' % (url, escape(pep_type))
-												cleanup version header, too

											
										
										
											2014-10-07 12:12:47 -04:00
+								        elif k.lower() == 'version':
 								            if v.startswith('$' 'Revision: ') and v.endswith(' $'):
-												cgi.escape is deprecated, use html.escape instead.

											
										
										
											2016-05-03 03:51:13 -04:00
+								                v = escape(v[11:-2])
-												Linkify the Author: fields with mailto urls.

											
										
										
											2000-08-17 00:27:04 -04:00
+								        else:
-												cgi.escape is deprecated, use html.escape instead.

											
										
										
											2016-05-03 03:51:13 -04:00
+								            v = escape(v)
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								        print('  <tr><th>%s:&nbsp;</th><td>%s</td></tr>' \
-												cgi.escape is deprecated, use html.escape instead.

											
										
										
											2016-05-03 03:51:13 -04:00
+								              % (escape(k), v), file=outfile)
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    print('</table>', file=outfile)
 								    print('</div>', file=outfile)
 								    print('<hr />', file=outfile)
 								    print('<div class="content">', file=outfile)
-												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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								                print('</pre>', file=outfile)
 								            print('<h3>%s</h3>' % line.strip(), file=outfile)
-												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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								                        print('<pre>', file=outfile)
-												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
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								                    print(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]),
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								                        line, 1), end=' ', file=outfile)
-												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
+								                    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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								                        print('<pre>', file=outfile)
-												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
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								                    print(re.sub(
 								                        parts[-1], url, line, 1), end=' ', file=outfile)
-												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
+								                    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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								                print('<pre>', file=outfile)
-												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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								        print('</pre>', file=outfile)
 								    print('</div>', file=outfile)
 								    print('</body>', file=outfile)
 								    print('</html>', file=outfile)
-												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
-												add missing import

											
										
										
											2014-10-07 19:26:44 -04:00
+								    from docutils.transforms.peps import Headers
-												get docutils not to use the svn url

											
										
										
											2014-10-07 16:18:39 -04:00
+								    Headers.pep_cvs_url = PEPCVSURL
-												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})
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    outfile.write(output.decode('utf-8'))
-												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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								        infile = open(inpath, encoding='utf-8')
 								    except IOError as e:
 								        if e.errno != errno.ENOENT: raise
 								        print('Error: Skipping missing PEP file:', e.filename, file=sys.stderr)
-												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
+								        sys.stderr.flush()
-												Fix some bugs when dealing with non-existent or non-PEP files.

											
										
										
											2007-05-10 18:55:31 -04:00
+								        return None
-												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
+								    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):
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								    """Find the .rst or .txt file indicated by a cmd line argument"""
-												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 os.path.exists(pep_str):
 								        return pep_str
 								    num = int(pep_str)
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								    rstpath = "pep-%04d.rst" % num
 								    if os.path.exists(rstpath):
 								        return rstpath
-												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
+								    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)
-												Fix some bugs when dealing with non-existent or non-PEP files.

											
										
										
											2007-05-10 18:55:31 -04:00
+								    if input_lines is None:
 								        return None
-												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 = get_pep_type(input_lines)
 								    if pep_type is None:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								        print('Error: Input file %s is not a PEP.' % inpath, file=sys.stderr)
-												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
+								        sys.stdout.flush()
 								        return None
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    elif pep_type not in PEP_TYPE_DISPATCH:
 								        print(('Error: Unknown PEP type for input file %s: %s'
 								                              % (inpath, pep_type)), file=sys.stderr)
-												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
+								        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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								        print(inpath, "(%s)" % pep_type, "->", outpath)
-												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
+								        sys.stdout.flush()
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    outfile = open(outpath, "w", encoding='utf-8')
-												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[pep_type](inpath, input_lines, outfile)
 								    outfile.close()
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    os.chmod(outfile.name, 0o664)
-												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
+								    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:
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    # This is pretty much covered by the __future__ imports...
 								    if sys.version_info < (2, 6, 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
+								        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.  '
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								            'See README.rst for installation.')
-												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
+								    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; '
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								                '%s present.  See README.rst for installation.'
-												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['docutils'], docutils.__version__))
 								def pep_type_error(inpath, pep_type):
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    print('Error: ' + PEP_TYPE_MESSAGES[pep_type] % locals(), file=sys.stderr)
-												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
+								    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)
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								    if file.startswith('pep-') and file.endswith((".txt", '.rst')):
-												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
+								        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)
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								    if file.startswith('pep-') and file.endswith((".txt", '.rst')):
-												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
+								        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='])
-												Port pep2html.py to 2/3.

This is a fairly naive port, just ran 2to3 over it and then tweaked
enough to make both versions happy.

											
										
										
											2015-04-12 23:27:02 -04:00
+								    except getopt.error as 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
+								        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:
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								        pep_list = []
-												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)
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								            pep_list.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)
-												Fix some bugs when dealing with non-existent or non-PEP files.

											
										
										
											2007-05-10 18:55:31 -04: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
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								        pep_list = []
-												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 = []
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								        files = glob.glob("pep-*.txt") + glob.glob("pep-*.rst")
-												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.sort()
 								        for file in files:
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								            pep_list.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:
-												Handle pep files with `.rst` extensions.

											
										
										
											2016-06-23 18:57:01 -04:00
+								        push_pep(html, pep_list, 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()