Changes in [3932:515c28c99841:3933:84a390ea9119] in livinglogic.python.xist

Show
Ignore:
Files:
1 added
76 modified

Legend:

Unmodified
Added
Removed
  • .hgtags

    r3932 r3933  
    99993aa5a5d89287166b52a746e030431a2a068fbc7c rel-3-6-5 
    100100697e888115bc65f7bbed0c35b1b33f70cf427e31 rel-3-6-6 
     101d09b5431bb12b8ed00703614a18928d7b98731b4 rel-3-7-1 
     1026becbe6f4b5ccac5963b88323932c9129bc7bcf5 rel-3-7-2 
    1011038550cdcc3cecb20f5fb9944577e2c535578d6423 rel-3-7-3 
  • INSTALL.rst

    r3844 r3898  
    44To use XIST you need the following software packages: 
    55 
    6     1.  `Python 2.6`_; 
     6    *   `Python 2.6`_; 
    77 
    8     2.  `Python Imaging Library`_; 
     8    *   `cssutils`_; 
    99 
    10     3.  `libxml2`_ and its Python wrapper (if you want to parse "broken" HTML); 
     10    *   `Python Imaging Library`_ (if you want to use automatic image size 
     11        calculation); 
    1112 
    12     4.  `elinks`_ (if you want want to use the function 
     13    *   `libxml2`_ and its Python wrapper (if you want to parse "broken" HTML); 
     14 
     15    *   `elinks`_ (if you want want to use the function 
    1316        :func:`ll.xist.ns.html.astext`); 
    1417 
    15     5.  `cx_Oracle`_ (if you want to use :mod:`ll.orasql`); 
     18    *   `cx_Oracle`_ (if you want to use :mod:`ll.orasql`); 
    1619 
    17     6.  `setuptools`_ (if you want to install this package as an egg); 
     20    *   `setuptools`_ (if you want to install this package as an egg); 
    1821 
    19     7.  `py.test`_ (if you want to run the test suite) 
     22    *   `py.test`_ (if you want to run the test suite) 
    2023 
    21     8.  and a C compiler supported by distutils, if you want to install the 
     24    *   `execnet`_ (if you want to use ssh URLs) 
     25 
     26    *   and a C compiler supported by distutils, if you want to install the 
    2227        source distribution. 
    2328 
    2429    .. _Python 2.6: http://www.python.org/ 
     30    .. _cssutils: http://cthedot.de/cssutils/ 
    2531    .. _Python Imaging Library: http://www.pythonware.com/products/pil/ 
    2632    .. _libxml2: http://www.xmlsoft.org/ 
     
    2935    .. _setuptools: http://peak.telecommunity.com/DevCenter/setuptools 
    3036    .. _py.test: http://codespeak.net/py/current/doc/test.html 
     37    .. _execnet: http://codespeak.net/execnet/ 
    3138 
    3239 
  • MIGRATION.rst

    r3846 r3898  
     1Migrating to version 3.8 
     2======================== 
     3 
     4Changes to XISTs walk filters 
     5----------------------------- 
     6 
     7*   The walk methods :meth:`walknode` and :meth:`walkpath` have been renamed to 
     8    :meth:`walknodes` and :meth:`walkpaths`. The class :class:`WalkFilter` has 
     9    been moved to :mod:`ll.xist.xfind`. 
     10 
     11Changes to :mod:`ll.url` 
     12------------------------ 
     13 
     14*   :class:`ll.url.Path` has been simplified: Path segments are strings instead 
     15    of tuples. If you need the path parameters (i.e. part after ``;`` in a path 
     16    segment you have to split the segment yourself. 
     17 
     18*   :meth:`ll.url.URL.import_` is gone. As a replacement :func:`misc.module` can 
     19    be used, i.e. replace:: 
     20 
     21        >>> from ll import url 
     22        >>> u = url.File("foo.py") 
     23        >>> m = u.import_(mode="always") 
     24 
     25    with:: 
     26 
     27        >>> from ll import url, misc 
     28        >>> u = url.File("foo.py") 
     29        >>> m = misc.module(u.openread().read(), u.local()) 
     30 
     31*   ssh URLs now required to standalone :mod:`execnet` package__. The 
     32    ``ssh_config`` parameter for ssh URLs is gone. 
     33 
     34    __ http://codespeak.net/execnet/ 
     35 
     36 
    137Migrating to version 3.7 
    238======================== 
     
    541-------------------------- 
    642 
    7 *   The division operator is no longer implemented, so instead of:: 
    8  
    9         t1 = make.FileAction(key=url.URL("foo.txt")) 
     43*   The division operator for actions is no longer implemented, so instead of:: 
     44 
     45        t1 = make.FileAction(key=url.URL("file:foo.txt")) 
    1046        t2 = t1 / 
    1147             make.DecodeAction("iso-8859-1") / 
  • NEWS.rst

    r3931 r3933  
     1Changes in 3.8 (released ??/??/????) 
     2------------------------------------ 
     3 
     4*   The walk methods :meth:`walknode` and :meth:`walkpath` have been renamed to 
     5    :meth:`walknodes` and :meth:`walkpaths` and the implemention has been moved 
     6    from the nodes classes into :class:`WalkFilter`. :class:`WalkFilter` has been 
     7    moved to :mod:`ll.xist.xfind`. 
     8 
     9*   Added a new function :func:`misc.module` that creates a module from source 
     10    code. 
     11 
     12*   :class:`ll.url.Path` has been simplified: Path segments are strings instead 
     13    of tuples now. 
     14 
     15*   The old :class:`URL` method :meth:`import_` has been removed. The new 
     16    function :func:`misc.module` can now be used for that. 
     17 
     18*   :class:`ll.orasql.PrimaryKey` has a new method :meth:`itercolumns` that 
     19    returns an iterator over the columns this primary key consists of. 
     20 
     21*   Two new UL4 functions ``abs`` and ``utcnow`` have been added. 
     22 
     23*   A new UL4 method ``mimeformat`` has been added to date objects. 
     24 
     25*   Use autoboxing in the Java code generated by :mod:`ll.xist.ns.jsp.fromul4`. 
     26 
     27*   The code has switched to using the :meth:`format` method instead of using 
     28    the ``%`` operator everywhere. 
     29 
     30*   ssh URLs in :mod:`ll.url` now use the standalone :mod:`execnet` package__. 
     31 
     32    __ http://codespeak.net/execnet/ 
     33 
     34*   ssh URLs now support a ``nice`` argument instead of ``ssh_config``. 
     35 
     36 
    137Changes in 3.7.3 (released 02/27/2010) 
    238-------------------------------------- 
  • demos/cherrypy-images/images.py

    r3795 r3893  
    2525    @cherrypy.expose 
    2626    def images(self, filename): 
    27         return cptools.serveFile("%s/%s" % (self.directory, filename)) 
     27        return cptools.serveFile("{0}/{1}".format(self.directory, filename)) 
    2828 
    2929    @cherrypy.expose 
  • demos/python-quotes/python-quotes.py

    r3077 r3866  
    1414    pool = xsc.Pool(html, xml, qel_xmlns, rdf_xmlns, rdfs_xmlns, cc_xmlns, dc_xmlns) 
    1515    base = "root:python-quotes.html" 
    16     e = parsers.parseurl(url, base=base, parser=parsers.ExpatParser(), pool=pool, validate=False) 
     16    e = parsers.parseurl(url, base=base, parser=parsers.Expat, pool=pool, validate=False) 
    1717    e = e[qel_xmlns.quotations][0] 
    1818    e = e.compact().conv() 
  • docs/UL4.rst

    r3851 r3918  
    472472 
    473473 
     474``utcnow`` 
     475:::::::::: 
     476 
     477``utcnow()`` returns the current date and time as a date object in UTC. 
     478 
     479 
    474480``vars`` 
    475481:::::::: 
     
    851857    <?code data = {'a': 17, 'b': 23)?> 
    852858    <?code output = template.render(**data)?> 
     859 
     860 
     861``isoformat`` 
     862::::::::::::: 
     863 
     864``isoformat`` is a date method. It returns the date object in ISO 8601 format, 
     865i.e.:: 
     866 
     867    <?print now().isoformat()?> 
     868 
     869might output:: 
     870 
     871    2010-02-22T18:30:29.569639 
     872 
     873 
     874``mimeformat`` 
     875:::::::::::::: 
     876 
     877``mimeformat`` is a date method. It returns the date object in MIME format 
     878(assuming the date object is in UTC), i.e.:: 
     879 
     880    <?print utcnow().mimeformat()?> 
     881 
     882might output:: 
     883 
     884    Mon, 22 Feb 2010 17:38:40 GMT 
  • docs/XIST_Advanced.xml

    r3829 r3893  
    153153            node = converter.target.inline(self.content, font_weight="bold") 
    154154        else: 
    155             raise TypeError("unsupported conversion target %r" % converter.target) 
     155            raise TypeError("unsupported conversion target {0!r}".format(converter.target)) 
    156156        return node.convert(converter) 
    157157</prog> 
  • docs/XIST_Examples.xml

    r3795 r3893  
    127127<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist.ns import html</input> 
    128128<prompt>&gt;&gt;&gt; </prompt><input>node = parsers.parseurl("http://www.python.org/", utidy=True)</input> 
    129 <prompt>&gt;&gt;&gt; </prompt><input>for img in node.walknode(html.a/html.img):</input> 
     129<prompt>&gt;&gt;&gt; </prompt><input>for img in node.walknodes(html.a/html.img):</input> 
    130130<prompt>... </prompt><input>   print img.atts.src</input> 
    131131<prompt>... </prompt><input></input> 
     
    143143<prompt>&gt;&gt;&gt; </prompt><input>from ll.xist.ns import html</input> 
    144144<prompt>&gt;&gt;&gt; </prompt><input>node = parsers.parseurl("http://www.python.org/", tidy=True)</input> 
    145 <prompt>&gt;&gt;&gt; </prompt><input>for path in node.walkpath(html.a/html.img):</input> 
     145<prompt>&gt;&gt;&gt; </prompt><input>for path in node.walkpaths(html.a/html.img):</input> 
    146146<prompt>... </prompt><input>   print path[-2].attrs.href, path[-1].attrs.src</input> 
    147147http://www.python.org/ http://www.python.org/images/python-logo.gif 
     
    261261    def convert(self, converter): 
    262262        context = converter[self] 
    263         elementname = "h%d" % min(context.level, 6) 
     263        elementname = "h{0}".format(min(context.level, 6)) 
    264264        node = xsc.Frag( 
    265265            getattr(converter.target, elementname)(self.attrs.title), 
  • docs/XIST_Searching.xml

    r3622 r3862  
    44<p>There are three related methods available for iterating through an &xml; 
    55tree and finding nodes in the tree: The methods <meth>walk</meth>, 
    6 <meth>walknode</meth> and <meth>walkpath</meth>.</p> 
     6<meth>walknodes</meth> and <meth>walkpaths</meth>.</p> 
    77 
    88<p>The method <pyref module="ll.xist.xsc" class="Node" method="walk"><meth>walk</meth></pyref> 
     
    1212the <meth>walk</meth> method are lists with the path from the root of the 
    1313tree to the node in question (Actually it's always the some list objects, if you 
    14 want distinct objects, use the <meth>walkpath</meth> method). The method 
    15 <meth>walknode</meth> produces the nodes instead of the paths to the 
     14want distinct objects, use the <meth>walkpaths</meth> method). The method 
     15<meth>walknodes</meth> produces the nodes instead of the paths to the 
    1616node.</p> 
    1717 
     
    4848<example><h>Using the <meth>walk</meth> method</h> 
    4949<prog> 
    50 from ll.xist import xsc, parsers 
    51 from ll.xist.ns import html 
    52  
    53 class IsTable(xsc.WalkFilter): 
     50from ll.xist import parsers, xfind 
     51from ll.xist.ns import html 
     52 
     53class IsTable(xfind.WalkFilter): 
    5454    def filternode(self, node): 
    5555        if isinstance(node, html.table): 
    56             return (True, xsc.entercontent) 
     56            return (True, xfind.entercontent) 
    5757        else: 
    58             return (xsc.entercontent,) 
    59  
    60 doc = parsers.parseurl("http://www.python.org/", tidy=True) 
    61  
    62 for node in doc.walknode(IsTable()): 
     58            return (xfind.entercontent,) 
     59 
     60doc = parsers.parseurl("http://www.python.org/", tidy=True) 
     61 
     62for node in doc.walknodes(IsTable()): 
    6363    <rep>...</rep> 
    6464</prog> 
     
    7676<example><h>Searching for <class>li</class> inside <class>ul</class> with <meth>walk</meth></h> 
    7777<prog> 
    78 for li in node.content.walknode(xsc.FindType(html.li)): 
     78for li in node.content.walknodes(xfind.FindType(html.li)): 
    7979    <rep>...</rep> 
    8080</prog> 
     
    9393doc = parsers.parseurl("http://www.python.org/", tidy=True) 
    9494 
    95 for node in doc.walknode(xsc.FindTypeAll(html.a)): 
     95for node in doc.walknodes(xfind.FindTypeAll(html.a)): 
    9696    print node.attrs.href 
    9797</prog> 
     
    115115<example><h>Finding external links on the Python home page</h> 
    116116<prog> 
    117 from ll.xist import xsc, parsers 
    118 from ll.xist.ns import html 
    119  
    120 class IsExtLink(xsc.WalkFilter): 
     117from ll.xist import parsers, xfind 
     118from ll.xist.ns import html 
     119 
     120class IsExtLink(xfind.WalkFilter): 
    121121    def filternode(self, node): 
    122122        if isinstance(node, html.a) and not unicode(node.attrs.href).startswith(u"http://www.python.org"): 
    123             return (True, xsc.entercontent) 
    124         return (xsc.entercontent,) 
    125  
    126 doc = parsers.parseurl("http://www.python.org/", tidy=True) 
    127  
    128 for node in doc.walknode(IsExtLink()): 
     123            return (True, xfind.entercontent) 
     124        return (xfind.entercontent,) 
     125 
     126doc = parsers.parseurl("http://www.python.org/", tidy=True) 
     127 
     128for node in doc.walknodes(IsExtLink()): 
    129129    print node.attrs.href 
    130130</prog> 
     
    189189doc = parsers.parseurl("http://www.python.org/", tidy=True) 
    190190 
    191 for node in doc.walknode((html.a | html.area) &amp; xfind.hasattr("href")): 
     191for node in doc.walknodes((html.a | html.area) &amp; xfind.hasattr("href")): 
    192192    print node.attrs.href 
    193193</prog> 
     
    202202doc = parsers.parseurl("http://www.python.org/", tidy=True) 
    203203 
    204 for node in doc.walknode(xfind.hasattr("id")): 
     204for node in doc.walknodes(xfind.hasattr("id")): 
    205205    print node.attrs.id 
    206206</prog> 
     
    238238doc = parsers.parseurl("http://www.python.org/", tidy=True) 
    239239 
    240 for node in doc.walknode(css.selector("div#menu ul.level-one li > a")): 
     240for node in doc.walknodes(css.selector("div#menu ul.level-one li > a")): 
    241241    print node.attrs.href 
    242242</prog> 
  • setup.py

    r3930 r3933  
    164164FTP 
    165165ssh 
    166 py.execnet 
     166execnet 
    167167 
    168168# xml_codec 
     
    218218    news = news[underlines[0]-1:underlines[1]-1] 
    219219    news = "".join(news) 
    220     descr = "%s\n\n\n%s" % (DESCRIPTION.strip(), news) 
     220    descr = "{0}\n\n\n{1}".format(DESCRIPTION.strip(), news) 
    221221 
    222222    # Get rid of text roles PyPI doesn't know about 
     
    228228args = dict( 
    229229    name="ll-xist", 
    230     version="3.7.3", 
     230    version="3.8", 
    231231    description="Extensible HTML/XML generator, cross-platform templating language, Oracle utilities and various other tools", 
    232232    long_description=descr, 
     
    292292    zip_safe=False, 
    293293    dependency_links=[ 
    294         "http://sourceforge.net/project/showfiles.php?group_id=84168", # cx_Oracle 
     294        "http://cx-oracle.sourceforge.net/", # cx_Oracle 
    295295    ], 
    296296) 
  • src/ll/_url.c

    r3930 r3933  
    226226int appendempty(PyObject *newpath, int *pos) 
    227227{ 
    228     PyObject *newsegment = Py_BuildValue("(u#)", pos, 0); /* pos is ignored */ 
     228    PyObject *newsegment = PyUnicode_FromString(""); 
    229229    if (!newsegment) 
    230230    { 
     
    248248    for i in xrange(l): 
    249249        segment = path_segments[i] 
    250         if segment==(".",) or segment==("",): 
     250        if segment=="." or segment=="": 
    251251            if i==l-1: 
    252                 new_path_segments.append(("",)) 
    253         elif segment==("..",) and len(new_path_segments) and new_path_segments[-1]!=("..",): 
     252                new_path_segments.append("") 
     253        elif segment==".." and len(new_path_segments) and new_path_segments[-1]!="..": 
    254254            new_path_segments.pop() 
    255255            if i==l-1: 
    256                 new_path_segments.append(("",)) 
     256                new_path_segments.append("") 
    257257        else: 
    258258            new_path_segments.append(segment) 
     
    283283    { 
    284284        PyObject *segment = PyList_GET_ITEM(path, in); 
    285         PyObject *dir; 
    286         int segmentsize; 
    287  
    288         if (!PyTuple_CheckExact(segment) || (((segmentsize = PyTuple_GET_SIZE(segment)) != 1) && (segmentsize != 2))) 
    289         { 
    290             PyErr_SetString(PyExc_TypeError, "path entries must be tuples with 1 or 2 entries"); 
    291             Py_DECREF(newpath); 
    292             return NULL; 
    293         } 
    294         dir = PyTuple_GET_ITEM(segment, 0); 
    295         if (!PyUnicode_CheckExact(dir)) 
     285        int seglen; 
     286 
     287        if (!PyUnicode_CheckExact(segment)) 
    296288        { 
    297289            PyErr_SetString(PyExc_TypeError, "path entry directory must be unicode"); 
     
    299291            return NULL; 
    300292        } 
    301         if (segmentsize == 1) /* we can only optimize it, if it doesn't have params */ 
    302         { 
    303             int dirlen = PyUnicode_GET_SIZE(dir); 
    304             if ((dirlen==0) || ((dirlen==1) && (PyUnicode_AS_UNICODE(dir)[0] == '.'))) /* skip '' and '.' */ 
    305             { 
     293        seglen = PyUnicode_GET_SIZE(segment); 
     294        if ((seglen==0) || ((seglen==1) && (PyUnicode_AS_UNICODE(segment)[0] == '.'))) /* skip '' and '.' */ 
     295        { 
     296            if (in==pathsize-1) /* add empty terminating segment */ 
     297                if (!appendempty(newpath, &out)) 
     298                    return NULL; 
     299            continue; /* skip output */ 
     300        } 
     301        else if ((seglen == 2) && (PyUnicode_AS_UNICODE(segment)[0] == '.') && (PyUnicode_AS_UNICODE(segment)[1] == '.') && out) /* drop '..' and a previous real directory name */ 
     302        { 
     303            PyObject *lastnewsegment = PyTuple_GET_ITEM(newpath, out-1); 
     304 
     305            if (!((PyUnicode_GET_SIZE(lastnewsegment) == 2) && /* check that previous name is not '..' */ 
     306                    (PyUnicode_AS_UNICODE(lastnewsegment)[0] == '.') && 
     307                    (PyUnicode_AS_UNICODE(lastnewsegment)[1] == '.'))) 
     308            { 
     309                Py_DECREF(lastnewsegment); 
     310                PyTuple_SET_ITEM(newpath, --out, NULL); /* drop previous */ 
    306311                if (in==pathsize-1) /* add empty terminating segment */ 
    307312                    if (!appendempty(newpath, &out)) 
    308313                        return NULL; 
    309314                continue; /* skip output */ 
    310             } 
    311             else if ((dirlen == 2) && (PyUnicode_AS_UNICODE(dir)[0] == '.') && (PyUnicode_AS_UNICODE(dir)[1] == '.') && out) /* drop '..' and a previous real directory name */ 
    312             { 
    313                 PyObject *lastnewsegment = PyTuple_GET_ITEM(newpath, out-1); 
    314                 int lastnewsegmentsize = PyTuple_GET_SIZE(lastnewsegment); 
    315                 PyObject *lastnewsegmentdir = PyTuple_GET_ITEM(lastnewsegment, 0); 
    316  
    317                 if (!((lastnewsegmentsize==1) && /* check that previous name is not '..' */ 
    318                         (PyUnicode_GET_SIZE(lastnewsegmentdir) == 2) && 
    319                         (PyUnicode_AS_UNICODE(lastnewsegmentdir)[0] == '.') && 
    320                         (PyUnicode_AS_UNICODE(lastnewsegmentdir)[1] == '.'))) 
    321                 { 
    322                     Py_DECREF(lastnewsegment); 
    323                     PyTuple_SET_ITEM(newpath, --out, NULL); /* drop previous */ 
    324                     if (in==pathsize-1) /* add empty terminating segment */ 
    325                         if (!appendempty(newpath, &out)) 
    326                             return NULL; 
    327                     continue; /* skip output */ 
    328                 } 
    329315            } 
    330316        } 
  • src/ll/color.py

    r3930 r3933  
    7676        elif s in csscolors: 
    7777            return csscolors[s] 
    78         raise ValueError("can't interpret %s as css value" % s) 
     78        raise ValueError("can't interpret {0} as css value".format(s)) 
    7979 
    8080    @classmethod 
     
    111111    def __repr__(self): 
    112112        if self[3] != 0xff: 
    113             return "Color(0x%02x, 0x%02x, 0x%02x, 0x%02x)" % self 
     113            return "Color({0:#04x}, {1:#04x}, {2:#04x}, {3:#04x})".format(*self) 
    114114        else: 
    115             return "Color(0x%02x, 0x%02x, 0x%02x)" % self[:3] 
     115            return "Color({0:#04x}, {1:#04x}, {2:#04x})".format(self[0], self[1], self[2]) 
    116116 
    117117    def __str__(self): 
     
    120120        """ 
    121121        if self[3] != 0xff: 
    122             return "rgba(%d,%d,%d,%.3f)" % (self[0], self[1], self[2], self[3]/255.) 
     122            return "rgba({0},{1},{2},{3:.3f})".format(self[0], self[1], self[2], self[3]/255.) 
    123123        else: 
    124             s = "#%02x%02x%02x" % (self[0], self[1], self[2]) 
     124            s = "#{0:02x}{1:02x}{2:02x}".format(self[0], self[1], self[2]) 
    125125            if s[1]==s[2] and s[3]==s[4] and s[5]==s[6]: 
    126                 s = "#%s%s%s" % (s[1], s[3], s[5]) 
     126                s = "#{0}{1}{2}".format(s[1], s[3], s[5]) 
    127127        return s 
    128128 
  • src/ll/daemon.py

    r3930 r3933  
    3030        if counter.service(): 
    3131            import sys, os, time 
    32             sys.stdout.write("Daemon started with pid %d\n" % os.getpid()) 
     32            sys.stdout.write("Daemon started with pid {0}\n".format(os.getpid())) 
    3333            sys.stdout.write("Daemon stdout output\n") 
    3434            sys.stderr.write("Daemon stderr output\n") 
    3535            c = 0 
    3636            while True: 
    37                 sys.stdout.write('%d: %s\n' % (c, time.ctime(time.time()))) 
     37                sys.stdout.write('{0}: {1}\n'.format(c, time.ctime(time.time()))) 
    3838                sys.stdout.flush() 
    3939                c += 1 
     
    146146                sys.exit(0) # Exit first parent 
    147147        except OSError, exc: 
    148             sys.exit("%s: fork #1 failed: (%d) %s\n" % (sys.argv[0], exc.errno, exc.strerror)) 
     148            sys.exit("{0}: fork #1 failed: ({1}) {2}\n".format(sys.argv[0], exc.errno, exc.strerror)) 
    149149     
    150150        # Decouple from parent environment 
     
    159159                sys.exit(0) # Exit second parent 
    160160        except OSError, exc: 
    161             sys.exit("%s: fork #2 failed: (%d) %s\n" % (sys.argv[0], exc.errno, exc.strerror)) 
     161            sys.exit("{0}: fork #2 failed: ({1}) {2}\n".format(sys.argv[0], exc.errno, exc.strerror)) 
    162162     
    163163        # Now I am a daemon! 
     
    189189            pidfile = open(self.options.pidfile, "rb") 
    190190        except IOError, exc: 
    191             sys.exit("can't open pidfile %s: %s" % (self.options.pidfile, str(exc))) 
     191            sys.exit("can't open pidfile {0}: {1}".format(self.options.pidfile, str(exc))) 
    192192        data = pidfile.read() 
    193193        try: 
    194194            pid = int(data) 
    195195        except ValueError: 
    196             sys.exit("mangled pidfile %s: %r" % (self.options.pidfile, data)) 
     196            sys.exit("mangled pidfile {0}: {1}".format(self.options.pidfile, data)) 
    197197        os.kill(pid, signal.SIGTERM) 
    198198 
     
    245245            return False 
    246246        else: 
    247             p.error("incorrect argument %s" % self.args[1]) 
     247            p.error("incorrect argument {0}".format(self.args[1])) 
    248248            sys.exit(1) 
  • src/ll/make.py

    r3930 r3933  
    9999 
    100100    def __repr__(self): 
    101         return "<%s.%s object action=%r since=%r reportable=%r reported=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.action, self.since, self.reportable, self.reported, id(self)) 
     101        return "<{0}.{1} object action={2!r} since={3!r} reportable={4!r} reported={5} at {6:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.action, self.since, self.reportable, self.reported, id(self)) 
    102102 
    103103 
     
    161161                    if error is not None: 
    162162                        if error.__module__ != "exceptions": 
    163                             text = "%s.%s" % (error.__module__, error.__name__) 
     163                            text = "{0}.{1}".format(error.__module__, error.__name__) 
    164164                        else: 
    165165                            text = error.__name__ 
     
    168168                        args.append("nodata") 
    169169                    elif isinstance(data, str): 
    170                         args.append(s4data("str (%db)" % len(data))) 
     170                        args.append(s4data("str ({0}b)".format(len(data)))) 
    171171                    elif isinstance(data, unicode): 
    172                         args.append(s4data("unicode (%dc)" % len(data))) 
     172                        args.append(s4data("unicode ({0}c)".format(len(data)))) 
    173173                    else: 
    174174                        dataclass = data.__class__ 
    175175                        if dataclass.__module__ != "__builtin__": 
    176                             text = "%s.%s @ 0x%x" % (dataclass.__module__, dataclass.__name__, id(data)) 
     176                            text = "{0}.{1} @ {2:#x}".format(dataclass.__module__, dataclass.__name__, id(data)) 
    177177                        else: 
    178                             text = "%s @ 0x%x" % (dataclass.__name__, id(data)) 
     178                            text = "{0} @ {1:#x}".format(dataclass.__name__, id(data)) 
    179179                        args.append(s4data(text)) 
    180180                project.writestack(*args) 
     
    200200 
    201201    def __str__(self): 
    202         return "target with key=%r redefined" % self.key 
     202        return "target with key={0!r} redefined".format(self.key) 
    203203 
    204204 
     
    213213 
    214214    def __str__(self): 
    215         return "target %r undefined" % self.key 
     215        return "target {0!r} undefined".format(self.key) 
    216216 
    217217 
     
    281281        return obj.type 
    282282    except AttributeError: 
    283         return "%s.%s" % (obj.__class__.__module__, obj.__class__.__name__) 
     283        return "{0}.{1}".format(obj.__class__.__module__, obj.__class__.__name__) 
    284284_ipipe_type.__xname__ = "type" 
    285285 
     
    387387        return CallAttrAction(self, attrname, *args, **kwargs) 
    388388 
     389    def __or__(self, other): 
     390        """ 
     391        Return an :class:`OrAction` for "oring" :var:`self` and :var:`other`. 
     392        """ 
     393        if not isinstance(other, Action): 
     394            other = ObjectAction(other) 
     395        return OrAction(self, other) 
     396 
    389397    def __repr__(self): 
    390398        def format(arg): 
    391399            if isinstance(arg, Action): 
    392                 return " from %s.%s" % (arg.__class__.__module__, arg.__class__.__name__) 
     400                return " from {0}.{1}".format(arg.__class__.__module__, arg.__class__.__name__) 
    393401            elif isinstance(arg, tuple): 
    394402                return "=(?)" 
     
    398406                return "={?}" 
    399407            else: 
    400                 return "=%r" % (arg,) 
    401  
    402         output = ["arg %d%s" % (i, format(arg)) for (i, arg) in enumerate(self.getargs())] 
     408                return "={0!r}"/format(arg) 
     409 
     410        output = ["arg {0}{1}".format(i, format(arg)) for (i, arg) in enumerate(self.getargs())] 
    403411        for (argname, arg) in self.getkwargs().iteritems(): 
    404             output.append("arg %s%s" % (argname, format(arg))) 
     412            output.append("arg {0}{1}".format(argname, format(arg))) 
    405413             
    406414        if output: 
    407             output = " with %s" % ", ".join(output) 
     415            output = " with {0}".format(", ".join(output)) 
    408416        else: 
    409417            output = "" 
    410         return "<%s.%s object%s at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, output, id(self)) 
     418        return "<{0}.{1} object{2} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, output, id(self)) 
    411419 
    412420    @misc.notimplemented 
     
    466474                    if len(test) < len(s): 
    467475                        s = test 
    468                     test = "~/%s" % key.relative(home) 
     476                    test = "~/{0}".format(key.relative(home)) 
    469477                    if len(test) < len(s): 
    470478                        s = test 
     
    550558 
    551559    def __repr__(self): 
    552         return "<%s.%s object at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, id(self)) 
     560        return "<{0}.{1} object at {2:#x}>".format(self.__class__.__module__, self.__class__.__name__, id(self)) 
    553561 
    554562 
     
    602610 
    603611    def __repr__(self): 
    604         s = "<%s.%s object" % (self.__class__.__module__, self.__class__.__name__) 
     612        s = "<{0}.{1} object".format(self.__class__.__module__, self.__class__.__name__) 
    605613        if self.key is not None: 
    606             s += " with key=%r" % self.key 
    607         s += " at 0x%x>" % id(self) 
     614            s += " with key={0!r}".format(self.key) 
     615        s += " at {0:#x}>".format(id(self)) 
    608616        return s 
    609617 
     
    673681        else: # We have no inputs (i.e. this is a "source" file) 
    674682            if self.changed is bigbang: 
    675                 raise ValueError("source file %r doesn't exist" % self.key) 
     683                raise ValueError("source file {0!r} doesn't exist".format(self.key)) 
    676684        if self.changed > since: # We are up to date now and newer than the output action 
    677685            return self.read(project) # return file data (to output action or client) 
     
    694702 
    695703    def __repr__(self): 
    696         return "<%s.%s object key=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.key, id(self)) 
     704        return "<{0}.{1} object key={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.key, id(self)) 
    697705 
    698706 
     
    721729 
    722730    def __repr__(self): 
    723         return "<%s.%s object with mode=0%03o at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.mode, id(self)) 
     731        return "<{0}.{1} object with mode={2:#03o} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.mode, id(self)) 
    724732 
    725733 
     
    752760 
    753761    def __repr__(self): 
    754         return "<%s.%s object with command=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.command, id(self)) 
     762        return "<{0}.{1} object with command={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.command, id(self)) 
    755763 
    756764 
     
    899907    __ http://xmlgraphics.apache.org/fop/ 
    900908    """ 
    901     command = "/usr/local/src/fop-0.20.5/fop.sh -q -c /usr/local/src/fop-0.20.5/conf/userconfig.xml -fo %s -pdf %s" 
     909    command = "/usr/local/src/fop-0.20.5/fop.sh -q -c /usr/local/src/fop-0.20.5/conf/userconfig.xml -fo {src} -pdf {dst}" 
    902910 
    903911    def execute(self, project, data): 
     
    910918            infile.write(data) 
    911919            infile.close() 
    912             os.system(self.command % (inname, outname)) 
     920            os.system(self.command.format(src=inname, dst=outname)) 
    913921            data = open(outname, "rb").read() 
    914922        finally: 
     
    948956                argsmsg = " with 1 arg" 
    949957            else: 
    950                 argsmsg = " with %d args" % len(args) 
     958                argsmsg = " with {0} args".format(len(args)) 
    951959        else: 
    952960            argsmsg = " without args" 
    953961        if kwargs: 
    954962            if len(kwargs) == 1: 
    955                 kwargsmsg = " and keyword %s" % ", ".join(kwargs) 
     963                kwargsmsg = " and keyword {0}".format(", ".join(kwargs)) 
    956964            else: 
    957                 kwargsmsg = " and keywords %s" % ", ".join(kwargs) 
     965                kwargsmsg = " and keywords {0}".format(", ".join(kwargs)) 
    958966        else: 
    959967            kwargsmsg = "" 
    960         project.writestep(self, "Calling %r" % (func, ), argsmsg, kwargsmsg) 
     968        project.writestep(self, "Calling {0!r}".format(func), argsmsg, kwargsmsg) 
    961969        return func(*args, **kwargs) 
    962970 
     
    991999    def execute(self, project, obj, attrname, *args, **kwargs): 
    9921000        func = getattr(obj, attrname) 
    993         project.writestep(self, "Calling %r" % func) 
     1001        project.writestep(self, "Calling {0!r}".format(func)) 
    9941002        return func(*args, **kwargs) 
     1003 
     1004 
     1005class OrAction(Action): 
     1006    """ 
     1007    This action "ors" the output of its input objects. 
     1008    """ 
     1009 
     1010    def __init__(self, *inputs): 
     1011        Action.__init__(self) 
     1012        self.inputs = inputs 
     1013 
     1014    def __iter__(self): 
     1015        for input in self.inputs: 
     1016            yield input 
     1017 
     1018    def __or__(self, other): 
     1019        if not isinstance(other, Action): 
     1020            other = ObjectAction(other) 
     1021        return OrAction(*(self.inputs + (other,))) 
     1022 
     1023    def getargs(self): 
     1024        return self.inputs 
     1025 
     1026    def execute(self, project, *inputs): 
     1027        project.writestep(self, "Oring ", len(inputs), " inputs") 
     1028        result = None 
     1029        for (i, input) in enumerate(inputs): 
     1030            if i: 
     1031                result |= input 
     1032            else: 
     1033                result = input 
     1034        return result 
    9951035 
    9961036 
     
    10141054 
    10151055    def __repr__(self): 
    1016         return "<%s.%s object command=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.command, id(self)) 
     1056        return "<{0}.{1} object command={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.command, id(self)) 
    10171057 
    10181058 
     
    10431083        """ 
    10441084        key = self.getkey() 
    1045         project.writestep(self, "Changing mode of ", project.strkey(key), " to 0%03o" % mode) 
     1085        project.writestep(self, "Changing mode of ", project.strkey(key), " to {0:#03o}".format(mode)) 
    10461086        key.chmod(mode) 
    10471087        return data 
     
    11441184        del self.inputs[:] # The module will be reloaded => drop all dependencies (they will be rebuilt during import) 
    11451185 
    1146         # Normalize line feeds, so that :func:`compile` works (normally done by import) 
    1147         data = data.replace("\r\n", "\n") 
    1148  
    1149         mod = types.ModuleType(name) 
    1150         mod.__file__ = filename 
    1151  
    11521186        try: 
    11531187            project.importstack.append(self) 
    1154             code = compile(data, filename, "exec") 
    1155             exec code in mod.__dict__ 
     1188            mod = misc.module(data, filename, name) 
    11561189        finally: 
    11571190            project.importstack.pop(-1) 
     
    11951228 
    11961229    def __repr__(self): 
    1197         return "<%s.%s object key=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.getkey(), id(self)) 
     1230        return "<{0}.{1} object key={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.getkey(), id(self)) 
    11981231 
    11991232 
     
    12831316 
    12841317    def __repr__(self): 
    1285         return "<%s.%s with %d targets at 0x%x>" % (self.__module__, self.__class__.__name__, len(self), id(self)) 
     1318        return "<{0}.{1} with {2} targets at {3:#x}>".format(self.__module__, self.__class__.__name__, len(self), id(self)) 
    12861319 
    12871320    class showaction(misc.propclass): 
     
    14211454            secs += delta.microseconds/1000000. 
    14221455            if rest: 
    1423                 text = "%d:%02d:%06.3fh" % (rest, mins, secs) 
     1456                text = "{0:d}:{1:02d}:{2:06.3f}h".format(rest, mins, secs) 
    14241457            elif mins: 
    1425                 text = "%02d:%06.3fm" % (mins, secs) 
     1458                text = "{0:02d}:{1:06.3f}m".format(mins, secs) 
    14261459            else: 
    1427                 text = "%.3fs" % secs 
     1460                text = "{0:.3f}s".format(secs) 
    14281461        return s4time(text) 
    14291462 
     
    14331466        :class:`datetime.datetime` value :var:`dt`. 
    14341467        """ 
    1435         return s4time(dt.strftime("%Y-%m-%d %H:%M:%S"), ".%06d" % (dt.microsecond)) 
     1468        return s4time(dt.strftime("%Y-%m-%d %H:%M:%S"), "{0:06d}".format(dt.microsecond)) 
    14361469 
    14371470    def strcounter(self, counter): 
     
    14401473        :var:`counter`. 
    14411474        """ 
    1442         return s4counter("%d." % counter) 
     1475        return s4counter("{0}.".format(counter)) 
    14431476 
    14441477    def strerror(self, text): 
     
    14631496            if len(test) < len(s): 
    14641497                s = test 
    1465             test = "~/%s" % key.relative(self.home) 
     1498            test = "~/{0}".format(key.relative(self.home)) 
    14661499            if len(test) < len(s): 
    14671500                s = test 
     
    16201653        p.add_option("-C", "--nocolor", dest="color", help="No colored output", action="store_false", default=None) 
    16211654        p.add_option("-g", "--growl", dest="growl", help="Issue growl notification after the build?", action="store_true", default=None) 
    1622         p.add_option("-a", "--showaction", dest="showaction", help="Show actions (%s)?" % ", ".join(actions), choices=actions, default=action2name(self.showaction)) 
    1623         p.add_option("-s", "--showstep", dest="showstep", help="Show steps (%s)?" % ", ".join(actions), choices=actions, default=action2name(self.showstep)) 
    1624         p.add_option("-n", "--shownote", dest="shownote", help="Show notes (%s)?" % ", ".join(actions), choices=actions, default=action2name(self.shownote)) 
    1625         p.add_option("-r", "--showregistration", dest="showregistration", help="Show registration (%s)?" % ", ".join(actions), choices=actions, default=action2name(self.showregistration)) 
     1655        p.add_option("-a", "--showaction", dest="showaction", help="Show actions ({0})?".format(", ".join(actions)), choices=actions, default=action2name(self.showaction)) 
     1656        p.add_option("-s", "--showstep", dest="showstep", help="Show steps ({0})?".format(", ".join(actions)), choices=actions, default=action2name(self.showstep)) 
     1657        p.add_option("-n", "--shownote", dest="shownote", help="Show notes ({0})?".format(", ".join(actions)), choices=actions, default=action2name(self.shownote)) 
     1658        p.add_option("-r", "--showregistration", dest="showregistration", help="Show registration ({0})?".format(", ".join(actions)), choices=actions, default=action2name(self.showregistration)) 
    16261659        p.add_option("-i", "--showidle", dest="showidle", help="Show actions that didn't produce data?", action="store_true", default=self.showidle) 
    16271660        p.add_option("-d", "--showdata", dest="showdata", help="Show data?", action="store_true", default=self.showdata) 
     
    17331766                self.writeln() 
    17341767            if self.growl: 
    1735                 filename = os.path.abspath(sys.modules[self.__class__.__module__].__file__) 
    1736                 cmd = "growlnotify -i py -n ll.make 'll.make done in %s'" % self.strtimedelta(now-self.starttime) 
     1768                try: 
     1769                    module = sys.modules[self.__class__.__module__] 
     1770                except KeyError: 
     1771                    filename = "???.py" 
     1772                else: 
     1773                    filename = os.path.abspath(module.__file__) 
     1774                cmd = "growlnotify -i py -n ll.make 'll.make done in {0}'".format(self.strtimedelta(now-self.starttime)) 
    17371775                import subprocess 
    17381776                pipe = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE).stdin 
    1739                 pipe.write("%s\n" % filename) 
    1740                 pipe.write("%s.%s\n" % (self.__class__.__module__, self.__class__.__name__)) 
    1741                 pipe.write("%d registered targets, " % len(self)) 
    1742                 pipe.write("%d actions called, " % self.actionscalled) 
    1743                 pipe.write("%d steps executed, " % self.stepsexecuted) 
    1744                 pipe.write("%d files/%d bytes read, " % (self.filesread, self.bytesread)) 
    1745                 pipe.write("%d files/%d bytes written, " % (self.fileswritten, self.byteswritten)) 
    1746                 pipe.write("%d actions failed" % self.actionsfailed) 
     1777                pipe.write("{0}\n".format(filename)) 
     1778                pipe.write("{0}.{1}\n".format(self.__class__.__module__, self.__class__.__name__)) 
     1779                pipe.write("{0} registered targets, ".format(len(self))) 
     1780                pipe.write("{0} actions called, ".format(self.actionscalled)) 
     1781                pipe.write("{0} steps executed, ".format(self.stepsexecuted)) 
     1782                pipe.write("{0} files/{1} bytes read, ".format(self.filesread, self.bytesread)) 
     1783                pipe.write("{0} files/{1} bytes written, ".format(self.fileswritten, self.byteswritten)) 
     1784                pipe.write("{0} actions failed".format(self.actionsfailed)) 
    17471785                pipe.close() 
    17481786 
  • src/ll/misc.py

    r3930 r3933  
    1616 
    1717 
    18 import sys, types, collections, weakref, cStringIO, gzip as gzip_ 
     18import sys, os, types, collections, weakref, cStringIO, gzip as gzip_ 
    1919 
    2020 
     
    104104            string = string.replace('"', "&quot;") 
    105105            for c in "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1f\x7f\x80\x81\x82\x83\x84\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f": 
    106                 string = string.replace(c, "&#%d;" % ord(c)) 
     106                string = string.replace(c, "&#{0};".format(ord(c))) 
    107107            return string 
    108108 
     
    120120            string = string.replace(">", "&gt;") 
    121121            for c in "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1f\x7f\x80\x81\x82\x83\x84\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f": 
    122                 string = string.replace(c, "&#%d;" % ord(c)) 
     122                string = string.replace(c, "&#{0};".format(ord(c))) 
    123123            return string 
    124124 
     
    137137            string = string.replace('"', "&quot;") 
    138138            for c in "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1f\x7f\x80\x81\x82\x83\x84\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f": 
    139                 string = string.replace(c, "&#%d;" % ord(c)) 
     139                string = string.replace(c, "&#{0};".format(ord(c))) 
    140140            return string 
    141141 
     
    148148    """ 
    149149    def wrapper(self, *args, **kwargs): 
    150         raise NotImplementedError("method %s() not implemented in %r" % (function.__name__, self.__class__)) 
     150        raise NotImplementedError("method {0}() not implemented in {1!r}".format(function.__name__, self.__class__)) 
    151151    wrapper.__dict__.update(function.__dict__) 
    152152    wrapper.__doc__ = function.__doc__ 
     
    278278 
    279279    def __repr__(self): 
    280         return "<%s.%s object with %d items at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, len(self._attrs), id(self)) 
     280        return "<{0}.{1} object with {2} items at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, len(self._attrs), id(self)) 
    281281 
    282282 
     
    365365 
    366366    def __repr__(self): 
    367         return "%s.%s" % (self.__module__, self._name) 
     367        return "{0}.{1}".format(self.__module__, self._name) 
    368368 
    369369 
     
    450450 
    451451 
     452def module(code, filename="unnamed.py", name=None): 
     453    """ 
     454    Create a module from the Python source code :var:`code`. :var:`filename` will 
     455    be used as the filename for the module and :var:`name` as the module name 
     456    (defaulting to the filename part of :var:`filename`). 
     457    """ 
     458    if name is None: 
     459        name = os.path.splitext(os.path.basename(filename))[0] 
     460    mod = types.ModuleType(name) 
     461    mod.__file__ = filename 
     462    code = code.replace("\r\n", "\n") # Normalize line feeds, so that :func:`compile` works (normally done by import) 
     463    code = compile(code, filename, "exec") 
     464    exec code in mod.__dict__ 
     465    return mod 
     466 
     467 
    452468class JSMinUnterminatedComment(Exception): 
    453469    pass 
  • src/ll/nightshade.py

    r3793 r3893  
    8888    else: 
    8989        dt -= dt.tzinfo.utcoffset(dt) 
    90     return "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (weekdayname[dt.weekday()], dt.day, monthname[dt.month], dt.year, dt.hour, dt.minute, dt.second) 
     90    return "{0}, {1:02d} {2:3s} {3:4d} {4:02d}:{5:02d}:{6:02d} GMT".format(weekdayname[dt.weekday()], dt.day, monthname[dt.month], dt.year, dt.hour, dt.minute, dt.second) 
    9191 
    9292 
     
    265265                encoding = result.get("p_encoding", None) 
    266266            if encoding is not None: 
    267                 cherrypy.response.headers["Content-Type"] = "%s; charset=%s" % (mimetype, encoding) 
     267                cherrypy.response.headers["Content-Type"] = "{0}; charset={1}".format(mimetype, encoding) 
    268268            else: 
    269269                cherrypy.response.headers["Content-Type"] = mimetype 
     
    288288                result = result.read() 
    289289            if not hasetag: 
    290                 cherrypy.response.headers["ETag"] = '"%x"' % hash(body) 
     290                cherrypy.response.headers["ETag"] = '"{0:x}"'.format(hash(body)) 
    291291 
    292292        if hasattr(body, "read"): 
  • src/ll/orasql/__init__.py

    r3930 r3933  
    6868class SQLObjectNotFoundError(IOError): 
    6969    def __init__(self, obj): 
    70         IOError.__init__(self, errno.ENOENT, "no such %s: %s" % (obj.type, getfullname(obj.name, obj.owner))) 
     70        IOError.__init__(self, errno.ENOENT, "no such {0}: {1}".format(obj.type, getfullname(obj.name, obj.owner))) 
    7171        self.obj = obj 
    7272 
     
    7878 
    7979    def __repr__(self): 
    80         return "<%s.%s name=%r owner=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.name, self.owner, id(self)) 
     80        return "<{0}.{1} name={2!r} owner={3!r} at {4:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.name, self.owner, id(self)) 
    8181 
    8282    def __str__(self): 
    8383        if self.owner is None: 
    84             return "no object named %r" % (self.name, ) 
    85         else: 
    86             return "no object named %r for owner %r" % (self.name, self.owner) 
     84            return "no object named {0!r}".format(self.name) 
     85        else: 
     86            return "no object named {0!r} for owner {1!r}".format(self.name, self.owner) 
    8787 
    8888 
     
    9292 
    9393    def __repr__(self): 
    94         return "<%s.%s mode=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.mode, id(self)) 
     94        return "<{0}.{1} mode={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.mode, id(self)) 
    9595 
    9696    def __str__(self): 
    97         return "unknown mode %r" % self.mode 
     97        return "unknown mode {0!r}".format(self.mode) 
    9898 
    9999 
     
    103103 
    104104    def __repr__(self): 
    105         return "<%s.%s schema=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.schema, id(self)) 
     105        return "<{0}.{1} schema={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.schema, id(self)) 
    106106 
    107107    def __str__(self): 
    108         return "unknown schema %r" % self.schema 
     108        return "unknown schema {0!r}".format(self.schema) 
    109109 
    110110 
     
    115115 
    116116    def __repr__(self): 
    117         return "<%s.%s object=%r message=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.object, self.message, id(self)) 
     117        return "<{0}.{1} object={2!r} message={3!r} at {4:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.object, self.message, id(self)) 
    118118 
    119119    def __str__(self): 
    120         return "conflict in %r: %s" % (self.object, self.message) 
     120        return "conflict in {0!r}: {1}".format(self.object, self.message) 
    121121 
    122122 
     
    168168    def __xrepr__(self, mode): 
    169169        if mode == "header": 
    170             yield (astyle.style_default, "%s.%s" % (self.__class__.__module__, self.__class__.__name__)) 
     170            yield (astyle.style_default, "{0}.{1}".format(self.__class__.__module__, self.__class__.__name__)) 
    171171        else: 
    172172            yield (astyle.style_default, repr(self)) 
    173173 
    174174    def __repr__(self): 
    175         return "%s.%s(%s)" % (self.__class__.__module__, self.__class__.__name__, ", ".join("%s=%r" % item for item in self.iteritems())) 
     175        return "{0}.{1}({2})".format(self.__class__.__module__, self.__class__.__name__, ", ".join("{0}={1!r}".format(*item) for item in self.iteritems())) 
    176176 
    177177 
     
    215215            index = self._name2index[name.lower()] 
    216216        except KeyError: 
    217             raise AttributeError("'%s' object has no attribute %r" % (self.__class__.__name__, name)) 
     217            raise AttributeError("'{0}' object has no attribute {1!r}".format(self.__class__.__name__, name)) 
    218218        return tuple.__getitem__(self, index) 
    219219 
     
    262262    def __xrepr__(self, mode): 
    263263        if mode == "header": 
    264             yield (astyle.style_default, "%s.%s" % (self.__class__.__module__, self.__class__.__name__)) 
     264            yield (astyle.style_default, "{0}.{1}".format(self.__class__.__module__, self.__class__.__name__)) 
    265265        else: 
    266266            yield (astyle.style_default, repr(self)) 
    267267 
    268268    def __repr__(self): 
    269         return "<%s.%s %s at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, ", ".join("%s=%r" % item for item in self.iteritems()), id(self)) 
     269        return "<{0}.{1} {2} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, ", ".join("{0}={1!r}".format(*item) for item in self.iteritems()), id(self)) 
    270270 
    271271 
     
    302302 
    303303    def connectstring(self): 
    304         return "%s@%s" % (self.username, self.tnsentry) 
     304        return "{0}@{1}".format(self.username, self.tnsentry) 
    305305 
    306306    def __repr__(self): 
    307         return "<%s.%s object db=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.connectstring(), id(self)) 
     307        return "<{0}.{1} object db={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.connectstring(), id(self)) 
    308308 
    309309 
     
    334334 
    335335    def connectstring(self): 
    336         return "%s@%s" % (self.username, self.tnsentry) 
     336        return "{0}@{1}".format(self.username, self.tnsentry) 
    337337 
    338338    def cursor(self, readlobs=None): 
     
    344344 
    345345    def __repr__(self): 
    346         return "<%s.%s object db=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.connectstring(), id(self)) 
     346        return "<{0}.{1} object db={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.connectstring(), id(self)) 
    347347 
    348348    def __xrepr__(self, mode): 
    349349        if mode == "header" or mode=="footer": 
    350             yield (astyle.style_default, "oracle connection to %s" % self.connectstring()) 
     350            yield (astyle.style_default, "oracle connection to {0}".format(self.connectstring())) 
    351351        elif mode == "cell": 
    352352            yield (style_connection, self.connectstring()) 
     
    572572                    for rec2 in cursor.fetchall(): 
    573573                        # No dependency checks neccessary, but use ``do`` anyway 
    574                         for subobj in do(Comment("%s.%s" % (rec.table_name, rec2.column_name), rec.owner, self)): 
     574                        for subobj in do(Comment("{0}.{1}".format(rec.table_name, rec2.column_name), rec.owner, self)): 
    575575                            yield subobj 
    576576 
     
    652652                cls = Object.name2type[type] 
    653653            except KeyError: 
    654                 raise TypeError("type %s not supported" % type) 
     654                raise TypeError("type {0} not supported".format(type)) 
    655655            else: 
    656656                return cls(rec.object_name, rec.owner, self) 
     
    703703                cls = Object.name2type[type] 
    704704            except KeyError: 
    705                 raise TypeError("type %s not supported" % type) 
     705                raise TypeError("type {0} not supported".format(type)) 
    706706            else: 
    707707                return cls(rec.object_name, rec.owner, self) 
     
    786786 
    787787    def __repr__(self): 
    788         return "<%s.%s statement=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.statement, id(self)) 
     788        return "<{0}.{1} statement={2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.statement, id(self)) 
    789789 
    790790 
     
    802802            if result: 
    803803                result.append(" || ") 
    804             result.append("'%s'" % "".join(current)) 
     804            result.append(u"'{0}'".format("".join(current))) 
    805805 
    806806    for c in value: 
    807807        if c == "'": 
    808             current.append("''") 
     808            current.append(u"''") 
    809809            shipcurrent() 
    810810        elif ord(c) < 32 or ord(c)>upper: 
     
    812812            current = [] 
    813813            if result: 
    814                 result.append(" || ") 
    815             result.append("chr(%d)" % ord(c)) 
     814                result.append(u" || ") 
     815            result.append(u"chr({0})".format(ord(c))) 
    816816        else: 
    817817            current.append(c) 
    818818            shipcurrent() 
    819819    shipcurrent(True) 
    820     return "".join(result) 
     820    return u"".join(result) 
    821821 
    822822 
     
    851851        (connection, cursor) = self.getcursor(connection) 
    852852        cursor.execute("select text from all_source where lower(type)=lower(:type) and owner=nvl(:owner, user) and name=:name order by line", type=self.__class__.type, owner=self.owner, name=self.name) 
    853         code = "\n".join((rec.text or "").rstrip() for rec in cursor) # sqlplus strips trailing spaces when executing SQL scripts, so we do that too 
     853        code = u"\n".join((rec.text or "").rstrip() for rec in cursor) # sqlplus strips trailing spaces when executing SQL scripts, so we do that too 
    854854        if not code: 
    855855            raise SQLObjectNotFoundError(self) 
    856         code = " ".join(code.split(None, 1)) # compress "PROCEDURE          FOO" 
     856        code = u" ".join(code.split(None, 1)) # compress "PROCEDURE          FOO" 
    857857        code = code.strip() 
    858858        type = self.__class__.type 
     
    860860        code = code.split(None, 1)[1] # drop our own name (as for triggers this includes the schema name) 
    861861        if self.owner is not None: 
    862             code = "create or replace %s %s.%s\n%s\n" % (type, self.owner, self.name, code) 
    863         else: 
    864             code = "create or replace %s %s\n%s\n" % (type, self.name, code) 
    865         if term: 
    866             code += "\n/\n" 
    867         else: 
    868             code += "\n" 
     862            code = u"create or replace {0} {1}.{2}\n{3}\n".format(type, self.owner, self.name, code) 
     863        else: 
     864            code = u"create or replace {0} {1}\n{2}\n".format(type, self.name, code) 
     865        if term: 
     866            code += u"\n/\n" 
     867        else: 
     868            code += u"\n" 
    869869        return code 
    870870 
    871871    def dropddl(self, connection=None, term=True): 
    872872        if self.owner is not None: 
    873             name = "%s.%s" % (self.owner, self.name) 
     873            name = u"{0}.{1}".format(self.owner, self.name) 
    874874        else: 
    875875            name = self.name 
    876         code = "drop %s %s" % (self.__class__.type, name) 
    877         if term: 
    878             code += ";\n" 
    879         else: 
    880             code += "\n" 
     876        code = u"drop {0} {1}".format(self.__class__.type, name) 
     877        if term: 
     878            code += u";\n" 
     879        else: 
     880            code += u"\n" 
    881881        return code 
    882882 
     
    884884    def fixname(cls, name, code): 
    885885        code = code.split(None, 5) 
    886         code = "create or replace %s %s\n%s" % (code[3], name, code[5]) 
     886        code = u"create or replace {0} {1}\n{2}".format(code[3], name, code[5]) 
    887887        return code 
    888888 
     
    892892    if owner is not None: 
    893893        if owner != owner.upper(): 
    894             parts.append('"%s"' % owner) 
     894            parts.append('"{0}"'.format(owner)) 
    895895        else: 
    896896            parts.append(owner) 
    897897    for part in name.split("."): 
    898898        if part != part.upper(): 
    899             parts.append('"%s"' % part) 
     899            parts.append('"{0}"'.format(part)) 
    900900        else: 
    901901            parts.append(part) 
     
    933933    def __repr__(self): 
    934934        if self.owner is not None: 
    935             return "%s.%s(%r, %r)" % (self.__class__.__module__, self.__class__.__name__, self.name, self.owner) 
    936         else: 
    937             return "%s.%s(%r)" % (self.__class__.__module__, self.__class__.__name__, self.name) 
     935            return "{0}.{1}({2!r}, {3!r})".format(self.__class__.__module__, self.__class__.__name__, self.name, self.owner) 
     936        else: 
     937            return "{0}.{1}({2!r})".format(self.__class__.__module__, self.__class__.__name__, self.name) 
    938938 
    939939    def __str__(self): 
    940940        if self.owner is not None: 
    941             return "%s(%s, %s)" % (self.__class__.__name__, self.name, self.owner) 
    942         else: 
    943             return "%s(%s)" % (self.__class__.__name__, self.name) 
     941            return "{0}({1}, {2})".format(self.__class__.__name__, self.name, self.owner) 
     942        else: 
     943            return "{0}({1})".format(self.__class__.__name__, self.name) 
    944944 
    945945    def __eq__(self, other): 
     
    11481148        if rec is None: 
    11491149            raise SQLObjectNotFoundError(self) 
    1150         code  = "create sequence %s\n" % self.getfullname() 
    1151         code += "\tincrement by %d\n" % rec.increment_by 
     1150        code  = "create sequence {0}\n".format(self.getfullname()) 
     1151        code += "\tincrement by {0}\n".format(rec.increment_by) 
    11521152        if copyvalue: 
    1153             code += "\tstart with %d\n" % (rec.last_number + rec.increment_by) 
    1154         else: 
    1155             code += "\tstart with %d\n" % rec.min_value 
    1156         code += "\tmaxvalue %s\n" % rec.max_value 
    1157         code += "\tminvalue %d\n" % rec.min_value 
    1158         code += "\t%scycle\n" % ["no", ""][rec.cycle_flag == "Y"] 
     1153            code += "\tstart with {0}\n".format(rec.last_number + rec.increment_by) 
     1154        else: 
     1155            code += "\tstart with {0}\n".format(rec.min_value) 
     1156        code += "\tmaxvalue {0}\n".format(rec.max_value) 
     1157        code += "\tminvalue {0}\n".format(rec.min_value) 
     1158        code += "\t{0}cycle\n".format("" if rec.cycle_flag == "Y" else "no") 
    11591159        if rec.cache_size: 
    1160             code += "\tcache %d\n" % rec.cache_size 
     1160            code += "\tcache {0}\n".format(rec.cache_size) 
    11611161        else: 
    11621162            code += "\tnocache\n" 
    1163         code += "\t%sorder" % ["no", ""][rec.order_flag == "Y"] 
     1163        code += "\t{0}order".format("" if rec.cycle_flag == "Y" else "no") 
    11641164        if term: 
    11651165            code += ";\n" 
     
    11781178 
    11791179    def dropddl(self, connection=None, term=True): 
    1180         code = "drop sequence %s" % self.getfullname() 
    1181         if term: 
    1182             code += ";\n" 
    1183         else: 
    1184             code += "\n" 
     1180        code = u"drop sequence {0}".format(self.getfullname()) 
     1181        if term: 
     1182            code += u";\n" 
     1183        else: 
     1184            code += u"\n" 
    11851185        return code 
    11861186 
     
    11881188    def fixname(cls, name, code): 
    11891189        code = code.split(None, 3) 
    1190         code = "create sequence %s\n%s" % (name, code[3]) 
     1190        code = u"create sequence {0}\n{1}".format(name, code[3]) 
    11911191        return code 
    11921192 
     
    12191219        ftype = "number" 
    12201220    elif ftype == "number" and fprec == 0: 
    1221         ftype = "number(%d)" % fsize 
     1221        ftype = "number({0})".format(fsize) 
    12221222    elif ftype == "number": 
    1223         ftype = "number(%d, %d)" % (fsize, fprec) 
     1223        ftype = "number({0}, {1})".format(fsize, fprec) 
    12241224    elif ftype == "raw": 
    1225         ftype = "raw(%d)" % rec.data_length 
     1225        ftype = "raw({0})".format(rec.data_length) 
    12261226    else: 
    12271227        if char_length != 0: 
    12281228            fsize = char_length 
    12291229        if fsize is not None: 
    1230             ftype += "(%d" % fsize 
     1230            ftype += "({0}".format(fsize) 
    12311231            if rec.char_used == "B": 
    12321232                ftype += " byte" 
     
    12341234                ftype += " char" 
    12351235            if fprec is not None: 
    1236                 ftype += ", %d" % fprec 
     1236                ftype += ", {0}".format(fprec) 
    12371237            ftype += ")" 
    12381238    return ftype 
     
    12591259        if not recs: 
    12601260            raise SQLObjectNotFoundError(self) 
    1261         code = ["create table %s\n(\n" % self.getfullname()] 
     1261        code = [u"create table {0}\n(\n".format(self.getfullname())] 
    12621262        for (i, rec) in enumerate(recs): 
    12631263            if i: 
    1264                 code.append(",\n") 
    1265             code.append("\t%s %s" % (rec.column_name, _columntype(rec))) 
     1264                code.append(u",\n") 
     1265            code.append(u"\t{0} {1}".format(rec.column_name, _columntype(rec))) 
    12661266            default = _columndefault(rec) 
    12671267            if default != "null": 
    1268                 code.append(" default %s" % default) 
     1268                code.append(u" default {0}".format(default)) 
    12691269            if rec.nullable == "N": 
    1270                 code.append(" not null") 
    1271         if term: 
    1272             code.append("\n);\n") 
    1273         else: 
    1274             code.append("\n)\n") 
    1275         return "".join(code) 
     1270                code.append(u" not null") 
     1271        if term: 
     1272            code.append(u"\n);\n") 
     1273        else: 
     1274            code.append(u"\n)\n") 
     1275        return u"".join(code) 
    12761276 
    12771277    def dropddl(self, connection=None, term=True): 
    12781278        if self.ismview(connection): 
    12791279            return "" 
    1280         code = "drop table %s" % self.getfullname() 
    1281         if term: 
    1282             code += ";\n" 
    1283         else: 
    1284             code += "\n" 
     1280        code = u"drop table {0}".format(self.getfullname()) 
     1281        if term: 
     1282            code += u";\n" 
     1283        else: 
     1284            code += u"\n" 
    12851285        return code 
    12861286 
     
    12881288    def fixname(cls, name, code): 
    12891289        code = code.split(None, 3) 
    1290         code = "create table %s\n%s" % (name, code[3]) 
     1290        code = u"create table {0}\n{1}".format(name, code[3]) 
    12911291        return code 
    12921292 
     
    13261326 
    13271327        for rec in cursor.fetchall(): 
    1328             yield Column("%s.%s" % (self.name, rec.column_name), self.owner, connection) 
     1328            yield Column("{0}.{1}".format(self.name, rec.column_name), self.owner, connection) 
    13291329 
    13301330    def iterrecords(self, connection=None): 
     
    13331333        """ 
    13341334        (connection, cursor) = self.getcursor(connection) 
    1335         query = "select * from %s" % self.getfullname() 
     1335        query = "select * from {0}".format(self.getfullname()) 
    13361336        cursor.execute(query) 
    13371337        return iter(cursor) 
     
    13441344        cursor.execute("select column_name from all_tab_columns where owner=nvl(:owner, user) and table_name=:name order by column_id", owner=self.owner, name=self.name) 
    13451345        for rec in cursor.fetchall(): 
    1346             yield Comment("%s.%s" % (self.name, rec.column_name), self.owner, connection) 
     1346            yield Comment("{0}.{1}".format(self.name, rec.column_name), self.owner, connection) 
    13471347 
    13481348    def iterconstraints(self, connection=None): 
     
    13951395    def fixname(cls, name, code): 
    13961396        code = code.split(None, 6) 
    1397         code = "alter table %s add constraint %s %s" % (code[2], name, code[6]) 
     1397        code = u"alter table {0} add constraint {1} {2}".format(code[2], name, code[6]) 
    13981398        return code 
    13991399 
     
    14041404    """ 
    14051405    type = u"pk" 
     1406 
     1407    def itercolumns(self, connection=None): 
     1408        """ 
     1409        Return an iterator over the columns this primary key consists of. 
     1410        """ 
     1411        (connection, cursor) = self.getcursor(connection) 
     1412        cursor.execute("select decode(owner, user, null, owner) as owner, constraint_name, table_name, r_owner, r_constraint_name from all_constraints where constraint_type='P' and owner=nvl(:owner, user) and constraint_name=:name", owner=self.owner, name=self.name) 
     1413        rec2 = cursor.fetchone() 
     1414        if rec2 is None: 
     1415            raise SQLObjectNotFoundError(self) 
     1416        tablename = getfullname(rec2.table_name, rec2.owner) 
     1417        cursor.execute("select column_name from all_cons_columns where owner=nvl(:owner, user) and constraint_name=:name", owner=self.owner, name=self.name) 
     1418        for r in cursor: 
     1419            yield Column(u"{0}.{1}".format(tablename, r.column_name)) 
    14061420 
    14071421    def createddl(self, connection=None, term=True): 
     
    14141428        tablename = getfullname(rec2.table_name, rec2.owner) 
    14151429        pkname = getfullname(self.name, None) 
    1416         code = "alter table %s add constraint %s primary key(%s)" % (tablename, pkname, ", ".join(r.column_name for r in cursor)) 
    1417         if term: 
    1418             code += ";\n" 
    1419         else: 
    1420             code += "\n" 
     1430        code = u"alter table {0} add constraint {1} primary key({2})".format(tablename, pkname, ", ".join(r.column_name for r in cursor)) 
     1431        if term: 
     1432            code += u";\n" 
     1433        else: 
     1434            code += u"\n" 
    14211435        return code 
    14221436 
     
    14271441        tablename = getfullname(rec.table_name, rec.owner) 
    14281442        pkname = getfullname(self.name, None) 
    1429         code = "alter table %s drop constraint %s" % (tablename, pkname) 
    1430         if term: 
    1431             code += ";\n" 
    1432         else: 
    1433             code += "\n" 
     1443        code = u"alter table {0} drop constraint {1}".format(tablename, pkname) 
     1444        if term: 
     1445            code += u";\n" 
     1446        else: 
     1447            code += u"\n" 
    14341448        return code 
    14351449 
     
    14991513        name = self.getfullname() 
    15001514        if row.comments: 
    1501             code = "comment on column %s is %s" % (name, formatstring(row.comments, latin1=True)) 
    1502         else: 
    1503             code = "comment on column %s is ''" % name 
    1504         if term: 
    1505             code += ";\n" 
    1506         else: 
    1507             code += "\n" 
     1515            code = u"comment on column {0} is {1}".format(name, formatstring(row.comments, latin1=True)) 
     1516        else: 
     1517            code = u"comment on column {0} is ''".format(name) 
     1518        if term: 
     1519            code += u";\n" 
     1520        else: 
     1521            code += u"\n" 
    15081522        return code 
    15091523 
     
    15151529    def fixname(cls, name, code): 
    15161530        code = code.split(None, 5) 
    1517         code = "comment on column %s is %s" % (name, code[5]) 
     1531        code = u"comment on column {0} is {1}".format(name, code[5]) 
    15181532        return code 
    15191533 
     
    15491563        fields1 = ", ".join(r.column_name for r in cursor) 
    15501564        cursor.execute("select table_name, column_name from all_cons_columns where owner=nvl(:owner, user) and constraint_name=:name order by position", owner=rec.r_owner, name=rec.r_constraint_name) 
    1551         fields2 = ", ".join("%s(%s)" % (getfullname(r.table_name, rec.r_owner), r.column_name) for r in cursor) 
     1565        fields2 = ", ".join("{0}({1})".format(getfullname(r.table_name, rec.r_owner), r.column_name) for r in cursor) 
    15521566        tablename = getfullname(rec.table_name, self.owner) 
    15531567        fkname = getfullname(self.name, None) 
    1554         code = "alter table %s add constraint %s foreign key (%s) references %s" % (tablename, fkname, fields1, fields2) 
    1555         if term: 
    1556             code += ";\n" 
    1557         else: 
    1558             code += "\n" 
     1568        code = u"alter table {0} add constraint {1} foreign key ({2}) references {3}".format(tablename, fkname, fields1, fields2) 
     1569        if term: 
     1570            code += u";\n" 
     1571        else: 
     1572            code += u"\n" 
    15591573        return code 
    15601574 
     
    15671581        tablename = getfullname(rec.table_name, self.owner) 
    15681582        fkname = getfullname(self.name, None) 
    1569         code = "alter table %s %s constraint %s" % (tablename, cmd, fkname) 
    1570         if term: 
    1571             code += ";\n" 
    1572         else: 
    1573             code += "\n" 
     1583        code = u"alter table {0} {1} constraint {2}".format(tablename, cmd, fkname) 
     1584        if term: 
     1585            code += u";\n" 
     1586        else: 
     1587            code += u"\n" 
    15741588        return code 
    15751589 
     
    16601674        indexname = self.getfullname() 
    16611675        if rec.uniqueness == "UNIQUE": 
    1662             unique = " unique" 
    1663         else: 
    1664             unique = "" 
     1676            unique = u" unique" 
     1677        else: 
     1678            unique = u"" 
    16651679        cursor.execute("select aie.column_expression, aic.column_name from all_ind_columns aic, all_ind_expressions aie where aic.table_owner=aie.table_owner(+) and aic.index_name=aie.index_name(+) and aic.column_position=aie.column_position(+) and aic.table_owner=nvl(:owner, user) and aic.index_name=:name order by aic.column_position", owner=self.owner, name=self.name) 
    1666         code = "create%s index %s on %s (%s)" % (unique, indexname, tablename, ", ".join(r.column_expression or r.column_name for r in cursor)) 
    1667         if term: 
    1668             code += ";\n" 
    1669         else: 
    1670             code += "\n" 
     1680        code = u"create{0} index {1} on {2} ({3})".format(unique, indexname, tablename, ", ".join(r.column_expression or r.column_name for r in cursor)) 
     1681        if term: 
     1682            code += u";\n" 
     1683        else: 
     1684            code += u"\n" 
    16711685        return code 
    16721686 
    16731687    def dropddl(self, connection=None, term=True): 
    16741688        if self.isconstraint(connection): 
    1675             return "" 
    1676         code = "drop index %s" % getfullname(self.name, self.owner) 
    1677         if term: 
    1678             code += ";\n" 
    1679         else: 
    1680             code += "\n" 
     1689            return u"" 
     1690        code = u"drop index {0}".format(getfullname(self.name, self.owner)) 
     1691        if term: 
     1692            code += u";\n" 
     1693        else: 
     1694            code += u"\n" 
    16811695        return code 
    16821696 
     
    16851699        if code.lower().startswith("create unique"): 
    16861700            code = code.split(None, 5) 
    1687             code = "create unique index %s %s" % (name, code[5]) 
     1701            code = u"create unique index {0} {1}".format(name, code[5]) 
    16881702        else: 
    16891703            code = code.split(None, 4) 
    1690             code = "create index %s %s" % (name, code[4]) 
     1704            code = u"create index {0} {1}".format(name, code[4]) 
    16911705        return code 
    16921706 
     
    17511765        uniquename = getfullname(self.name, None) 
    17521766        cursor.execute("select column_name from all_cons_columns where owner=nvl(:owner, user) and constraint_name=:name", owner=self.owner, name=self.name) 
    1753         code = "alter table %s add constraint %s unique(%s)" % (tablename, uniquename, ", ".join(r.column_name for r in cursor)) 
    1754         if term: 
    1755             code += ";\n" 
    1756         else: 
    1757             code += "\n" 
     1767        code = u"alter table {0} add constraint {1} unique({2})".format(tablename, uniquename, ", ".join(r.column_name for r in cursor)) 
     1768        if term: 
     1769            code += u";\n" 
     1770        else: 
     1771            code += u"\n" 
    17581772        return code 
    17591773 
     
    17661780        tablename = getfullname(rec.table_name, self.owner) 
    17671781        uniquename = getfullname(self.name, None) 
    1768         code = "alter table %s drop constraint %s" % (tablename, uniquename) 
    1769         if term: 
    1770             code += ";\n" 
    1771         else: 
    1772             code += "\n" 
     1782        code = u"alter table {0} drop constraint {1}".format(tablename, uniquename) 
     1783        if term: 
     1784            code += u";\n" 
     1785        else: 
     1786            code += u"\n" 
    17731787        return code 
    17741788 
     
    18421856        name = getfullname(self.name, owner) 
    18431857        name2 = getfullname(rec.table_name, rec.table_owner) 
    1844         code = "create or replace %ssynonym %s for %s" % (public, name, name2) 
     1858        code = u"create or replace {0}synonym {1} for {2}".format(public, name, name2) 
    18451859        if rec.db_link is not None: 
    1846             code += "@%s" % rec.db_link 
    1847         if term: 
    1848             code += ";\n" 
    1849         else: 
    1850             code += "\n" 
     1860            code += u"@{0}".format(rec.db_link) 
     1861        if term: 
     1862            code += u";\n" 
     1863        else: 
     1864            code += u"\n" 
    18511865        return code 
    18521866 
     
    18591873            public = "" 
    18601874        name = getfullname(self.name, owner) 
    1861         code = "drop %ssynonym %s" % (public, name) 
    1862         if term: 
    1863             code += ";\n" 
    1864         else: 
    1865             code += "\n" 
     1875        code = u"drop {0}synonym {1}".format(public, name) 
     1876        if term: 
     1877            code += u";\n" 
     1878        else: 
     1879            code += u"\n" 
    18661880        return code 
    18671881 
     
    18701884        if code.lower().startswith("create or replace public"): 
    18711885            code = code.split(None, 6) 
    1872             code = "create or replace public synonym %s %s" % (name, code[6]) 
     1886            code = u"create or replace public synonym {0} {1}".format(name, code[6]) 
    18731887        else: 
    18741888            code = code.split(None, 5) 
    1875             code = "create or replace synonym %s %s" % (name, code[5]) 
     1889            code = u"create or replace synonym {0} {1}".format(name, code[5]) 
    18761890        return code 
    18771891 
     
    19111925        if rec is None: 
    19121926            raise SQLObjectNotFoundError(self) 
    1913         code = "\n".join(line.rstrip() for line in rec.text.strip().splitlines()) # Strip trailing whitespace 
    1914         code = "create or replace force view %s as\n\t%s" % (self.getfullname(), code) 
    1915         if term: 
    1916             code += "\n/\n" 
    1917         else: 
    1918             code += "\n" 
     1927        code = u"\n".join(line.rstrip() for line in rec.text.strip().splitlines()) # Strip trailing whitespace 
     1928        code = u"create or replace force view {0} as\n\t{1}".format(self.getfullname(), code) 
     1929        if term: 
     1930            code += u"\n/\n" 
     1931        else: 
     1932            code += u"\n" 
    19191933        return code 
    19201934 
    19211935    def dropddl(self, connection=None, term=True): 
    1922         code = "drop view %s" % self.getfullname() 
    1923         if term: 
    1924             code += ";\n" 
    1925         else: 
    1926             code += "\n" 
     1936        code = u"drop view {0}".format(self.getfullname()) 
     1937        if term: 
     1938            code += u";\n" 
     1939        else: 
     1940            code += u"\n" 
    19271941        return code 
    19281942 
     
    19301944    def fixname(cls, name, code): 
    19311945        code = code.split(None, 6) 
    1932         code = "create or replace force view %s %s" % (name, code[6]) 
     1946        code = u"create or replace force view {0} {1}".format(name, code[6]) 
    19331947        return code 
    19341948 
    19351949    def iterrecords(self, connection=None): 
    19361950        (connection, cursor) = self.getcursor(connection) 
    1937         query = "select * from %s" % self.getfullname() 
     1951        query = "select * from {0}".format(self.getfullname()) 
    19381952        cursor.execute(query) 
    19391953        return iter(cursor) 
     
    19521966        if rec is None: 
    19531967            raise SQLObjectNotFoundError(self) 
    1954         code = "\n".join(line.rstrip() for line in rec.query.strip().splitlines()) # Strip trailing whitespace 
    1955         code = "create materialized view %s\nrefresh %s on %s as\n\t%s" % (self.getfullname(), rec.refresh_method, rec.refresh_mode, code) 
    1956         if term: 
    1957             code += "\n/\n" 
    1958         else: 
    1959             code += "\n" 
     1968        code = u"\n".join(line.rstrip() for line in rec.query.strip().splitlines()) # Strip trailing whitespace 
     1969        code = u"create materialized view {0}\nrefresh {1} on {2} as\n\t{3}".format(self.getfullname(), rec.refresh_method, rec.refresh_mode, code) 
     1970        if term: 
     1971            code += u"\n/\n" 
     1972        else: 
     1973            code += u"\n" 
    19601974        return code 
    19611975 
    19621976    def dropddl(self, connection=None, term=True): 
    1963         code = "drop materialized view %s" % self.getfullname() 
    1964         if term: 
    1965             code += ";\n" 
    1966         else: 
    1967             code += "\n" 
     1977        code = u"drop materialized view {0}".format(self.getfullname()) 
     1978        if term: 
     1979            code += u";\n" 
     1980        else: 
     1981            code += u"\n" 
    19681982        return code 
    19691983 
     
    19711985    def fixname(cls, name, code): 
    19721986        code = code.split(None, 4) 
    1973         code = "create materialized view %s %s" % (name, code[4]) 
     1987        code = u"create materialized view {0} {1}".format(name, code[4]) 
    19741988        return code 
    19751989 
     
    19972011        if rec is None: 
    19982012            raise SQLObjectNotFoundError(self) 
    1999         return "create or replace library %s as %r" % (self.getfullname(), rec.file_spec) 
     2013        return "create or replace library {0} as {1!r}".format(self.getfullname(), rec.file_spec) 
    20002014        if term: 
    20012015            code += ";\n" 
     
    20052019 
    20062020    def dropddl(self, connection=None, term=True): 
    2007         code = "drop library %s" % self.getfullname() 
    2008         if term: 
    2009             code += ";\n" 
    2010         else: 
    2011             code += "\n" 
     2021        code = u"drop library {0}".format(self.getfullname()) 
     2022        if term: 
     2023            code += u";\n" 
     2024        else: 
     2025            code += u"\n" 
    20122026        return code 
    20132027 
     
    20152029    def fixname(cls, name, code): 
    20162030        code = code.split(None, 5) 
    2017         code = "create or replace library %s %s" % (name, code[5]) 
     2031        code = u"create or replace library {0} {1}".format(name, code[5]) 
    20182032        return code 
    20192033 
     
    20322046 
    20332047    def __repr__(self): 
    2034         return "<%s.%s name=%r position=%r datatype=%r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.name, self.position, self.datatype, id(self)) 
     2048        return "<{0}.{1} name={2!r} position={3!r} datatype={4!r} at {5:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.name, self.position, self.datatype, id(self)) 
    20352049 
    20362050    def __xattrs__(self, mode="default"): 
     
    20902104 
    20912105        if len(args) > len(self._argsbypos): 
    2092             raise TypeError("too many parameters for %r: %d given, %d expected" % (self, len(args), len(self._argsbypos))) 
     2106            raise TypeError("too many parameters for {0!r}: {1} given, {2} expected".format(self, len(args), len(self._argsbypos))) 
    20932107 
    20942108        # Handle positional arguments 
     
    21002114            argname = argname.lower() 
    21012115            if argname in queryargs: 
    2102                 raise TypeError("duplicate argument for %r: %s" % (self, argname)) 
     2116                raise TypeError("duplicate argument for {0!r}: {1}".format(self, argname)) 
    21032117            try: 
    21042118                arginfo = self._argsbyname[argname] 
    21052119            except KeyError: 
    2106                 raise TypeError("unknown parameter for %r: %s" % (self, argname)) 
     2120                raise TypeError("unknown parameter for {0!r}: {1}".format(self, argname)) 
    21072121            queryargs[arginfo.name] = self._wraparg(cursor, arginfo, arg) 
    21082122 
     
    21212135                t = type(arg) 
    21222136        except KeyError: 
    2123             raise TypeError("can't handle parameter %s of type %s with value %r in %r" % (arginfo.name, arginfo.datatype, arg, self)) 
     2137            raise TypeError("can't handle parameter {0} of type {1} with value {2!r} in {3!r}".format(arginfo.name, arginfo.datatype, arg, self)) 
    21242138        if isinstance(arg, str) and len(arg) >= 4000: 
    21252139            t = BLOB 
     
    21832197            name = self.name 
    21842198        else: 
    2185             name = "%s.%s" % (self.owner, self.name) 
     2199            name = "{0}.{1}".format(self.owner, self.name) 
    21862200 
    21872201        queryargs = self._getargs(cursor, *args, **kwargs) 
    21882202 
    2189         query = "begin %s(%s); end;" % (name, ", ".join("%s=>:%s" % (name, name) for name in queryargs)) 
     2203        query = "begin {0}({1}); end;".format(name, ", ".join("{0}=>:{0}".format(name) for name in queryargs)) 
    21902204 
    21912205        cursor.execute(query, queryargs) 
     
    22142228            name = self.name 
    22152229        else: 
    2216             name = "%s.%s" % (self.owner, self.name) 
     2230            name = "{0}.{1}".format(self.owner, self.name) 
    22172231 
    22182232        queryargs = self._getargs(cursor, *args, **kwargs) 
     
    22232237        queryargs[returnvalue] = self._wraparg(cursor, self._returnvalue, None) 
    22242238 
    2225         query = "begin :%s := %s(%s); end;" % (returnvalue, name, ", ".join("%s=>:%s" % (name, name) for name in queryargs if name != returnvalue)) 
     2239        query = "begin :{0} := {1}({2}); end;".format(returnvalue, name, ", ".join("{0}=>:{0}".format(name) for name in queryargs if name != returnvalue)) 
    22262240 
    22272241        cursor.execute(query, queryargs) 
     
    22692283        (connection, cursor) = self.getcursor(connection) 
    22702284        cursor.execute("select text from all_source where type='JAVA SOURCE' and owner=nvl(:owner, user) and name=:name order by line", owner=self.owner, name=self.name) 
    2271         code = "\n".join((rec.text or "").rstrip() for rec in cursor) 
     2285        code = u"\n".join((rec.text or u"").rstrip() for rec in cursor) 
    22722286        code = code.strip() 
    22732287 
    2274         code = "create or replace and compile java source named %s as\n%s\n" % (self.getfullname(), code) 
    2275         if term: 
    2276             code += "/\n" 
     2288        code = u"create or replace and compile java source named {0} as\n{1}\n".format(self.getfullname(), code) 
     2289        if term: 
     2290            code += u"/\n" 
    22772291        return code 
    22782292 
    22792293    def dropddl(self, connection=None, term=True): 
    2280         code = "drop java source %s" % self.getfullname() 
    2281         if term: 
    2282             code += ";\n" 
    2283         else: 
    2284             code += "\n" 
     2294        code = u"drop java source {0}".format(self.getfullname()) 
     2295        if term: 
     2296            code += u";\n" 
     2297        else: 
     2298            code += u"\n" 
    22852299        return code 
    22862300 
     
    22882302    def fixname(cls, name, code): 
    22892303        code = code.split(None, 9) 
    2290         code = "create or replace and compile java source named %s %s" % (name, code[9]) 
     2304        code = u"create or replace and compile java source named {0} {1}".format(name, code[9]) 
    22912305        return code 
    22922306 
     
    23082322    def __repr__(self): 
    23092323        if self.owner is not None: 
    2310             return "%s.%s(%r, %r, %r, %r)" % (self.__class__.__module__, self.__class__.__name__, self.privilege, self.name, self.grantee, self.owner) 
    2311         else: 
    2312             return "%s.%s(%r, %r, %r)" % (self.__class__.__module__, self.__class__.__name__, self.privilege, self.name, self.grantee) 
     2324            return "{0}.{1}({2!r}, {3!r}, {4!r}, {5!r})".format(self.__class__.__module__, self.__class__.__name__, self.privilege, self.name, self.grantee, self.owner) 
     2325        else: 
     2326            return "{0}.{1}({2!r}, {3!r}, {4!r})".format(self.__class__.__module__, self.__class__.__name__, self.privilege, self.name, self.grantee) 
    23132327 
    23142328    def __str__(self): 
    23152329        if self.owner is not None: 
    2316             return "%s(%r, %r, %r, %r)" % (self.__class__.__name__, self.privilege, self.name, self.grantee, self.owner) 
    2317         else: 
    2318             return "%s(%r, %r, %r)" % (self.__class__.__name__, self.privilege, self.name, self.grantee) 
     2330            return "{0}({1!r}, {2!r}, {3!r}, {4!r})".format(self.__class__.__name__, self.privilege, self.name, self.grantee, self.owner) 
     2331        else: 
     2332            return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.privilege, self.name, self.grantee) 
    23192333 
    23202334    def getconnection(self, connection): 
     
    23832397        if grantee is None: 
    23842398            return "" 
    2385         code = "grant %s on %s to %s" % (self.privilege, self.name, grantee) 
    2386         if term: 
    2387             code += ";\n" 
     2399        code = u"grant {0} on {1} to {2}".format(self.privilege, self.name, grantee) 
     2400        if term: 
     2401            code += u";\n" 
    23882402        return code 
    23892403 
     
    24182432        rec = self._getcolumnrecord(cursor) 
    24192433        name = self.name.split(".") 
    2420         code = ["alter table %s add %s" % (getfullname(name[0], self.owner), getfullname(name[1], None))] 
    2421         code.append(" %s" % _columntype(rec)) 
     2434        code = [u"alter table {0} add {1}".format(getfullname(name[0], self.owner), getfullname(name[1], None))] 
     2435        code.append(" {0}".format(_columntype(rec))) 
    24222436        default = _columndefault(rec) 
    24232437        if default != "null": 
    2424             code.append(" default %s" % default) 
     2438            code.append(u" default {0}".format(default)) 
    24252439        if rec.nullable == "N": 
    2426             code.append(" not null") 
    2427         if term: 
    2428             code.append(";\n") 
    2429         else: 
    2430             code.append("\n") 
     2440            code.append(u" not null") 
     2441        if term: 
     2442            code.append(u";\n") 
     2443        else: 
     2444            code.append(u"\n") 
    24312445        return "".join(code) 
    24322446 
     
    24402454        name = self.name.split(".") 
    24412455 
    2442         code = ["alter table %s modify %s" % (getfullname(name[0], self.owner), getfullname(name[1], None))] 
     2456        code = [u"alter table {0} modify {1}".format(getfullname(name[0], self.owner), getfullname(name[1], None))] 
    24432457        # Has the type changed? 
    24442458        if recold.data_precision != recnew.data_precision or recold.data_length != recnew.data_length or recold.data_scale != recnew.data_scale or recold.char_length != recnew.char_length or recold.data_type != recnew.data_type or recold.data_type_owner != recnew.data_type_owner: 
     
    24572471                except ValueError: 
    24582472                    char_length = None 
    2459                 code.append(" %s" % _columntype(rec, data_precision=data_precision, data_scale=data_scale, char_length=char_length)) 
     2473                code.append(u" {0}".format(_columntype(rec, data_precision=data_precision, data_scale=data_scale, char_length=char_length))) 
    24602474            else: # The type has changed too 
    24612475                if recnew.data_type != rec.data_type or recnew.data_type_owner != rec.data_type_owner: 
     
    24672481                elif recnew.char_length != rec.char_length: 
    24682482                    raise ConflictError(self, "char_length unmergeable") 
    2469                 code.append(" %s" % _columntype(recnew)) 
     2483                code.append(u" {0}".format(_columntype(recnew))) 
    24702484 
    24712485        # Has the default changed? 
     
    24762490            if newdefault != default: 
    24772491                raise ConflictError(self, "default value unmergable") 
    2478             code.append(" default %s" % newdefault) 
     2492            code.append(u" default {0}".format(newdefault)) 
    24792493 
    24802494        # Check nullability 
    24812495        if recold.nullable != recnew.nullable: 
    24822496            if recnew.nullable == "N": 
    2483                 code.append(" not null") 
     2497                code.append(u" not null") 
    24842498            else: 
    2485                 code.append(" null") 
    2486  
    2487         if term: 
    2488             code.append(";\n") 
    2489         else: 
    2490             code.append("\n") 
     2499                code.append(u" null") 
     2500 
     2501        if term: 
     2502            code.append(u";\n") 
     2503        else: 
     2504            code.append(u"\n") 
    24912505 
    24922506        return "".join(code) 
     
    24952509        (connection, cursor) = self.getcursor(connection) 
    24962510        name = self.name.split(".") 
    2497         code = "alter table %s drop column %s" % (getfullname(name[0], self.owner), getfullname(name[1], None)) 
    2498         if term: 
    2499             code += ";\n" 
    2500         else: 
    2501             code += "\n" 
     2511        code = u"alter table {0} drop column {1}".format(getfullname(name[0], self.owner), getfullname(name[1], None)) 
     2512        if term: 
     2513            code += u";\n" 
     2514        else: 
     2515            code += u"\n" 
    25022516        return code 
    25032517 
     
    25962610    def _isroot(self, url): 
    25972611        path = url.path 
    2598         return len(path) == 0 or (len(path) == 1 and not path[0][0]) 
     2612        return len(path) == 0 or (len(path) == 1 and not path[0]) 
    25992613         
    26002614    def _istype(self, url): 
    26012615        path = url.path 
    2602         return len(path) == 1 or (len(path) == 2 and not path[1][0]) 
     2616        return len(path) == 1 or (len(path) == 2 and not path[1]) 
    26032617         
    26042618    def isdir(self, url): 
     
    26112625        if self.isdir(url): 
    26122626            return "application/octet-stream" 
    2613         return "text/x-oracle-%s" % url.path[0][0] 
     2627        return "text/x-oracle-{0}".format(url.path[0]) 
    26142628 
    26152629    def owner(self, url): 
     
    26212635        if self.isdir(url): 
    26222636            return bigbang 
    2623         type = url.path[0][0] 
    2624         name = url.path[1][0] 
     2637        type = url.path[0] 
     2638        name = url.path[1] 
    26252639        # FIXME: This isn't the correct time zone, but Oracle doesn't provide anything better 
    26262640        c = self.dbconnection.cursor() 
     
    26282642        row = c.fetchone() 
    26292643        if row is None: 
    2630             raise IOError(errno.ENOENT, "no such %s: %s" % (type, name)) 
     2644            raise IOError(errno.ENOENT, "no such {0}: {1}".format(type, name)) 
    26312645        return row[0]-datetime.timedelta(seconds=60*(row[1]*60+row[2])) 
    26322646 
     
    26342648        if self.isdir(url): 
    26352649            return bigbang 
    2636         type = url.path[0][0] 
    2637         name = url.path[1][0] 
     2650        type = url.path[0] 
     2651        name = url.path[1] 
    26382652        # FIXME: This isn't the correct time zone, but Oracle doesn't provide anything better 
    26392653        c = self.dbconnection.cursor() 
     
    26412655        row = c.fetchone() 
    26422656        if row is None: 
    2643             raise IOError(errno.ENOENT, "no such %s: %s" % (type, name)) 
     2657            raise IOError(errno.ENOENT, "no such {0}: {1}".format(type, name)) 
    26442658        return row[0]-datetime.timedelta(seconds=60*(row[1]*60+row[2])) 
    26452659 
     
    26592673                names = (name[0] for name in Object.name2type[type].iternames(self.dbconnection, "user") if name[1] is None) 
    26602674                if len(path) == 1: 
    2661                     result = [url_.URL("%s/%s" % (type, name)) for name in names] 
     2675                    result = [url_.URL("{0}/{1}".format(type, name)) for name in names] 
    26622676                else: 
    26632677                    result = [url_.URL(name) for name in names] 
    26642678        else: 
    2665             raise IOError(errno.ENOTDIR, "Not a directory: %s" % (url,)) 
     2679            raise IOError(errno.ENOTDIR, "Not a directory: {0}".format(url)) 
    26662680        if pattern is not None: 
    26672681            pattern = pattern.lower() 
     
    26792693 
    26802694    def __repr__(self): 
    2681         return "<%s.%s to %r at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.connection.connectstring(), id(self)) 
     2695        return "<{0}.{1} to {2!r} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.connection.connectstring(), id(self)) 
    26822696 
    26832697 
     
    26942708        self.name = str(self.url) 
    26952709 
    2696         type = url.path[0][0] 
     2710        type = url.path[0] 
    26972711        if type not in Object.name2type: 
    2698             raise ValueError("don't know how to handle %r" % url) 
     2712            raise ValueError("don't know how to handle {0!r}".format(url)) 
    26992713        if "w" in self.mode: 
    27002714            self.stream = cStringIO.StringIO() 
    27012715        else: 
    2702             name = url.path[1][0] 
     2716            name = url.path[1] 
    27032717            code = Object.name2type[type](name.upper()).createddl(self.connection.dbconnection, term=False) 
    27042718            self.stream = cStringIO.StringIO(code.encode("utf-8")) 
     
    27272741            if "w" in self.mode: 
    27282742                c = self.connection.dbconnection.cursor() 
    2729                 type = Object.name2type[self.url.path[0][0]] 
    2730                 name = self.url.path[1][0] 
     2743                type = Object.name2type[self.url.path[0]] 
     2744                name = self.url.path[1] 
    27312745                code = self.stream.getvalue().decode("utf-8") 
    27322746                code = type.fixname(name, code) 
     
    27502764            userinfo = url.userinfo.split(":") 
    27512765            if len(userinfo) != 2: 
    2752                 raise ValueError("illegal userinfo %r" % url.userinfo) 
    2753             connection = connections[server] = OracleConnection(context, "%s/%s@%s" % (userinfo[0], userinfo[1], url.host)) 
     2766                raise ValueError("illegal userinfo {0!r}".format(url.userinfo)) 
     2767            connection = connections[server] = OracleConnection(context, "{0}/{1}@{2}".format(userinfo[0], userinfo[1], url.host)) 
    27542768        return (connection, kwargs) 
    27552769 
  • src/ll/orasql/scripts/oracreate.py

    r3930 r3933  
    2525    p = optparse.OptionParser(usage="usage: %prog [options] connectstring >output.sql") 
    2626    p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    27     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
     27    p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    2828    p.add_option("-s", "--seqcopy", dest="seqcopy", help="copy sequence values?", default=False, action="store_true") 
    2929    p.add_option("-x", "--execute", metavar="CONNECTSTRING2", dest="execute", help="Execute in target database", type="str") 
     
    7575        if options.verbose: 
    7676            if options.execute: 
    77                 msg = astyle.style_default("oracreate.py: ", cs1, " -> ", cs2, ": fetching/creating #%d" % (i+1)) 
     77                msg = astyle.style_default("oracreate.py: ", cs1, " -> ", cs2, ": fetching/creating #{0}".format(i+1)) 
    7878            else: 
    79                 msg = astyle.style_default("oracreate.py: ", cs1, " fetching #%d" % (i+1)) 
     79                msg = astyle.style_default("oracreate.py: ", cs1, " fetching #{0}".format(i+1)) 
    8080            msg = astyle.style_default(msg, " ", s4object(str(obj))) 
    8181            if not keepobj: 
     
    9595                        if not options.ignore or "ORA-01013" in str(exc): 
    9696                            raise 
    97                         stderr.writeln("oracreate.py: ", s4error("%s: %s" % (exc.__class__.__name__, str(exc).strip()))) 
     97                        stderr.writeln("oracreate.py: ", s4error("{0}: {1}".format(exc.__class__.__name__, str(exc).strip()))) 
    9898                else: 
    9999                    stdout.writeln(ddl.encode(options.encoding)) 
  • src/ll/orasql/scripts/oradelete.py

    r3930 r3933  
    2626    p = optparse.OptionParser(usage="usage: %prog [options] connectstring >output.sql") 
    2727    p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    28     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
     28    p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    2929    p.add_option("-s", "--sequences", dest="sequences", help="Should sequences be reset?", default=False, action="store_true") 
    3030    p.add_option("-x", "--execute", dest="execute", action="store_true", help="immediately execute the commands instead of printing them?") 
     
    5757        if options.verbose: 
    5858            msg = "truncating" if options.truncate else "deleting from" 
    59             msg = astyle.style_default("oradelete.py: ", cs, ": %s #%d " % (msg, i+1), s4object(str(obj))) 
     59            msg = astyle.style_default("oradelete.py: ", cs, ": {0} #{1} ".format(msg, i+1), s4object(str(obj))) 
    6060            stderr.writeln(msg) 
    6161 
     
    6464            try: 
    6565                if options.truncate: 
    66                     cursor.execute(u"truncate table %s" % obj.name) 
     66                    cursor.execute(u"truncate table {0}".format(obj.name)) 
    6767                else: 
    68                     cursor.execute(u"delete from %s" % obj.name) 
     68                    cursor.execute(u"delete from {0}".format(obj.name)) 
    6969            except orasql.DatabaseError, exc: 
    7070                if not options.ignore or "ORA-01013" in str(exc): 
    7171                    raise 
    72                 stderr.writeln("oradelete.py: ", s4error("%s: %s" % (exc.__class__, str(exc).strip()))) 
     72                stderr.writeln("oradelete.py: ", s4error("{0}: {1}".format(exc.__class__, str(exc).strip()))) 
    7373        else: 
    7474            if options.truncate: 
    75                 sql = u"truncate table %s;\n" % obj.name 
     75                sql = u"truncate table {0};\n".format(obj.name) 
    7676            else: 
    77                 sql = u"delete from %s;\n" % obj.name 
     77                sql = u"delete from {1};\n".format(obj.name) 
    7878            stdout.write(sql.encode(options.encoding)) 
    7979    if not options.truncate: 
     
    8484            # Progress report 
    8585            if options.verbose: 
    86                 msg = astyle.style_default("oradelete.py: ", cs, ": recreating #%d " % (i+1), s4object(str(obj))) 
     86                msg = astyle.style_default("oradelete.py: ", cs, ": recreating #{0} ".format(i+1), s4object(str(obj))) 
    8787                stderr.writeln(msg) 
    8888 
     
    9696                    if not options.ignore or "ORA-01013" in str(exc): 
    9797                        raise 
    98                     stderr.writeln("oradelete.py: ", s4error("%s: %s" % (exc.__class__, str(exc).strip()))) 
     98                    stderr.writeln("oradelete.py: ", s4error("{0}: {1}".format(exc.__class__, str(exc).strip()))) 
    9999            else: 
    100100                sql = obj.dropddl(term=True) + obj.createddl(term=True) 
  • src/ll/orasql/scripts/oradiff.py

    r3930 r3933  
    7373            self.compareline = " ".join(line.strip().split()) 
    7474        else: 
    75             raise ValueError("unknown blank value %r" % blank) 
     75            raise ValueError("unknown blank value {0!r}".format(blank)) 
    7676 
    7777    def __eq__(self, other): 
     
    8787def showudiff(out, obj, ddl1, ddl2, connection1, connection2, encoding="utf-8", context=3, timeformat="%c"): 
    8888    def header(prefix, style, connection): 
    89         return style("%s %r in %s: %s" % (prefix, obj, connection.connectstring(), gettimestamp(obj, connection, timeformat))) 
     89        return style("{0} {1!r} in {2}: {3}".format(prefix, obj, connection.connectstring(), gettimestamp(obj, connection, timeformat))) 
    9090 
    9191    started = False 
     
    9696            started = True 
    9797        (i1, i2, j1, j2) = group[0][1], group[-1][2], group[0][3], group[-1][4] 
    98         out.writeln(s4pos("@@ -%d,%d +%d,%d @@" % (i1+1, i2-i1, j1+1, j2-j1))) 
     98        out.writeln(s4pos("@@ -{0},{1} +{2},{3} @@".format(i1+1, i2-i1, j1+1, j2-j1))) 
    9999        for (tag, i1, i2, j1, j2) in group: 
    100100            if tag == "equal": 
    101101                for line in ddl1[i1:i2]: 
    102                     out.writeln((" %s" % line.originalline).encode(encoding)) 
     102                    out.writeln(" {0}".format(line.originalline).encode(encoding)) 
    103103                continue 
    104104            if tag == "replace" or tag == "delete": 
     
    116116    p = optparse.OptionParser(usage="usage: %prog [options] connectstring1 connectstring2") 
    117117    p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    118     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
    119     p.add_option("-m", "--mode", dest="mode", help="Output mode (%s)" % ", ".join(modes), default="udiff", choices=modes) 
     118    p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
     119    p.add_option("-m", "--mode", dest="mode", help="Output mode ({0})".format(", ".join(modes)), default="udiff", choices=modes) 
    120120    p.add_option("-n", "--context", dest="context", help="Number of context lines", type="int", default=2) 
    121121    p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' or 'SYS_EXPORT_SCHEMA_' in their name?", default=False, action="store_true") 
    122     p.add_option("-b", "--blank", dest="blank", help="How to treat whitespace (%s)" % ", ".join(blanks), default="literal", choices=blanks) 
     122    p.add_option("-b", "--blank", dest="blank", help="How to treat whitespace ({0})".format(", ".join(blanks)), default="literal", choices=blanks) 
    123123    p.add_option("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
    124124 
     
    140140    connection2 = orasql.connect(args[1]) 
    141141 
     142    print connection1, connection2 
    142143    def fetch(connection): 
    143144        objects = set() 
     
    155156            keepdef = keep(obj) 
    156157            if options.verbose: 
    157                 msg = astyle.style_default("oradiff.py: ", cs(connection), ": fetching #%d " % (i+1), df(obj)) 
     158                msg = astyle.style_default("oradiff.py: ", cs(connection), ": fetching #{0} ".format(i+1), df(obj)) 
    158159                if not keepdef: 
    159160                    msg = astyle.style_default(msg, " ", s4warning("(skipped)")) 
     
    169170    for (i, obj) in enumerate(onlyin1): 
    170171        if options.verbose: 
    171             stderr.writeln("oradiff.py: only in ", cs(connection1), " #%d/%d " % (i+1, len(onlyin1)), df(obj)) 
     172            stderr.writeln("oradiff.py: only in ", cs(connection1), " #{0}/{1} ".format(i+1, len(onlyin1)), df(obj)) 
    172173        if options.mode == "brief": 
    173174            stdout.writeln(df(obj), ": only in ", cs(connection1)) 
    174175        elif options.mode == "full": 
    175             stdout.writeln(comment(df(obj), ": only in " % cs(connection1))) 
     176            stdout.writeln(comment(df(obj), ": only in ", cs(connection1))) 
    176177            ddl = obj.dropddl(connection1, term=True) 
    177178            if ddl: 
     
    184185    for (i, obj) in enumerate(onlyin2): 
    185186        if options.verbose: 
    186             stderr.writeln("oradiff.py: only in ", cs(connection2), " #%d/%d " % (i+1, len(onlyin2)), df(obj)) 
     187            stderr.writeln("oradiff.py: only in ", cs(connection2), " #{0}/{1} ".format(i+1, len(onlyin2)), df(obj)) 
    187188        if options.mode == "brief": 
    188189            stdout.writeln(df(obj), ": only in ", cs(connection2)) 
     
    199200    for (i, obj) in enumerate(common): 
    200201        if options.verbose: 
    201             stderr.writeln("oradiff.py: diffing #%d/%d " % (i+1, len(common)), df(obj)) 
     202            stderr.writeln("oradiff.py: diffing #{0}/{1} ".format(i+1, len(common)), df(obj)) 
    202203        ddl1 = obj.createddl(connection1) 
    203204        ddl2 = obj.createddl(connection2) 
  • src/ll/orasql/scripts/oradrop.py

    r3930 r3933  
    2626    p = optparse.OptionParser(usage="usage: %prog [options] connectstring >output.sql") 
    2727    p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    28     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
    29     p.add_option("-f", "--fks", dest="fks", help="How should foreign keys from other schemas be treated (%s)?" % ", ".join(fks), default="disable", choices=fks) 
     28    p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
     29    p.add_option("-f", "--fks", dest="fks", help="How should foreign keys from other schemas be treated ({0})?".format(", ".join(fks)), default="disable", choices=fks) 
    3030    p.add_option("-x", "--execute", dest="execute", action="store_true", help="immediately execute the commands instead of printing them?") 
    3131    p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' in their name?", default=False, action="store_true") 
     
    8383        # Progress report 
    8484        if options.verbose: 
    85             msg = astyle.style_default("oradrop.py: ", cs, ": fetching #%d " % (i+1), s4object(str(obj))) 
     85            msg = astyle.style_default("oradrop.py: ", cs, ": fetching #{0} ".format(i+1), s4object(str(obj))) 
    8686            if action is not None: 
    87                 msg = astyle.style_default(msg, " ", s4warning("(%s)" % action)) 
     87                msg = astyle.style_default(msg, " ", s4warning("({0})".format(action))) 
    8888            stderr.writeln(msg) 
    8989 
     
    100100        for (i, (obj, ddl)) in enumerate(ddls): 
    101101            if options.verbose: 
    102                 stderr.writeln("oradrop.py: ", cs, ": dropping #%d/%d " % (i+1, len(ddls)), s4object(str(obj))) 
     102                stderr.writeln("oradrop.py: ", cs, ": dropping #{0}/{1} ".format(i+1, len(ddls)), s4object(str(obj))) 
    103103            try: 
    104104                cursor.execute(ddl) 
     
    106106                if not options.ignore or "ORA-01013" in str(exc): 
    107107                    raise 
    108                 stderr.writeln("oradrop.py: ", s4error("%s: %s" % (exc.__class__, str(exc).strip()))) 
     108                stderr.writeln("oradrop.py: ", s4error("{0}: {1}".format(exc.__class__, str(exc).strip()))) 
    109109 
    110110 
  • src/ll/orasql/scripts/orafind.py

    r3930 r3933  
    4141 
    4242def connid(name): 
    43     return s4connid("[%d]" % name) 
     43    return s4connid("[{0}]".format(name)) 
    4444 
    4545 
     
    6767                cls = s4action 
    6868            if count > 1: 
    69                 msg = "%d %ss %s" % (count, type, name) 
     69                msg = "{0} {1}s {2}".format(count, type, name) 
    7070            else: 
    71                 msg = "1 %s %s" % (type, name) 
     71                msg = "1 {0} {1}".format(type, name) 
    7272            out.write(cls(msg)) 
    7373    if first: 
     
    9292    p = optparse.OptionParser(usage="usage: %prog [options] connectstring searchstring [table] [table] ...") 
    9393    p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    94     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
     94    p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    9595    p.add_option("-i", "--ignore-case", dest="ignorecase", help="Ignore case distinctions?", default=False, action="store_true") 
    9696    p.add_option("-r", "--read-lobs", dest="readlobs", help="Read LOBs when printing records?", default=False, action="store_true") 
     
    115115    if options.ignorecase: 
    116116        searchstring = searchstring.lower() 
    117     searchstring = "%%%s%%" % searchstring.replace("%", "%%") 
     117    searchstring = "%{0}%".format(searchstring.replace("%", "%%")) 
    118118    tablenames = [name.decode(options.encoding).lower() for name in args[2:]] 
    119119 
     
    133133                if datatype == "clob" or datatype.startswith("varchar2"): 
    134134                    if options.ignorecase: 
    135                         where.append("lower(%s) like :searchstring" % col.name) 
     135                        where.append("lower({0}) like :searchstring".format(col.name)) 
    136136                    else: 
    137                         where.append("%s like :searchstring" % col.name) 
     137                        where.append("{0} like :searchstring".format(col.name)) 
    138138            if not where: 
    139139                continue # no string columns 
    140             query = "select * from %s where %s" % (table.name, " or ".join(where)) 
     140            query = "select * from {0} where {1}".format(table.name, " or ".join(where)) 
    141141            c.execute(query, searchstring=searchstring) 
    142142            for r in c: 
  • src/ll/orasql/scripts/oragrant.py

    r3930 r3933  
    2525    p = optparse.OptionParser(usage="usage: %prog [options] connectstring >output.sql") 
    2626    p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    27     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
     27    p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    2828    p.add_option("-x", "--execute", metavar="CONNECTSTRING2", dest="execute", help="Execute in target database", type="str") 
    2929    p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' or 'SYS_EXPORT_SCHEMA_' in their name?", default=False, action="store_true") 
     
    7272        if options.verbose: 
    7373            if options.execute: 
    74                 msg = astyle.style_default("oragrant.py: ", cs1, " -> ", cs2, ": fetching/granting #%d" % (i+1)) 
     74                msg = astyle.style_default("oragrant.py: ", cs1, " -> ", cs2, ": fetching/granting #{0}".format(i+1)) 
    7575            else: 
    76                 msg = astyle.style_default("oragrant.py: ", cs1, " fetching #%d" % (i+1)) 
     76                msg = astyle.style_default("oragrant.py: ", cs1, " fetching #{0}".format(i+1)) 
    7777            msg = astyle.style_default(msg, " ", s4object(str(obj))) 
    7878            if not keepobj: 
     
    8989                        if not options.ignore or "ORA-01013" in str(exc): 
    9090                            raise 
    91                         stderr.writeln("oragrant.py: ", s4error("%s: %s" % (exc.__class__.__name__, str(exc).strip()))) 
     91                        stderr.writeln("oragrant.py: ", s4error("{0}: {1}".format(exc.__class__.__name__, str(exc).strip()))) 
    9292                else: 
    9393                    stdout.writeln(ddl.encode(options.encoding)) 
  • src/ll/orasql/scripts/oramerge.py

    r3930 r3933  
    4141 
    4242def connid(name): 
    43     return s4connid("[%d]" % name) 
     43    return s4connid("[{0}]".format(name)) 
    4444 
    4545 
     
    6767                cls = s4action 
    6868            if count > 1: 
    69                 msg = "%d %ss %s" % (count, type, name) 
    70             else: 
    71                 msg = "1 %s %s" % (type, name) 
     69                msg = "{0} {1}s {2}".format(count, type, name) 
     70            else: 
     71                msg = "1 {0} {1}".format(type, name) 
    7272            out.write(cls(msg)) 
    7373    if first: 
     
    9494    p = optparse.OptionParser(usage="usage: %prog [options] oldsourceconnectstring newsourceconnectstring destinationconnectstring") 
    9595    p.add_option("-v", "--verbose", dest="verbose", help="Give a progress report?", default=False, action="store_true") 
    96     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
     96    p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    9797    p.add_option("-k", "--keepjunk", dest="keepjunk", help="Output objects with '$' in their name?", default=False, action="store_true") 
    9898    p.add_option("-e", "--encoding", dest="encoding", help="Encoding for output", default="utf-8") 
     
    122122            keep = ("$" not in obj.name and not obj.name.startswith("SYS_EXPORT_SCHEMA_")) or options.keepjunk 
    123123            if options.verbose: 
    124                 msg = astyle.style_default("oramerge.py: ", cs(connection), connid(name), " fetching #%d " % (i+1), df(obj)) 
     124                msg = astyle.style_default("oramerge.py: ", cs(connection), connid(name), " fetching #{0} ".format(i+1), df(obj)) 
    125125                if not keep: 
    126126                    msg += s4error(" (skipped)") 
     
    348348                                    stdout.writeln(line) 
    349349                            else: 
    350                                 raise OSError("Trouble from diff3: %d" % diffretcode) 
     350                                raise OSError("Trouble from diff3: {0}".format(diffretcode)) 
    351351                        finally: 
    352352                            os.remove(filename3) 
  • src/ll/scripts/ucp.py

    r3930 r3933  
    7070    p = optparse.OptionParser(usage="usage: %prog [options] source-file-url target-file-url\n   or: %prog [options] source-file-url(s) target-dir-url") 
    7171    p.add_option("-v", "--verbose", dest="verbose", help="Be verbose?", action="store_true", default=False) 
    72     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
     72    p.add_option("-c", "--color", dest="color", help="Color output ({0})".format(", ".join(colors)), default="auto", choices=colors) 
    7373    p.add_option("-u", "--user", dest="user", help="user id or name for target files") 
    7474    p.add_option("-g", "--group", dest="group", help="group id or name for target files") 
  • src/ll/scripts/uls.py

    r3930 r3933  
    136136    def printall(base, url, one, long, recursive, human, spacing): 
    137137        if url.isdir(): 
    138             if url.path.segments[-1][0]: 
    139                 url.path.segments.append(("",)) 
     138            if url.path.segments[-1]: 
     139                url.path.segments.append("") 
    140140            if not long and not one: 
    141141                if recursive: 
     
    158158    colors = ("yes", "no", "auto") 
    159159    p = optparse.OptionParser(usage="usage: %prog [options] [url] [url] ...") 
    160     p.add_option("-c", "--color", dest="color", help="Color output (%s)" % ", ".join(colors), default="auto", choices=colors) 
     160    p.add_option("-c", "--color", dest="color", help="Color output ([{0}])".format(", ".join(colors)), default="auto", choices=colors) 
    161161    p.add_option("-1", "--one", dest="one", help="One entry per line?", action="store_true") 
    162162    p.add_option("-l", "--long", dest="long", help="Long format?", action="store_true") 
  • src/ll/sisyphus.py

    r3930 r3933  
    6565            sisyphus.Job.__init__(self, 180, name="Fetch") 
    6666            self.url = "http://www.python.org/" 
    67             self.tmpname = "Fetch_Tmp_%d.html" % os.getpid() 
     67            self.tmpname = "Fetch_Tmp_{0}.html".format(os.getpid()) 
    6868            self.officialname = "Python.html" 
    6969 
    7070        def execute(self): 
    71             self.logProgress("fetching data from %r" % self.url) 
     71            self.logProgress("fetching data from {0!r}".format(self.url)) 
    7272            data = urllib.urlopen(self.url).read() 
    7373            datasize = len(data) 
    74             self.logProgress("writing file %r (%d bytes)" % (self.tmpname, datasize)) 
     74            self.logProgress("writing file {0!r} ({1} bytes)".format(self.tmpname, datasize)) 
    7575            open(self.tmpname, "wb").write(data) 
    76             self.logProgress("renaming file %r to %r" % (self.tmpname, self.officialname)) 
     76            self.logProgress("renaming file {0!r} to {1!r}".format(self.tmpname, self.officialname)) 
    7777            os.rename(self.tmpname, self.officialname) 
    78             self.logLoop("cached %r as %r (%d bytes)" % (self.url, self.officialname, datasize)) 
     78            self.logLoop("cached {0!r} as {1!r} ({2} bytes)".format(self.url, self.officialname, datasize)) 
    7979 
    8080    if __name__=="__main__": 
     
    106106    (rest, mins) = divmod(rest, 60) 
    107107    rest += timedelta.days*24 
    108     return "%d:%02d:%06.3f" % (rest, mins, secs+timedelta.microseconds/1000000.) 
     108    return "{0:d}:{1:02d}:{2:06.3f}".format(rest, mins, secs+timedelta.microseconds/1000000.) 
    109109 
    110110 
     
    150150        now = datetime.datetime.now() 
    151151        pid = os.getpid() 
    152         prefix = "[pid=%d][%s]=[t+%s]" % (pid, _formattime(now), _formattimedelta(now-self.starttime)) 
     152        prefix = "[pid={0}][{1}]=[t+{2}]".format(pid, _formattime(now), _formattimedelta(now-self.starttime)) 
    153153 
    154154        self.__open() 
    155155        for text in texts: 
    156             if isinstance(text, str): 
    157                 pass 
    158             elif isinstance(text, unicode): 
    159                 text = text.encode(self.encoding, "replace") 
    160             elif isinstance(text, Exception): 
     156            if isinstance(text, Exception): 
    161157                tb = "\n" + "".join(traceback.format_tb(sys.exc_info()[-1])) 
    162                 text = "%s%s: %s" % (tb, text.__class__.__name__, text) 
    163             else: 
     158                text = "{0}{1.__class__.__name__}: {1}".format(tb, text) 
     159            elif not isinstance(text, basestring): 
    164160                text = pprint.pformat(text) 
    165161            lines = text.splitlines() 
     
    167163                del lines[-1] 
    168164            for line in lines: 
    169                 self.file.write("%s %s\n" % (prefix, line)) 
     165                line = "{0} {1}\n".format(prefix, line) 
     166                if isinstance(line, unicode): 
     167                    line = line.encode(self.encoding, "replace") 
     168                self.file.write(line) 
    170169 
    171170 
     
    182181    """ 
    183182 
    184     pidfilenametemplate = "~/run/%s.pid" 
    185     loopfilenametemplate = "~/log/%s_loop.log" 
    186     errorfilenametemplate = "~/log/%s_error.log" 
    187     progressfilenametemplate = "~/log/%s_progress.log" 
     183    pidfilenametemplate = "~/run/{name}.pid" 
     184    loopfilenametemplate = "~/log/{name}_loop.log" 
     185    errorfilenametemplate = "~/log/{name}_error.log" 
     186    progressfilenametemplate = "~/log/{name}_progress.log" 
    188187 
    189188    def __init__(self, maxruntime=0, name=None, raiseerrors=False, printkills=False): 
     
    215214        self.printkills = printkills 
    216215        self.pidfilewritten = False 
    217         self.pidfilename = url.File(self.pidfilenametemplate % self.name) 
    218         self.loopLogfile = LogFile(self.loopfilenametemplate % self.name) 
    219         self.errorLogfile = LogFile(self.errorfilenametemplate % self.name) 
    220         self.progressLogfile = LogFile(self.progressfilenametemplate % self.name, mode="w") 
     216        self.pidfilename = url.File(self.pidfilenametemplate.format(name=self.name)) 
     217        self.loopLogfile = LogFile(self.loopfilenametemplate.format(name=self.name)) 
     218        self.errorLogfile = LogFile(self.errorfilenametemplate.format(name=self.name)) 
     219        self.progressLogfile = LogFile(self.progressfilenametemplate.format(name=self.name), mode="w") 
    221220 
    222221    def __writepid(self): 
     
    303302                file.close() 
    304303                self.__writepid() 
    305                 self.logProgress("ignoring bogus pid file %s (invalid content)" % self.pidfilename) 
     304                self.logProgress("ignoring bogus pid file {0} (invalid content)".format(self.pidfilename)) 
    306305            else: 
    307306                file.close() 
     
    313312                        raise 
    314313                    self.__writepid() 
    315                     msg = "ignoring bogus pid file %s (process with pid %d doesn't exist)" % (self.pidfilename, pid) 
     314                    msg = "ignoring bogus pid file {0} (process with pid {1} doesn't exist)".format(self.pidfilename, pid) 
    316315                    self.logError(msg) 
    317316                else: 
     
    323322                                raise 
    324323                        self.__writepid() 
    325                         msg = "killed previous job running with pid %d (ran %s seconds; %s allowed); here we go" % (pid, _formattimedelta(self.starttime-lastmodified), _formattimedelta(self.maxruntime)) 
     324                        msg = "killed previous job running with pid {0} (ran {1} seconds; {2} allowed); here we go".format(pid, _formattimedelta(self.starttime-lastmodified), _formattimedelta(self.maxruntime)) 
    326325                        self.logError(msg) 
    327326                        if self.printkills: 
    328327                            print msg 
    329328                    else: 
    330                         msg = "Job still running (for %s; %s allowed; started on %s) with pid %d (according to %s)" % (_formattimedelta(self.starttime-lastmodified), _formattimedelta(self.maxruntime), _formattime(lastmodified), pid, self.pidfilename) 
     329                        msg = "Job still running (for {0}; {1} allowed; started on {2}) with pid {3} (according to {4})".format(_formattimedelta(self.starttime-lastmodified), _formattimedelta(self.maxruntime), _formattime(lastmodified), pid, self.pidfilename) 
    331330                        self.logErrorOnly(msg) 
    332331                        return # Return without calling :meth:`execute` 
     
    336335        except (Exception, KeyboardInterrupt), exc: 
    337336            self.logError(exc) # log the error 
    338             self.logLoop("failed with %s(%s)" % (exc.__class__.__name__, exc)) # log the error to the loop log too, because the job probably didn't have a chance to do it. 
     337            self.logLoop("failed with {0.__class__.__name__}({0})".format(exc)) # log the error to the loop log too, because the job probably didn't have a chance to do it. 
    339338            self.failed() 
    340339            if self.raiseerrors or isinstance(exc, KeyboardInterrupt): # Really exit 
  • src/ll/spark.py

    r3485 r3893  
    8282 
    8383    def error(self, s, pos): 
    84         print "Lexical error at position %s" % pos 
     84        print "Lexical error at position {0}".format(pos) 
    8585        raise SystemExit 
    8686 
     
    263263 
    264264    def error(self, token): 
    265         print "Syntax error at or near `%s' token" % token 
     265        print "Syntax error at or near '{0}' token".format(token) 
    266266        raise SystemExit 
    267267 
  • src/ll/toxicc.py

    r3930 r3933  
    182182            if current: 
    183183                if nchar: 
    184                     yield u"N'%s'" % u"".join(current) 
     184                    yield u"N'{0}'".format(u"".join(current)) 
    185185                else: 
    186                     yield u"'%s'" % u"".join(current) 
     186                    yield u"'{0}'".format(u"".join(current)) 
    187187                current = [] 
    188             yield u"chr(%d)" % ord(c) 
     188            yield u"chr({0})".format(ord(c)) 
    189189        else: 
    190190            if c == u"'": 
     
    193193            if len(current) > 1000: 
    194194                if nchar: 
    195                     yield u"N'%s'" % u"".join(current) 
     195                    yield u"N'{0}'".format(u"".join(current)) 
    196196                else: 
    197                     yield u"'%s'" % u"".join(current) 
     197                    yield u"'{0}'".format(u"".join(current)) 
    198198                current = [] 
    199199    if current: 
    200200        if nchar: 
    201             yield u"N'%s'" % u"".join(current) 
     201            yield u"N'{0}'".format(u"".join(current)) 
    202202        else: 
    203             yield u"'%s'" % u"".join(current) 
     203            yield u"'{0}'".format(u"".join(current)) 
    204204 
    205205 
     
    231231        else: 
    232232            # Treat unknown PIs as text 
    233             foundsql.append((-1, u"<?%s %s?>" % (t, s))) 
     233            foundsql.append((-1, u"<?{0} {1}?>".format(t, s))) 
    234234 
    235235    result = [] 
    236236    if foundargs: 
    237         result.append(u"(\n\t%s\n)\n" % u",\n\t".join(foundargs)) 
     237        result.append(u"(\n\t{0}\n)\n".format(u",\n\t".join(foundargs))) 
    238238    plaintype = foundtype 
    239239    if u"(" in plaintype: 
     
    241241    isclob = plaintype.lower() in ("clob", "nclob") 
    242242    if not foundproc: 
    243         result.append(u"return %s\n" % plaintype) 
     243        result.append(u"return {0}\n".format(plaintype)) 
    244244    result.append(u"as\n") 
    245245    if not foundproc: 
    246         result.append(u"\tc_out %s;\n" % foundtype) 
     246        result.append(u"\tc_out {0};\n".format(foundtype)) 
    247247    if foundvars: 
    248         result.append(u"\t%s\n" % u"".join(foundvars)) 
     248        result.append(u"\t{0}\n".format(u"".join(foundvars))) 
    249249    nchar = foundtype.lower().startswith(u"n") 
    250250    if isclob: 
    251251        for arg in (u"clob", u"varchar2"): 
    252             result.append(u"\tprocedure write(p_text in %s%s)\n" % (plaintype.rstrip(u"clob"), arg)) 
     252            result.append(u"\tprocedure write(p_text in {0}{1})\n".format(plaintype.rstrip(u"clob"), arg)) 
    253253            result.append(u"\tas\n") 
    254254            result.append(u"\t\tbegin\n") 
     
    268268            for s in _stringifyoracle(string, nchar): 
    269269                if isclob: 
    270                     result.append(u"\twrite(%s);\n" % s) 
     270                    result.append(u"\twrite({0});\n".format(s)) 
    271271                else: 
    272                     result.append(u"\tc_out := c_out || %s;\n" % s) 
     272                    result.append(u"\tc_out := c_out || {0};\n".format(s)) 
    273273        elif mode == 0: 
    274274            result.append(string) 
     
    276276        else: # mode == 1 
    277277            if isclob: 
    278                 result.append(u"\twrite(%s);\n" % string) 
     278                result.append(u"\twrite({0});\n".format(string)) 
    279279            else: 
    280                 result.append(u"\tc_out := c_out || %s;\n" % string) 
     280                result.append(u"\tc_out := c_out || {0};\n".format(string)) 
    281281    if not foundproc: 
    282282        result.append(u"\treturn c_out;\n") 
     
    312312        else: 
    313313            # Treat unknown PIs as text 
    314             foundsql.append((-1, "<?%s %s?>" % (t, s))) 
     314            foundsql.append((-1, "<?{0} {1}?>".format(t, s))) 
    315315 
    316316    result = [] 
    317317    if foundargs: 
    318         result.append("(\n\t%s\n)\n" % u",\n\t".join(foundargs)) 
    319     if not foundproc: 
    320         result.append("returns %s\n" % foundtype) 
     318        result.append("(\n\t{0}\n)\n".format(u",\n\t".join(foundargs))) 
     319    if not foundproc: 
     320        result.append("returns {0}\n".format(foundtype)) 
    321321    result.append("as\n") 
    322322    result.append("begin\n") 
    323323    if not foundproc: 
    324         result.append("\tdeclare @c_out %s;\n" % foundtype) 
     324        result.append("\tdeclare @c_out {0};\n".format(foundtype)) 
    325325        result.append("\tset @c_out = '';\n") 
    326326    if foundvars: 
    327         result.append("\t%s\n" % u"".join(foundvars)) 
     327        result.append("\t{0}\n".format(u"".join(foundvars))) 
    328328    for (mode, string) in foundsql: 
    329329        if mode == -1: 
    330             string = "'%s'" % string.replace("'", "''") 
    331             result.append("\tset @c_out = @c_out + %s;\n" % string) 
     330            string = "'{0}'" .format(string.replace("'", "''")) 
     331            result.append("\tset @c_out = @c_out + {0};\n".format(string)) 
    332332        elif mode == 0: 
    333333            result.append(string) 
    334334            result.append("\n") 
    335335        else: # mode == 1 
    336             result.append("\tset @c_out = @c_out + set @c_out = @c_out + convert(varchar, isnull(%s, ''));\n" % string) 
     336            result.append("\tset @c_out = @c_out + set @c_out = @c_out + convert(varchar, isnull({0}, ''));\n".format(string)) 
    337337    if not foundproc: 
    338338        result.append("\treturn @c_out;\n") 
     
    352352    elif mode == "sqlserver": 
    353353        return _compile_sqlserver(string) 
    354     raise ValueError("unknown mode %r" % mode) 
     354    raise ValueError("unknown mode {0!r}".format(mode)) 
    355355 
    356356 
     
    390390        } 
    391391    else: 
    392         raise ValueError("unknown mode %r" % mode) 
     392        raise ValueError("unknown mode {0!r}".format(mode)) 
    393393    indent = 0 
    394394    firstafteras = False 
     
    405405                pre = -1 
    406406            indent = max(0, indent+pre) 
    407             newlines.append("%s%s" % ("\t"*indent, line)) 
     407            newlines.append("{0}{1}".format("\t"*indent, line)) 
    408408            indent = max(0, indent+post) 
    409409            if prefix == "as": 
  • src/ll/ul4c.py

    r3930 r3933  
    8484 
    8585    def __repr__(self): 
    86         return "<%s.%s %s at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self, id(self)) 
     86        return "<{0}.{1} {2} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self, id(self)) 
    8787 
    8888    def pos(self): 
     
    9595    def __str__(self): 
    9696        (line, col) = self.pos() 
    97         return "%r at %d (line %d, col %d)" % (self.tag, self.starttag+1, line, col) 
     97        return "{0!r} at {1} (line {2}, col {3})".format(self.tag, self.starttag+1, line, col) 
    9898 
    9999 
     
    111111 
    112112    def __repr__(self): 
    113         return "<%s.%s in %s at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, self.location, id(self)) 
     113        return "<{0}.{1} in {2} at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, self.location, id(self)) 
    114114 
    115115    def __str__(self): 
     
    124124        module = exc.__class__.__module__ 
    125125        if module != "exceptions": 
    126             name = "%s.%s" % (module, name) 
    127         return "%s %s %s" % (name, " ".join("in %s:" % location for location in path), exc) 
     126            name = "{0}.{1}".format(module, name) 
     127        return "{0} {1} {2}".format(name, " ".join("in {0}:".format(location) for location in path), exc) 
    128128 
    129129 
     
    135135 
    136136    def __str__(self): 
    137         return "Unmatched input %r" % self.input 
     137        return "Unmatched input {0!r}".format(self.input) 
    138138 
    139139 
     
    143143 
    144144    def __str__(self): 
    145         return "Lexical error near %r" % str(self.token) 
     145        return "Lexical error near {0!r}".format(str(self.token)) 
    146146 
    147147 
     
    179179 
    180180    def __str__(self): 
    181         return "function %r unknown" % self.funcname 
     181        return "function {0!r} unknown".format(self.funcname) 
    182182 
    183183 
     
    193193 
    194194    def __str__(self): 
    195         return "method %r unknown" % self.methname 
     195        return "method {0!r} unknown".format(self.methname) 
    196196 
    197197 
     
    205205 
    206206    def __str__(self): 
    207         return "opcode %r unknown" % self.opcode 
     207        return "opcode {0!r} unknown".format(self.opcode) 
    208208 
    209209 
     
    472472 
    473473    def __repr__(self): 
    474         v = ["<", self.__class__.__name__, " code=%r" % self.code] 
     474        v = ["<", self.__class__.__name__, " code={0!r}".format(self.code)] 
    475475        for attrname in ("r1", "r2", "r3", "r4", "r5", "arg"): 
    476476            attr = getattr(self, attrname) 
    477477            if attr is not None: 
    478                 v.append(" %s=%r" % (attrname, attr)) 
     478                v.append(" {0}={1!r}".format(attrname, attr)) 
    479479        if self.code is None: 
    480             v.append(" text=%r" % self.location.code) 
    481         v.append(" at 0x%x>" % id(self)) 
     480            v.append(" text={0!r}".format(self.location.code)) 
     481        v.append(" at {0:#x}>".format(id(self))) 
    482482        return "".join(v) 
    483483 
    484484    def __str__(self): 
    485         if self.code is None: 
    486             return "print %r" % self.location.code 
    487         elif self.code == "print": 
    488             return "print r%r" % self.r1 
    489         elif self.code == "printx": 
    490             return "print xmlescape(r%r)" % self.r1 
    491         elif self.code == "loadnone": 
    492             return "r%r = None" % self.r1 
    493         elif self.code == "loadfalse": 
    494             return "r%r = False" % self.r1 
    495         elif self.code == "loadtrue": 
    496             return "r%r = True" % self.r1 
    497         elif self.code == "loadstr": 
    498             return "r%r = %r" % (self.r1, self.arg) 
    499         elif self.code == "loadint": 
    500             return "r%r = %s" % (self.r1, self.arg) 
    501         elif self.code == "loadfloat": 
    502             return "r%r = %s" % (self.r1, self.arg) 
    503         elif self.code == "loaddate": 
    504             return "r%r = %s" % (self.r1, self.arg) 
    505         elif self.code == "loadcolor": 
    506             return "r%r = #%s" % (self.r1, self.arg) 
    507         elif self.code == "buildlist": 
    508             return "r%r = []" % (self.r1) 
    509         elif self.code == "builddict": 
    510             return "r%r = {}" % (self.r1) 
    511         elif self.code == "addlist": 
    512             return "r%r.append(r%r)" % (self.r1, self.r2) 
    513         elif self.code == "adddict": 
    514             return "r%r[r%r] = r%r" % (self.r1, self.r2, self.r3) 
    515         elif self.code == "updatedict": 
    516             return "r%r.update(r%r)" % (self.r1, self.r2) 
    517         elif self.code == "loadvar": 
    518             return "r%r = vars[%r]" % (self.r1, self.arg) 
    519         elif self.code == "storevar": 
    520             return "vars[%r] = r%r" % (self.arg, self.r1) 
    521         elif self.code == "addvar": 
    522             return "vars[%r] += r%r" % (self.arg, self.r1) 
    523         elif self.code == "subvar": 
    524             return "vars[%r] -= r%r" % (self.arg, self.r1) 
    525         elif self.code == "mulvar": 
    526             return "vars[%r] *= r%r" % (self.arg, self.r1) 
    527         elif self.code == "truedivvar": 
    528             return "vars[%r] /= r%r" % (self.arg, self.r1) 
    529         elif self.code == "floordivvar": 
    530             return "vars[%r] //= r%r" % (self.arg, self.r1) 
    531         elif self.code == "modvar": 
    532             return "vars[%r] %%= r%r" % (self.arg, self.r1) 
    533         elif self.code == "delvar": 
    534             return "del vars[%r]" % self.arg 
    535         elif self.code == "for": 
    536             return "for r%r in r%r" % (self.r1, self.r2) 
    537         elif self.code == "endfor": 
    538             return "endfor" 
    539         elif self.code == "break": 
    540             return "break" 
    541         elif self.code == "continue": 
    542             return "continue" 
    543         elif self.code == "if": 
    544             return "if r%r" % self.r1 
    545         elif self.code == "else": 
    546             return "else" 
    547         elif self.code == "endif": 
    548             return "endif" 
    549         elif self.code == "getattr": 
    550             return "r%r = getattr(r%r, %r)" % (self.r1, self.r2, self.arg) 
    551         elif self.code == "getitem": 
    552             return "r%r = r%r[r%r]" % (self.r1, self.r2, self.r3) 
    553         elif self.code == "getslice1": 
    554             return "r%r = r%r[r%r:]" % (self.r1, self.r2, self.r3) 
    555         elif self.code == "getslice2": 
    556             return "r%r = r%r[:r%r]" % (self.r1, self.r2, self.r3) 
    557         elif self.code == "getslice12": 
    558             return "r%r = r%r[r%r:r%r]" % (self.r1, self.r2, self.r3, self.r4) 
    559         elif self.code == "not": 
    560             return "r%r = not r%r" % (self.r1, self.r2) 
    561         elif self.code == "eq": 
    562             return "r%r = r%r == r%r" % (self.r1, self.r2, self.r3) 
    563         elif self.code == "ne": 
    564             return "r%r = r%r != r%r" % (self.r1, self.r2, self.r3) 
    565         elif self.code == "lt": 
    566             return "r%r = r%r < r%r" % (self.r1, self.r2, self.r3) 
    567         elif self.code == "le": 
    568             return "r%r = r%r <= r%r" % (self.r1, self.r2, self.r3) 
    569         elif self.code == "gt": 
    570             return "r%r = r%r > r%r" % (self.r1, self.r2, self.r3) 
    571         elif self.code == "ge": 
    572             return "r%r = r%r >= r%r" % (self.r1, self.r2, self.r3) 
    573         elif self.code == "contains": 
    574             return "r%r = r%r in r%r" % (self.r1, self.r2, self.r3) 
    575         elif self.code == "notcontains": 
    576             return "r%r = r%r not in r%r" % (self.r1, self.r2, self.r3) 
    577         elif self.code == "add": 
    578             return "r%r = r%r + r%r" % (self.r1, self.r2, self.r3) 
    579         elif self.code == "sub": 
    580             return "r%r = r%r - r%r" % (self.r1, self.r2, self.r3) 
    581         elif self.code == "mul": 
    582             return "r%r = r%r * r%r" % (self.r1, self.r2, self.r3) 
    583         elif self.code == "floordiv": 
    584             return "r%r = r%r // r%r" % (self.r1, self.r2, self.r3) 
    585         elif self.code == "truediv": 
    586             return "r%r = r%r / r%r" % (self.r1, self.r2, self.r3) 
    587         elif self.code == "and": 
    588             return "r%r = r%r and r%r" % (self.r1, self.r2, self.r3) 
    589         elif self.code == "or": 
    590             return "r%r = r%r or r%r" % (self.r1, self.r2, self.r3) 
    591         elif self.code == "mod": 
    592             return "r%r = r%r %% r%r" % (self.r1, self.r2, self.r3) 
    593         elif self.code == "neg": 
    594             return "r%r = -r%r" % (self.r1, self.r2) 
    595         elif self.code == "callfunc0": 
    596             return "r%r = %s()" % (self.r1, self.arg) 
    597         elif self.code == "callfunc1": 
    598             return "r%r = %s(r%r)" % (self.r1, self.arg, self.r2) 
    599         elif self.code == "callfunc2": 
    600             return "r%r = %s(r%r, r%r)" % (self.r1, self.arg, self.r2, self.r3) 
    601         elif self.code == "callfunc3": 
    602             return "r%r = %s(r%r, r%r, r%r)" % (self.r1, self.arg, self.r2, self.r3, self.r4) 
    603         elif self.code == "callfunc4": 
    604             return "r%r = %s(r%r, r%r, r%r, r%r)" % (self.r1, self.arg, self.r2, self.r3, self.r4, self.r5) 
    605         elif self.code == "callmeth0": 
    606             return "r%r = r%r.%s()" % (self.r1, self.r2, self.arg) 
    607         elif self.code == "callmeth1": 
    608             return "r%r = r%r.%s(r%r)" % (self.r1, self.r2, self.arg, self.r3) 
    609         elif self.code == "callmeth2": 
    610             return "r%r = r%r.%s(r%r, r%r)" % (self.r1, self.r2, self.arg, self.r3, self.r4) 
    611         elif self.code == "callmeth3": 
    612             return "r%r = r%r.%s(r%r, r%r, r%r)" % (self.r1, self.r2, self.arg, self.r3, self.r4, self.r5) 
    613         elif self.code == "callmethkw": 
    614             return "r%r = r%r.%s(**r%r)" % (self.r1, self.r2, self.arg, self.r3) 
    615         elif self.code == "render": 
    616             return "render r%r(r%r)" % (self.r1, self.r2) 
    617         elif self.code == "def": 
    618             return "def %s(vars)" % self.arg 
    619         elif self.code == "enddef": 
    620             return "endfor" 
    621         else: 
     485        formats = { 
     486            None: "print {op.location.code!r}", 
     487            "print": "print r{op.r1!r}", 
     488            "printx": "print xmlescape(r{op.r1!r})", 
     489            "loadnone": "r{op.r1!r} = None", 
     490            "loadfalse": "r{op.r1!r} = False", 
     491            "loadtrue": "r{op.r1!r} = True", 
     492            "loadstr": "r{op.r1!r} = {op.r2!r}", 
     493            "loadint": "r{op.r1!r} = {op.arg}", 
     494            "loadfloat": "r{op.r1!r} = {op.arg}", 
     495            "loaddate": "r{op.r1!r} = {op.arg}", 
     496            "loadcolor": "r{op.r1!r} = #{op.arg}", 
     497            "buildlist": "r{op.r1!r} = []", 
     498            "builddict": "r{op.r1!r} = {{}}", 
     499            "addlist": "r{op.r1!r}.append(r{op.r2!r})", 
     500            "adddict": "r{op.r1!r}[r{op.r2!r}] = r{op.r3!r}", 
     501            "updatedict": "r{op.r1!r}.update(r{op.r2!r})", 
     502            "loadvar": "r{op.r1!r} = vars[{op.arg!r}]", 
     503            "storevar": "vars[{op.arg!r}] = r{op.r1!r}", 
     504            "addvar": "vars[{op.arg!r}] += r{op.r1!r}", 
     505            "subvar": "vars[{op.arg!r}] -= r{op.r1!r}", 
     506            "mulvar": "vars[{op.arg!r}] *= r{op.r1!r}", 
     507            "truedivvar": "vars[{op.arg!r}] /= r{op.r1!r}", 
     508            "floordivvar": "vars[{op.arg!r}] //= r{op.r1!r}", 
     509            "modvar": "vars[{op.arg!r}] %= r{op.r1!r}", 
     510            "delvar": "del vars[{op.arg!r}]", 
     511            "for": "for r{op.r1!r} in r{op.r2!r}", 
     512            "endfor": "endfor", 
     513            "break": "break", 
     514            "continue": "continue", 
     515            "if": "if r{op.r1!r}", 
     516            "else": "else", 
     517            "endif": "endif", 
     518            "getattr": "r{op.r1!r} = getattr(r{op.r2!r}, {op.arg!r})", 
     519            "getitem": "r{op.r1!r} = r{op.r2!r}[r{op.r3!r}]", 
     520            "getslice1": "r{op.r1!r} = r{op.r2!r}[r{op.r3!r}:]", 
     521            "getslice2": "r{op.r1!r} = r{op.r2!r}[:r{op.r3!r}]", 
     522            "getslice12": "r{op.r1!r} = r{op.r2!r}[r{op.r3!r}:r{op.r4!r}]", 
     523            "not": "r{op.r1!r} = not r{op.r2!r}", 
     524            "eq": "r{op.r1!r} = r{op.r2!r} == r{op.r3!r}", 
     525            "ne": "r{op.r1!r} = r{op.r2!r} != r{op.r3!r}", 
     526            "lt": "r{op.r1!r} = r{op.r2!r} < r{op.r3!r}", 
     527            "le": "r{op.r1!r} = r{op.r2!r} <= r{op.r3!r}", 
     528            "gt": "r{op.r1!r} = r{op.r2!r} > r{op.r3!r}", 
     529            "ge": "r{op.r1!r} = r{op.r2!r} >= r{op.r3!r}", 
     530            "contains": "r{op.r1!r} = r{op.r2!r} in r{op.r3!r}", 
     531            "notcontains": "r{op.r1!r} = r{op.r2!r} not in r{op.r3!r}", 
     532            "add": "r{op.r1!r} = r{op.r2!r} + r{op.r3!r}", 
     533            "sub": "r{op.r1!r} = r{op.r2!r} - r{op.r3!r}", 
     534            "mul": "r{op.r1!r} = r{op.r2!r} * r{op.r3!r}", 
     535            "floordiv": "r{op.r1!r} = r{op.r2!r} // r{op.r3!r}", 
     536            "truediv": "r{op.r1!r} = r{op.r2!r} / r{op.r3!r}", 
     537            "and": "r{op.r1!r} = r{op.r2!r} and r{op.r3!r}", 
     538            "or": "r{op.r1!r} = r{op.r2!r} or r{op.r3!r}", 
     539            "mod": "r{op.r1!r} = r{op.r2!r} % r{op.r3!r}", 
     540            "neg":"r{op.r1!r} = -r{op.r2!r}", 
     541            "callfunc0": "r{op.r1!r} = {op.arg}()", 
     542            "callfunc1": "r{op.r1!r} = {op.arg}(r{op.r2!r})", 
     543            "callfunc2": "r{op.r1!r} = {op.arg}(r{op.r2!r}, r{op.r3!r})", 
     544            "callfunc3": "r{op.r1!r} = {op.arg}(r{op.r2!r}, r{op.r3!r}, r{op.r4!r})", 
     545            "callfunc4": "r{op.r1!r} = {op.arg}(r{op.r2!r}, r{op.r3!r}, r{op.r4!r}, r{op.r5!r})", 
     546            "callmeth0": "r{op.r1!r} = r{op.r2!r}.{op.arg}()", 
     547            "callmeth1": "r{op.r1!r} = r{op.r2!r}.{op.arg}(r{op.r3!r})", 
     548            "callmeth2": "r{op.r1!r} = r{op.r2!r}.{op.arg}(r{op.r3!r}, r{op.r4!r})", 
     549            "callmeth3": "r{op.r1!r} = r{op.r3!r}.{op.arg}(r{op.r3!r}, r{op.r4!r}, r{op.r5!r})", 
     550            "callmethkw": "r{op.r1!r} = r{op.r2!r}.{op.arg}(**r{op.r3!r})", 
     551            "render": "render r{op.r1!r}(r{op.r2!r})", 
     552            "def": "def {op.arg}(vars)", 
     553            "enddef": "endfor", 
     554        } 
     555        try: 
     556            return formats[self.code].format(op=self) 
     557        except KeyError: 
    622558            raise UnknownOpcodeError(self.code) 
    623559 
     
    636572    is a generator) or :meth:`renders` (which returns a string). 
    637573    """ 
    638     version = "11" 
     574    version = "12" 
    639575 
    640576    def __init__(self, source=None, startdelim="<?", enddelim="?>"): 
     
    672608                    return i 
    673609                else: 
    674                     raise ValueError("invalid terminator, expected %r, got %r" % (term, c)) 
     610                    raise ValueError("invalid terminator, expected {0!r}, got {1!r}".format(term, c)) 
    675611 
    676612        def _readstr(term): 
     
    687623                    return None 
    688624                else: 
    689                     raise ValueError("invalid terminator, expected %r, got %r" % (term, c)) 
     625                    raise ValueError("invalid terminator, expected {0!r}, got {1!r}".format(term, c)) 
    690626            s = stream.read(i) 
    691627            if len(s) != i: 
     
    700636                return int(c) 
    701637            else: 
    702                 raise ValueError("invalid register spec %r" % c) 
     638                raise ValueError("invalid register spec {0!r}".format(c)) 
    703639 
    704640        def _readcr(): 
    705641            c = stream.read(1) 
    706642            if c != "\n": 
    707                 raise ValueError("invalid linefeed %r" % c) 
     643                raise ValueError("invalid linefeed {0!r}".format(c)) 
    708644 
    709645        self = cls() 
     
    712648        header = header.rstrip() 
    713649        if header != "ul4": 
    714             raise ValueError("invalid header, expected 'ul4', got %r" % header) 
     650            raise ValueError("invalid header, expected 'ul4', got {0!r}".format(header)) 
    715651        version = stream.readline() 
    716652        version = version.rstrip() 
    717653        if version != self.version: 
    718             raise ValueError("invalid version, expected %r got, %r" % (self.version, version)) 
     654            raise ValueError("invalid version, expected {0!r}, got {1!r}".format(self.version, version)) 
    719655        self.startdelim = _readstr(u"<") 
    720656        _readcr() 
     
    742678                location = Location(self.source, _readstr("="), _readint("("), _readint(")"), _readint("{"), _readint("}")) 
    743679            else: 
    744                 raise ValueError("invalid location spec %r" % locspec) 
     680                raise ValueError("invalid location spec {0!r}".format(locspec)) 
    745681            _readcr() 
    746682            count -= 1 
     
    772708                yield string 
    773709 
    774         yield "ul4\n%s\n" % self.version 
     710        yield "ul4\n{0}\n".format(self.version) 
    775711        for p in _writestr("<", self.startdelim): yield p 
    776712        yield "\n" 
     
    817753 
    818754    def _pythonsource_line(self, location, line): 
    819         self.lines.append("%s%s" % ("\t"*self.indent, line)) 
     755        self.lines.append("{0}{1}".format("\t"*self.indent, line)) 
    820756        if self.lastlocation is not location or not self.locations: 
    821757            self.locations.append((location.type, location.starttag, location.endtag, location.startcode, location.endcode)) 
     
    824760 
    825761    def _pythonsource_dispatch_None(self, opcode): 
    826         self._pythonsource_line(opcode.location, "yield %r" % opcode.location.code) 
     762        self._pythonsource_line(opcode.location, "yield {0!r}".format(opcode.location.code)) 
    827763    def _pythonsource_dispatch_loadstr(self, opcode): 
    828         self._pythonsource_line(opcode.location, "r%d = %r" % (opcode.r1, opcode.arg)) 
     764        self._pythonsource_line(opcode.location, "r{op.r1:d} = {op.arg!r}".format(op=opcode)) 
    829765    def _pythonsource_dispatch_loadint(self, opcode): 
    830         self._pythonsource_line(opcode.location, "r%d = %s" % (opcode.r1, opcode.arg)) 
     766        self._pythonsource_line(opcode.location, "r{op.r1:d} = {op.arg}".format(op=opcode)) 
    831767    def _pythonsource_dispatch_loadfloat(self, opcode): 
    832         self._pythonsource_line(opcode.location, "r%d = %s" % (opcode.r1, opcode.arg)) 
     768        self._pythonsource_line(opcode.location, "r{op.r1:d} = {op.arg}".format(op=opcode)) 
    833769    def _pythonsource_dispatch_loadnone(self, opcode): 
    834         self._pythonsource_line(opcode.location, "r%d = None" % opcode.r1) 
     770        self._pythonsource_line(opcode.location, "r{op.r1:d} = None".format(op=opcode)) 
    835771    def _pythonsource_dispatch_loadfalse(self, opcode): 
    836         self._pythonsource_line(opcode.location, "r%d = False" % opcode.r1) 
     772        self._pythonsource_line(opcode.location, "r{op.r1:d} = False".format(op=opcode)) 
    837773    def _pythonsource_dispatch_loadtrue(self, opcode): 
    838         self._pythonsource_line(opcode.location, "r%d = True" % opcode.r1) 
     774        self._pythonsource_line(opcode.location, "r{op.r1:d} = True".format(op=opcode)) 
    839775    def _pythonsource_dispatch_loaddate(self, opcode): 
    840         self._pythonsource_line(opcode.location, "r%d = datetime.datetime(%s)" % (opcode.r1, ", ".join(str(int(p)) for p in datesplitter.split(opcode.arg)))) 
     776        self._pythonsource_line(opcode.location, "r{op.r1:d} = datetime.datetime({date})".format(op=opcode, date=", ".join(str(int(p)) for p in datesplitter.split(opcode.arg)))) 
    841777    def _pythonsource_dispatch_loadcolor(self, opcode): 
    842         self._pythonsource_line(opcode.location, "r%d = color.Color(0x%s, 0x%s, 0x%s, 0x%s)" % (opcode.r1, opcode.arg[:2], opcode.arg[2:4], opcode.arg[4:6], opcode.arg[6:])) 
     778        self._pythonsource_line(opcode.location, "r{op.r1:d} = color.Color(0x{r}, 0x{g}, 0x{b}, 0x{a})".format(op=opcode, r=opcode.arg[:2], g=opcode.arg[2:4], b=opcode.arg[4:6], a=opcode.arg[6:])) 
    843779    def _pythonsource_dispatch_buildlist(self, opcode): 
    844         self._pythonsource_line(opcode.location, "r%d = []" % opcode.r1) 
     780        self._pythonsource_line(opcode.location, "r{op.r1:d} = []".format(op=opcode)) 
    845781    def _pythonsource_dispatch_builddict(self, opcode): 
    846         self._pythonsource_line(opcode.location, "r%d = {}" % opcode.r1) 
     782        self._pythonsource_line(opcode.location, "r{op.r1:d} = {{}}".format(op=opcode)) 
    847783    def _pythonsource_dispatch_addlist(self, opcode): 
    848         self._pythonsource_line(opcode.location, "r%d.append(r%d)" % (opcode.r1, opcode.r2)) 
     784        self._pythonsource_line(opcode.location, "r{op.r1:d}.append(r{op.r2:d})".format(op=opcode)) 
    849785    def _pythonsource_dispatch_adddict(self, opcode): 
    850         self._pythonsource_line(opcode.location, "r%d[r%d] = r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     786        self._pythonsource_line(opcode.location, "r{op.r1:d}[r{op.r2:d}] = r{op.r3:d}".format(op=opcode)) 
    851787    def _pythonsource_dispatch_updatedict(self, opcode): 
    852         self._pythonsource_line(opcode.location, "r%d.update(r%d)" % (opcode.r1, opcode.r2)) 
     788        self._pythonsource_line(opcode.location, "r{op.r1:d}.update(r{op.r2:d})".format(op=opcode)) 
    853789    def _pythonsource_dispatch_loadvar(self, opcode): 
    854         self._pythonsource_line(opcode.location, "r%d = variables[%r]" % (opcode.r1, opcode.arg)) 
     790        self._pythonsource_line(opcode.location, "r{op.r1:d} = variables[{op.arg!r}]".format(op=opcode)) 
    855791    def _pythonsource_dispatch_storevar(self, opcode): 
    856         self._pythonsource_line(opcode.location, "variables[%r] = r%d" % (opcode.arg, opcode.r1)) 
     792        self._pythonsource_line(opcode.location, "variables[{op.arg!r}] = r{op.r1:d}".format(op=opcode)) 
    857793    def _pythonsource_dispatch_addvar(self, opcode): 
    858         self._pythonsource_line(opcode.location, "variables[%r] += r%d" % (opcode.arg, opcode.r1)) 
     794        self._pythonsource_line(opcode.location, "variables[{op.arg!r}] += r{op.r1:d}".format(op=opcode)) 
    859795    def _pythonsource_dispatch_subvar(self, opcode): 
    860         self._pythonsource_line(opcode.location, "variables[%r] -= r%d" % (opcode.arg, opcode.r1)) 
     796        self._pythonsource_line(opcode.location, "variables[{op.arg!r}] -= r{op.r1:d}".format(op=opcode)) 
    861797    def _pythonsource_dispatch_mulvar(self, opcode): 
    862         self._pythonsource_line(opcode.location, "variables[%r] *= r%d" % (opcode.arg, opcode.r1)) 
     798        self._pythonsource_line(opcode.location, "variables[{op.arg!r}] *= r{op.r1:d}".format(op=opcode)) 
    863799    def _pythonsource_dispatch_truedivvar(self, opcode): 
    864         self._pythonsource_line(opcode.location, "variables[%r] /= r%d" % (opcode.arg, opcode.r1)) 
     800        self._pythonsource_line(opcode.location, "variables[{op.arg!r}] /= r{op.r1:d}".format(op=opcode)) 
    865801    def _pythonsource_dispatch_floordivvar(self, opcode): 
    866         self._pythonsource_line(opcode.location, "variables[%r] //= r%d" % (opcode.arg, opcode.r1)) 
     802        self._pythonsource_line(opcode.location, "variables[{op.arg!r}] //= r{op.r1:d}".format(op=opcode)) 
    867803    def _pythonsource_dispatch_modvar(self, opcode): 
    868         self._pythonsource_line(opcode.location, "variables[%r] %%= r%d" % (opcode.arg, opcode.r1)) 
     804        self._pythonsource_line(opcode.location, "variables[{op.arg!r}] %= r{op.r1:d}".format(op=opcode)) 
    869805    def _pythonsource_dispatch_delvar(self, opcode): 
    870         self._pythonsource_line(opcode.location, "del variables[%r]" % opcode.arg) 
     806        self._pythonsource_line(opcode.location, "del variables[{op.arg!r}]".format(op=opcode)) 
    871807    def _pythonsource_dispatch_getattr(self, opcode): 
    872         self._pythonsource_line(opcode.location, "r%d = r%d[%r]" % (opcode.r1, opcode.r2, opcode.arg)) 
     808        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}[{op.arg!r}]".format(op=opcode)) 
    873809    def _pythonsource_dispatch_getitem(self, opcode): 
    874         self._pythonsource_line(opcode.location, "r%d = r%d[r%d]" % (opcode.r1, opcode.r2, opcode.r3)) 
     810        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}[r{op.r3:d}]".format(op=opcode)) 
    875811    def _pythonsource_dispatch_getslice12(self, opcode): 
    876         self._pythonsource_line(opcode.location, "r%d = r%d[r%d:r%d]" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4)) 
     812        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}[r{op.r3:d}:r{op.r4:d}]".format(op=opcode)) 
    877813    def _pythonsource_dispatch_getslice1(self, opcode): 
    878         self._pythonsource_line(opcode.location, "r%d = r%d[r%d:]" % (opcode.r1, opcode.r2, opcode.r3)) 
     814        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}[r{op.r3:d}:]".format(op=opcode)) 
    879815    def _pythonsource_dispatch_getslice2(self, opcode): 
    880         self._pythonsource_line(opcode.location, "r%d = r%d[:r%d]" % (opcode.r1, opcode.r2, opcode.r3)) 
     816        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}[:r{op.r3:d}]".format(op=opcode)) 
    881817    def _pythonsource_dispatch_print(self, opcode): 
    882         self._pythonsource_line(opcode.location, "if r%d is not None: yield unicode(r%d)" % (opcode.r1, opcode.r1)) 
     818        self._pythonsource_line(opcode.location, "if r{op.r1:d} is not None: yield unicode(r{op.r1:d})".format(op=opcode)) 
    883819    def _pythonsource_dispatch_printx(self, opcode): 
    884         self._pythonsource_line(opcode.location, "if r%d is not None: yield xmlescape(unicode(r%d))" % (opcode.r1, opcode.r1)) 
     820        self._pythonsource_line(opcode.location, "if r{op.r1:d} is not None: yield xmlescape(unicode(r{op.r1:d}))".format(op=opcode)) 
    885821    def _pythonsource_dispatch_for(self, opcode): 
    886         self._pythonsource_line(opcode.location, "for r%d in r%d:" % (opcode.r1, opcode.r2)) 
     822        self._pythonsource_line(opcode.location, "for r{op.r1:d} in r{op.r2:d}:".format(op=opcode)) 
    887823        self.indent += 1 
    888824    def _pythonsource_dispatch_endfor(self, opcode): 
     
    894830        self._pythonsource_line(opcode.location, "continue") 
    895831    def _pythonsource_dispatch_not(self, opcode): 
    896         self._pythonsource_line(opcode.location, "r%d = not r%d" % (opcode.r1, opcode.r2)) 
     832        self._pythonsource_line(opcode.location, "r{op.r1:d} = not r{op.r2:d}".format(op=opcode)) 
    897833    def _pythonsource_dispatch_neg(self, opcode): 
    898         self._pythonsource_line(opcode.location, "r%d = -r%d" % (opcode.r1, opcode.r2)) 
     834        self._pythonsource_line(opcode.location, "r{op.r1:d} = -r{op.r2:d}".format(op=opcode)) 
    899835    def _pythonsource_dispatch_contains(self, opcode): 
    900         self._pythonsource_line(opcode.location, "r%d = r%d in r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     836        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} in r{op.r3:d}".format(op=opcode)) 
    901837    def _pythonsource_dispatch_notcontains(self, opcode): 
    902         self._pythonsource_line(opcode.location, "r%d = r%d not in r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     838        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} not in r{op.r3:d}".format(op=opcode)) 
    903839    def _pythonsource_dispatch_eq(self, opcode): 
    904         self._pythonsource_line(opcode.location, "r%d = r%d == r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     840        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} == r{op.r3:d}".format(op=opcode)) 
    905841    def _pythonsource_dispatch_ne(self, opcode): 
    906         self._pythonsource_line(opcode.location, "r%d = r%d != r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     842        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} != r{op.r3:d}".format(op=opcode)) 
    907843    def _pythonsource_dispatch_lt(self, opcode): 
    908         self._pythonsource_line(opcode.location, "r%d = r%d < r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     844        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} < r{op.r3:d}".format(op=opcode)) 
    909845    def _pythonsource_dispatch_le(self, opcode): 
    910         self._pythonsource_line(opcode.location, "r%d = r%d <= r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     846        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} <= r{op.r3:d}".format(op=opcode)) 
    911847    def _pythonsource_dispatch_gt(self, opcode): 
    912         self._pythonsource_line(opcode.location, "r%d = r%d > r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     848        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} > r{op.r3:d}".format(op=opcode)) 
    913849    def _pythonsource_dispatch_ge(self, opcode): 
    914         self._pythonsource_line(opcode.location, "r%d = r%d >= r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     850        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} >= r{op.r3:d}".format(op=opcode)) 
    915851    def _pythonsource_dispatch_add(self, opcode): 
    916         self._pythonsource_line(opcode.location, "r%d = r%d + r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     852        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} + r{op.r3:d}".format(op=opcode)) 
    917853    def _pythonsource_dispatch_sub(self, opcode): 
    918         self._pythonsource_line(opcode.location, "r%d = r%d - r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     854        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} - r{op.r3:d}".format(op=opcode)) 
    919855    def _pythonsource_dispatch_mul(self, opcode): 
    920         self._pythonsource_line(opcode.location, "r%d = r%d * r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     856        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} * r{op.r3:d}".format(op=opcode)) 
    921857    def _pythonsource_dispatch_floordiv(self, opcode): 
    922         self._pythonsource_line(opcode.location, "r%d = r%d // r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     858        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} // r{op.r3:d}".format(op=opcode)) 
    923859    def _pythonsource_dispatch_truediv(self, opcode): 
    924         self._pythonsource_line(opcode.location, "r%d = r%d / r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     860        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} / r{op.r3:d}".format(op=opcode)) 
    925861    def _pythonsource_dispatch_and(self, opcode): 
    926         self._pythonsource_line(opcode.location, "r%d = r%d and r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     862        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} and r{op.r3:d}".format(op=opcode)) 
    927863    def _pythonsource_dispatch_or(self, opcode): 
    928         self._pythonsource_line(opcode.location, "r%d = r%d or r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     864        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} or r{op.r3:d}".format(op=opcode)) 
    929865    def _pythonsource_dispatch_mod(self, opcode): 
    930         self._pythonsource_line(opcode.location, "r%d = r%d %% r%d" % (opcode.r1, opcode.r2, opcode.r3)) 
     866        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} % r{op.r3:d}".format(op=opcode)) 
    931867    def _pythonsource_dispatch_callfunc0(self, opcode): 
    932868        try: 
    933             getattr(self, "_pythonsource_dispatch_callfunc0_%s" % opcode.arg)(opcode) 
     869            getattr(self, "_pythonsource_dispatch_callfunc0_{op.arg}".format(op=opcode))(opcode) 
    934870        except AttributeError: 
    935871            raise UnknownFunctionError(opcode.arg) 
    936872    def _pythonsource_dispatch_callfunc1(self, opcode): 
    937873        try: 
    938             getattr(self, "_pythonsource_dispatch_callfunc1_%s" % opcode.arg)(opcode) 
     874            getattr(self, "_pythonsource_dispatch_callfunc1_{op.arg}".format(op=opcode))(opcode) 
    939875        except AttributeError: 
    940876            raise UnknownFunctionError(opcode.arg) 
    941877    def _pythonsource_dispatch_callfunc2(self, opcode): 
    942878        try: 
    943             getattr(self, "_pythonsource_dispatch_callfunc2_%s" % opcode.arg)(opcode) 
     879            getattr(self, "_pythonsource_dispatch_callfunc2_{op.arg}".format(op=opcode))(opcode) 
    944880        except AttributeError: 
    945881            raise UnknownFunctionError(opcode.arg) 
    946882    def _pythonsource_dispatch_callfunc3(self, opcode): 
    947883        try: 
    948             getattr(self, "_pythonsource_dispatch_callfunc3_%s" % opcode.arg)(opcode) 
     884            getattr(self, "_pythonsource_dispatch_callfunc3_{op.arg}".format(op=opcode))(opcode) 
    949885        except AttributeError: 
    950886            raise UnknownFunctionError(opcode.arg) 
    951887    def _pythonsource_dispatch_callfunc4(self, opcode): 
    952888        try: 
    953             getattr(self, "_pythonsource_dispatch_callfunc4_%s" % opcode.arg)(opcode) 
     889            getattr(self, "_pythonsource_dispatch_callfunc4_{op.arg}".format(op=opcode))(opcode) 
    954890        except AttributeError: 
    955891            raise UnknownFunctionError(opcode.arg) 
    956892    def _pythonsource_dispatch_callmeth0(self, opcode): 
    957893        if opcode.arg in ("split", "rsplit", "strip", "lstrip", "rstrip", "upper", "lower", "capitalize", "isoformat", "r", "g", "b", "a", "hls", "hlsa", "hsv", "hsva", "lum"): 
    958             self._pythonsource_line(opcode.location, "r%d = r%d.%s()" % (opcode.r1, opcode.r2, opcode.arg)) 
     894            self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}.{op.arg}()".format(op=opcode)) 
    959895        elif opcode.arg == "items": 
    960             self._pythonsource_line(opcode.location, "r%d = r%d.iteritems()" % (opcode.r1, opcode.r2)) 
     896            self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}.iteritems()".format(op=opcode)) 
    961897        elif opcode.arg == "render": 
    962             self._pythonsource_line(opcode.location, 'r%d = "".join(r%d())' % (opcode.r1, opcode.r2)) 
     898            self._pythonsource_line(opcode.location, 'r{op.r1:d} = "".join(r{op.r2:d}())'.format(op=opcode)) 
     899        elif opcode.arg == "mimeformat": 
     900            self._pythonsource_line(opcode.location, 'r{op.r1:d} = ul4c._mimeformat(r{op.r2:d})'.format(op=opcode)) 
    963901        else: 
    964902            raise UnknownMethodError(opcode.arg) 
    965903    def _pythonsource_dispatch_callmeth1(self, opcode): 
    966904        if opcode.arg in ("split", "rsplit", "strip", "lstrip", "rstrip", "startswith", "endswith", "find", "get", "withlum", "witha"): 
    967             self._pythonsource_line(opcode.location, "r%d = r%d.%s(r%d)" % (opcode.r1, opcode.r2, opcode.arg, opcode.r3)) 
     905            self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}.{op.arg}(r{op.r3:d})".format(op=opcode)) 
    968906        elif opcode.arg == "join": 
    969             self._pythonsource_line(opcode.location, "r%d = r%d.join(unicode(x) for x in r%d)" % (opcode.r1, opcode.r2, opcode.r3)) 
     907            self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}.join(unicode(x) for x in r{op.r3:d})".format(op=opcode)) 
    970908        elif opcode.arg == "format": 
    971             self._pythonsource_line(opcode.location, "r%d = r%d.__format__(r%d)" % (opcode.r1, opcode.r2, opcode.r3)) 
     909            self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}.__format__(r{op.r3:d})".format(op=opcode)) 
    972910        else: 
    973911            raise UnknownMethodError(opcode.arg) 
    974912    def _pythonsource_dispatch_callmeth2(self, opcode): 
    975913        if opcode.arg in ("split", "rsplit", "find", "replace", "get"): 
    976             self._pythonsource_line(opcode.location, "r%d = r%d.%s(r%d, r%d)" % (opcode.r1, opcode.r2, opcode.arg, opcode.r3, opcode.r4)) 
     914            self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}.{op.arg}(r{op.r3:d}, r{op.r4:d})".format(op=opcode)) 
    977915        else: 
    978916            raise UnknownMethodError(opcode.arg) 
    979917    def _pythonsource_dispatch_callmeth3(self, opcode): 
    980918        if opcode.arg == "find": 
    981             self._pythonsource_line(opcode.location, "r%d = r%d.%s(r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.arg, opcode.r3, opcode.r4, opcode.r5)) 
     919            self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d}.{op.arg}(r{op.r3:d}, r{op.r4:d}, r{op.r5:d})".format(op=opcode)) 
    982920        else: 
    983921            raise UnknownMethodError(opcode.arg) 
    984922    def _pythonsource_dispatch_callmethkw(self, opcode): 
    985923        if opcode.arg == "render": 
    986             self._pythonsource_line(opcode.location, 'r%d = "".join(r%d(**dict((key.encode("utf-8"), value) for (key, value) in r%d.iteritems())))' % (opcode.r1, opcode.r2, opcode.r3)) 
     924            self._pythonsource_line(opcode.location, 'r{op.r1:d} = "".join(r{op.r2:d}(**dict((key.encode("utf-8"), value) for (key, value) in r{op.r3:d}.iteritems())))'.format(op=opcode)) # FIXME: This can be simplified in Python 3.0 where strings are unicode 
    987925        else: 
    988926            raise UnknownMethodError(opcode.arg) 
    989927    def _pythonsource_dispatch_if(self, opcode): 
    990         self._pythonsource_line(opcode.location, "if r%d:" % (opcode.r1)) 
     928        self._pythonsource_line(opcode.location, "if r{op.r1:d}:".format(op=opcode)) 
    991929        self.indent += 1 
    992930    def _pythonsource_dispatch_else(self, opcode): 
     
    1019957        self._pythonsource_line(opcode.location, "raise newexc") 
    1020958        self.indent -= 2 
    1021         self._pythonsource_line(opcode.location, "variables[%r] = _" % defopcode.arg) 
     959        self._pythonsource_line(opcode.location, "variables[{op.arg!r}] = _".format(op=defopcode)) 
    1022960    def _pythonsource_dispatch_render(self, opcode): 
    1023         self._pythonsource_line(opcode.location, 'for chunk in r%d(**dict((key.encode("utf-8"), value) for (key, value) in r%d.iteritems())): yield chunk' % (opcode.r1, opcode.r2)) 
     961        self._pythonsource_line(opcode.location, 'for chunk in r{op.r1:d}(**dict((key.encode("utf-8"), value) for (key, value) in r{op.r2:d}.iteritems())): yield chunk'.format(op=opcode)) 
    1024962    def _pythonsource_dispatch_callfunc0_now(self, opcode): 
    1025         self._pythonsource_line(opcode.location, "r%d = datetime.datetime.now()" % opcode.r1) 
     963        self._pythonsource_line(opcode.location, "r{op.r1:d} = datetime.datetime.now()".format(op=opcode)) 
     964    def _pythonsource_dispatch_callfunc0_utcnow(self, opcode): 
     965        self._pythonsource_line(opcode.location, "r{op.r1:d} = datetime.datetime.utcnow()".format(op=opcode)) 
    1026966    def _pythonsource_dispatch_callfunc0_vars(self, opcode): 
    1027         self._pythonsource_line(opcode.location, "r%d = variables" % opcode.r1) 
     967        self._pythonsource_line(opcode.location, "r{op.r1:d} = variables".format(op=opcode)) 
    1028968    def _pythonsource_dispatch_callfunc1_xmlescape(self, opcode): 
    1029         self._pythonsource_line(opcode.location, "r%d = xmlescape(unicode(r%d)) if r%d is not None else u''" % (opcode.r1, opcode.r2, opcode.r2)) 
     969        self._pythonsource_line(opcode.location, "r{op.r1:d} = xmlescape(unicode(r{op.r2:d})) if r{op.r2:d} is not None else u''".format(op=opcode)) 
    1030970    def _pythonsource_dispatch_callfunc1_csv(self, opcode): 
    1031         self._pythonsource_line(opcode.location, "r%d = ul4c._csv(r%d)" % (opcode.r1, opcode.r2)) 
     971        self._pythonsource_line(opcode.location, "r{op.r1:d} = ul4c._csv(r{op.r2:d})".format(op=opcode)) 
    1032972    def _pythonsource_dispatch_callfunc1_json(self, opcode): 
    1033         self._pythonsource_line(opcode.location, "r%d = json.dumps(r%d)" % (opcode.r1, opcode.r2)) 
     973        self._pythonsource_line(opcode.location, "r{op.r1:d} = json.dumps(r{op.r2:d})".format(op=opcode)) 
    1034974    def _pythonsource_dispatch_callfunc1_str(self, opcode): 
    1035         self._pythonsource_line(opcode.location, "r%d = unicode(r%d) if r%d is not None else u''" % (opcode.r1, opcode.r2, opcode.r2)) 
     975        self._pythonsource_line(opcode.location, "r{op.r1:d} = unicode(r{op.r2:d}) if r{op.r2:d} is not None else u''".format(op=opcode)) 
    1036976    def _pythonsource_dispatch_callfunc1_int(self, opcode): 
    1037         self._pythonsource_line(opcode.location, "r%d = int(r%d)" % (opcode.r1, opcode.r2)) 
     977        self._pythonsource_line(opcode.location, "r{op.r1:d} = int(r{op.r2:d})".format(op=opcode)) 
    1038978    def _pythonsource_dispatch_callfunc1_float(self, opcode): 
    1039         self._pythonsource_line(opcode.location, "r%d = float(r%d)" % (opcode.r1, opcode.r2)) 
     979        self._pythonsource_line(opcode.location, "r{op.r1:d} = float(r{op.r2:d})".format(op=opcode)) 
    1040980    def _pythonsource_dispatch_callfunc1_bool(self, opcode): 
    1041         self._pythonsource_line(opcode.location, "r%d = bool(r%d)" % (opcode.r1, opcode.r2)) 
     981        self._pythonsource_line(opcode.location, "r{op.r1:d} = bool(r{op.r2:d})".format(op=opcode)) 
    1042982    def _pythonsource_dispatch_callfunc1_len(self, opcode): 
    1043         self._pythonsource_line(opcode.location, "r%d = len(r%d)" % (opcode.r1, opcode.r2)) 
     983        self._pythonsource_line(opcode.location, "r{op.r1:d} = len(r{op.r2:d})".format(op=opcode)) 
     984    def _pythonsource_dispatch_callfunc1_abs(self, opcode): 
     985        self._pythonsource_line(opcode.location, "r{op.r1:d} = abs(r{op.r2:d})".format(op=opcode)) 
    1044986    def _pythonsource_dispatch_callfunc1_enumerate(self, opcode): 
    1045         self._pythonsource_line(opcode.location, "r%d = enumerate(r%d)" % (opcode.r1, opcode.r2)) 
     987        self._pythonsource_line(opcode.location, "r{op.r1:d} = enumerate(r{op.r2:d})".format(op=opcode)) 
    1046988    def _pythonsource_dispatch_callfunc1_isnone(self, opcode): 
    1047         self._pythonsource_line(opcode.location, "r%d = r%d is None" % (opcode.r1, opcode.r2)) 
     989        self._pythonsource_line(opcode.location, "r{op.r1:d} = r{op.r2:d} is None".format(op=opcode)) 
    1048990    def _pythonsource_dispatch_callfunc1_isstr(self, opcode): 
    1049         self._pythonsource_line(opcode.location, "r%d = isinstance(r%d, basestring)" % (opcode.r1, opcode.r2)) 
     991        self._pythonsource_line(opcode.location, "r{op.r1:d} = isinstance(r{op.r2:d}, basestring)".format(op=opcode)) 
    1050992    def _pythonsource_dispatch_callfunc1_isint(self, opcode): 
    1051         self._pythonsource_line(opcode.location, "r%d = isinstance(r%d, (int, long)) and not isinstance(r%d, bool)" % (opcode.r1, opcode.r2, opcode.r2)) 
     993        self._pythonsource_line(opcode.location, "r{op.r1:d} = isinstance(r{op.r2:d}, (int, long)) and not isinstance(r{op.r2:d}, bool)".format(op=opcode)) 
    1052994    def _pythonsource_dispatch_callfunc1_isfloat(self, opcode): 
    1053         self._pythonsource_line(opcode.location, "r%d = isinstance(r%d, float)" % (opcode.r1, opcode.r2)) 
     995        self._pythonsource_line(opcode.location, "r{op.r1:d} = isinstance(r{op.r2:d}, float)".format(op=opcode)) 
    1054996    def _pythonsource_dispatch_callfunc1_isbool(self, opcode): 
    1055         self._pythonsource_line(opcode.location, "r%d = isinstance(r%d, bool)" % (opcode.r1, opcode.r2)) 
     997        self._pythonsource_line(opcode.location, "r{op.r1:d} = isinstance(r{op.r2:d}, bool)".format(op=opcode)) 
    1056998    def _pythonsource_dispatch_callfunc1_isdate(self, opcode): 
    1057         self._pythonsource_line(opcode.location, "r%d = isinstance(r%d, datetime.datetime)" % (opcode.r1, opcode.r2)) 
     999        self._pythonsource_line(opcode.location, "r{op.r1:d} = isinstance(r{op.r2:d}, datetime.datetime)".format(op=opcode)) 
    10581000    def _pythonsource_dispatch_callfunc1_islist(self, opcode): 
    1059         self._pythonsource_line(opcode.location, "r%d = isinstance(r%d, (list, tuple)) and not isinstance(r%d, color.Color)" % (opcode.r1, opcode.r2, opcode.r2)) 
     1001        self._pythonsource_line(opcode.location, "r{op.r1:d} = isinstance(r{op.r2:d}, (list, tuple)) and not isinstance(r{op.r2:d}, color.Color)".format(op=opcode)) 
    10601002    def _pythonsource_dispatch_callfunc1_isdict(self, opcode): 
    1061         self._pythonsource_line(opcode.location, "r%d = isinstance(r%d, dict)" % (opcode.r1, opcode.r2)) 
     1003        self._pythonsource_line(opcode.location, "r{op.r1:d} = isinstance(r{op.r2:d}, dict)".format(op=opcode)) 
    10621004    def _pythonsource_dispatch_callfunc1_istemplate(self, opcode): 
    1063         self._pythonsource_line(opcode.location, "r%d = hasattr(r%d, '__call__')" % (opcode.r1, opcode.r2)) # this supports normal generators too 
     1005        self._pythonsource_line(opcode.location, "r{op.r1:d} = hasattr(r{op.r2:d}, '__call__')".format(op=opcode)) # this supports normal generators too 
    10641006    def _pythonsource_dispatch_callfunc1_iscolor(self, opcode): 
    1065         self._pythonsource_line(opcode.location, "r%d = isinstance(r%d, color.Color)" % (opcode.r1, opcode.r2)) 
     1007        self._pythonsource_line(opcode.location, "r{op.r1:d} = isinstance(r{op.r2:d}, color.Color)".format(op=opcode)) 
    10661008    def _pythonsource_dispatch_callfunc1_repr(self, opcode): 
    1067         self._pythonsource_line(opcode.location, "r%d = ul4c._repr(r%d)" % (opcode.r1, opcode.r2)) 
     1009        self._pythonsource_line(opcode.location, "r{op.r1:d} = ul4c._repr(r{op.r2:d})".format(op=opcode)) 
    10681010    def _pythonsource_dispatch_callfunc1_get(self, opcode): 
    1069         self._pythonsource_line(opcode.location, "r%d = variables.get(r%d)" % (opcode.r1, opcode.r2)) 
     1011        self._pythonsource_line(opcode.location, "r{op.r1:d} = variables.get(r{op.r2:d})".format(op=opcode)) 
    10701012    def _pythonsource_dispatch_callfunc1_chr(self, opcode): 
    1071         self._pythonsource_line(opcode.location, "r%d = unichr(r%d)" % (opcode.r1, opcode.r2)) 
     1013        self._pythonsource_line(opcode.location, "r{op.r1:d} = unichr(r{op.r2:d})".format(op=opcode)) 
    10721014    def _pythonsource_dispatch_callfunc1_ord(self, opcode): 
    1073         self._pythonsource_line(opcode.location, "r%d = ord(r%d)" % (opcode.r1, opcode.r2)) 
     1015        self._pythonsource_line(opcode.location, "r{op.r1:d} = ord(r{op.r2:d})".format(op=opcode)) 
    10741016    def _pythonsource_dispatch_callfunc1_hex(self, opcode): 
    1075         self._pythonsource_line(opcode.location, "r%d = hex(r%d)" % (opcode.r1, opcode.r2)) 
     1017        self._pythonsource_line(opcode.location, "r{op.r1:d} = hex(r{op.r2:d})".format(op=opcode)) 
    10761018    def _pythonsource_dispatch_callfunc1_oct(self, opcode): 
    1077         self._pythonsource_line(opcode.location, "r%d = ul4c._oct(r%d)" % (opcode.r1, opcode.r2)) 
     1019        self._pythonsource_line(opcode.location, "r{op.r1:d} = ul4c._oct(r{op.r2:d})".format(op=opcode)) 
    10781020    def _pythonsource_dispatch_callfunc1_bin(self, opcode): 
    1079         self._pythonsource_line(opcode.location, "r%d = bin(r%d)" % (opcode.r1, opcode.r2)) 
     1021        self._pythonsource_line(opcode.location, "r{op.r1:d} = bin(r{op.r2:d})".format(op=opcode)) 
    10801022    def _pythonsource_dispatch_callfunc1_sorted(self, opcode): 
    1081         self._pythonsource_line(opcode.location, "r%d = sorted(r%d)" % (opcode.r1, opcode.r2)) 
     1023        self._pythonsource_line(opcode.location, "r{op.r1:d} = sorted(r{op.r2:d})".format(op=opcode)) 
    10821024    def _pythonsource_dispatch_callfunc1_range(self, opcode): 
    1083         self._pythonsource_line(opcode.location, "r%d = xrange(r%d)" % (opcode.r1, opcode.r2)) 
     1025        self._pythonsource_line(opcode.location, "r{op.r1:d} = xrange(r{op.r2:d})".format(op=opcode)) 
    10841026    def _pythonsource_dispatch_callfunc1_type(self, opcode): 
    1085         self._pythonsource_line(opcode.location, "r%d = ul4c._type(r%d)" % (opcode.r1, opcode.r2)) 
     1027        self._pythonsource_line(opcode.location, "r{op.r1:d} = ul4c._type(r{op.r2:d})".format(op=opcode)) 
    10861028    def _pythonsource_dispatch_callfunc1_reversed(self, opcode): 
    1087         self._pythonsource_line(opcode.location, "r%d = reversed(r%d)" % (opcode.r1, opcode.r2)) 
     1029        self._pythonsource_line(opcode.location, "r{op.r1:d} = reversed(r{op.r2:d})".format(op=opcode)) 
    10881030    def _pythonsource_dispatch_callfunc2_range(self, opcode): 
    1089         self._pythonsource_line(opcode.location, "r%d = xrange(r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3)) 
     1031        self._pythonsource_line(opcode.location, "r{op.r1:d} = xrange(r{op.r2:d}, r{op.r3:d})".format(op=opcode)) 
    10901032    def _pythonsource_dispatch_callfunc2_get(self, opcode): 
    1091         self._pythonsource_line(opcode.location, "r%d = variables.get(r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3)) 
     1033        self._pythonsource_line(opcode.location, "r{op.r1:d} = variables.get(r{op.r2:d}, r{op.r3:d})".format(op=opcode)) 
    10921034    def _pythonsource_dispatch_callfunc2_zip(self, opcode): 
    1093         self._pythonsource_line(opcode.location, "r%d = itertools.izip(r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3)) 
     1035        self._pythonsource_line(opcode.location, "r{op.r1:d} = itertools.izip(r{op.r2:d}, r{op.r3:d})".format(op=opcode)) 
    10941036    def _pythonsource_dispatch_callfunc2_int(self, opcode): 
    1095         self._pythonsource_line(opcode.location, "r%d = int(r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3)) 
     1037        self._pythonsource_line(opcode.location, "r{op.r1:d} = int(r{op.r2:d}, r{op.r3:d})".format(op=opcode)) 
    10961038    def _pythonsource_dispatch_callfunc3_range(self, opcode): 
    1097         self._pythonsource_line(opcode.location, "r%d = xrange(r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4)) 
     1039        self._pythonsource_line(opcode.location, "r{op.r1:d} = xrange(r{op.r2:d}, r{op.r3:d}, r{op.r4:d})".format(op=opcode)) 
    10981040    def _pythonsource_dispatch_callfunc3_zip(self, opcode): 
    1099         self._pythonsource_line(opcode.location, "r%d = itertools.izip(r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4)) 
     1041        self._pythonsource_line(opcode.location, "r{op.r1:d} = itertools.izip(r{op.r2:d}, r{op.r3:d}, r{op.r4:d})".format(op=opcode)) 
    11001042    def _pythonsource_dispatch_callfunc3_rgb(self, opcode): 
    1101         self._pythonsource_line(opcode.location, "r%d = color.Color.fromrgb(r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4)) 
     1043        self._pythonsource_line(opcode.location, "r{op.r1:d} = color.Color.fromrgb(r{op.r2:d}, r{op.r3:d}, r{op.r4:d})".format(op=opcode)) 
    11021044    def _pythonsource_dispatch_callfunc3_hls(self, opcode): 
    1103         self._pythonsource_line(opcode.location, "r%d = color.Color.fromhls(r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4)) 
     1045        self._pythonsource_line(opcode.location, "r{op.r1:d} = color.Color.fromhls(r{op.r2:d}, r{op.r3:d}, r{op.r4:d})".format(op=opcode)) 
    11041046    def _pythonsource_dispatch_callfunc3_hsv(self, opcode): 
    1105         self._pythonsource_line(opcode.location, "r%d = color.Color.fromhsv(r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4)) 
     1047        self._pythonsource_line(opcode.location, "r{op.r1:d} = color.Color.fromhsv(r{op.r2:d}, r{op.r3:d}, r{op.r4:d})".format(op=opcode)) 
    11061048    def _pythonsource_dispatch_callfunc4_rgb(self, opcode): 
    1107         self._pythonsource_line(opcode.location, "r%d = color.Color.fromrgb(r%d, r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4, opcode.r5)) 
     1049        self._pythonsource_line(opcode.location, "r{op.r1:d} = color.Color.fromrgb(r{op.r2:d}, r{op.r3:d}, r{op.r4:d}, r{op.r5:d})".format(op=opcode)) 
    11081050    def _pythonsource_dispatch_callfunc4_hls(self, opcode): 
    1109         self._pythonsource_line(opcode.location, "r%d = color.Color.fromhls(r%d, r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4, opcode.r5)) 
     1051        self._pythonsource_line(opcode.location, "r{op.r1:d} = color.Color.fromhls(r{op.r2:d}, r{op.r3:d}, r{op.r4:d}, r{op.r5:d})".format(op=opcode)) 
    11101052    def _pythonsource_dispatch_callfunc4_hsv(self, opcode): 
    1111         self._pythonsource_line(opcode.location, "r%d = color.Color.fromhsv(r%d, r%d, r%d, r%d)" % (opcode.r1, opcode.r2, opcode.r3, opcode.r4, opcode.r5)) 
     1053        self._pythonsource_line(opcode.location, "r{op.r1:d} = color.Color.fromhsv(r{op.r2:d}, r{op.r3:d}, r{op.r4:d}, r{op.r5:d})".format(op=opcode)) 
    11121054 
    11131055    def pythonsource(self, function=None): 
     
    11251067 
    11261068        if function is not None: 
    1127             self._pythonsource_line(self.lastlocation, "def %s(**variables):" % function) 
     1069            self._pythonsource_line(self.lastlocation, "def {0}(**variables):".format(function)) 
    11281070            self.indent += 1 
    11291071            self.lines2locs = [] # We initialize startline one line below, which restarts the counter 
     
    11311073        self._pythonsource_line(self.lastlocation, "__1__") 
    11321074        self._pythonsource_line(self.lastlocation, "__2__") 
    1133         self._pythonsource_line(self.lastlocation, "source = %r" % self.source) 
     1075        self._pythonsource_line(self.lastlocation, "source = {0!r}".format(self.source)) 
    11341076        self._pythonsource_line(self.lastlocation, 'variables = dict((key.decode("utf-8"), value) for (key, value) in variables.iteritems())') # FIXME: This can be dropped in Python 3.0 where strings are unicode 
    11351077        self._pythonsource_line(self.lastlocation, "r0 = r1 = r2 = r3 = r4 = r5 = r6 = r7 = r8 = r9 = None") 
     
    11411083            for opcode in self.opcodes: 
    11421084                try: 
    1143                     getattr(self, "_pythonsource_dispatch_%s" % opcode.code)(opcode) 
     1085                    getattr(self, "_pythonsource_dispatch_{0}".format(opcode.code))(opcode) 
    11441086                except AttributeError: 
    11451087                    raise UnknownOpcodeError(opcode.code) 
     
    11561098        self._pythonsource_line(self.lastlocation, "raise newexc") 
    11571099        locoffset = 1+int(self.lines[0].strip() != "__1__") 
    1158         self.lines[locoffset] = self.lines[locoffset].replace("__1__", "locations = %r" % (tuple(self.locations),)) 
    1159         self.lines[locoffset+1] = self.lines[locoffset+1].replace("__2__", "lines2locs = %r" % (tuple(self.lines2locs),)) 
     1100        self.lines[locoffset] = self.lines[locoffset].replace("__1__", "locations = {0!r}".format(tuple(self.locations))) 
     1101        self.lines[locoffset+1] = self.lines[locoffset+1].replace("__2__", "lines2locs = {0!r}".format(tuple(self.lines2locs))) 
    11601102        result = "\n".join(self.lines) 
    11611103        del self.lastopcode 
     
    12071149                i -= 1 
    12081150            if opcode.code in ("endif", "endfor", "enddef"): 
    1209                 yield "%s}" % (i*indent) 
     1151                yield "{0}}}".format(i*indent) 
    12101152            elif opcode.code in ("for", "if", "def"): 
    1211                 yield "%s%s {" % (i*indent, opcode) 
     1153                yield "{0}{1} {{".format(i*indent, opcode) 
    12121154            elif opcode.code == "else": 
    1213                 yield "%s} else {" % (i*indent) 
     1155                yield "{0}}} else {{".format(i*indent) 
    12141156            else: 
    1215                 yield "%s%s" % (i*indent, opcode) 
     1157                yield "{0}{1}".format(i*indent, opcode) 
    12161158            if opcode.code in ("for", "if", "else", "def"): 
    12171159                i += 1 
     
    12251167        or non-tag text. It will be called by :meth:`_compile` internally. 
    12261168        """ 
    1227         pattern = u"%s(printx|print|code|for|if|elif|else|end|break|continue|render|def|note)(\s*((.|\\n)*?)\s*)?%s" % (re.escape(startdelim), re.escape(enddelim)) 
     1169        pattern = u"{0}(printx|print|code|for|if|elif|else|end|break|continue|render|def|note)(\s*((.|\\n)*?)\s*)?{1}".format(re.escape(startdelim), re.escape(enddelim)) 
    12281170        pos = 0 
    12291171        for match in re.finditer(pattern, source): 
     
    13321274                                raise BlockError("enddef doesn't match any def") 
    13331275                        else: 
    1334                             raise BlockError("illegal end value %r" % code) 
     1276                            raise BlockError("illegal end value {0!r}".format(code)) 
    13351277                    last = stack.pop() 
    13361278                    if last[0] == "if": 
     
    13581300                    stack.append(("def", location)) 
    13591301                else: # Can't happen 
    1360                     raise ValueError("unknown tag %r" % location.type) 
     1302                    raise ValueError("unknown tag {0!r}".format(location.type)) 
    13611303            except Exception, exc: 
    13621304                newexc = Error(location) # FIXME: use ``raise ... from`` in Python 3.0 
     
    13771319 
    13781320    def __repr__(self): 
    1379         return "<%s.%s object with %d opcodes at 0x%x>" % (self.__class__.__module__, self.__class__.__name__, len(self.opcodes), id(self)) 
     1321        return "<{0}.{1} object with {2} opcodes at {3:#x}>".format(self.__class__.__module__, self.__class__.__name__, len(self.opcodes), id(self)) 
    13801322 
    13811323 
     
    13981340 
    13991341    def __repr__(self): 
    1400         return "%s(%r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.type) 
     1342        return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.start, self.end, self.type) 
    14011343 
    14021344    def __str__(self): 
     
    14201362 
    14211363    def __repr__(self): 
    1422         return "%s(%r, %r)" % (self.__class__.__name__, self.start, self.end) 
     1364        return "{0}({1!r}, {2!r})".format(self.__class__.__name__, self.start, self.end) 
    14231365 
    14241366    def compile(self, template): 
    14251367        r = template._allocreg() 
    1426         template.opcode("load%s" % self.type, r1=r) 
     1368        template.opcode("load{0}".format(self.type), r1=r) 
    14271369        return r 
    14281370 
     
    14491391 
    14501392    def __repr__(self): 
    1451         return "%s(%r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.value) 
     1393        return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.start, self.end, self.value) 
    14521394 
    14531395    def compile(self, template): 
    14541396        r = template._allocreg() 
    1455         template.opcode("load%s" % self.type, r1=r, arg=unicode(self.value)) 
     1397        template.opcode("load{0}".format(self.type), r1=r, arg=unicode(self.value)) 
    14561398        return r 
    14571399 
     
    14661408    def compile(self, template): 
    14671409        r = template._allocreg() 
    1468         template.opcode("load%s" % self.type, r1=r, arg=repr(self.value)) 
     1410        template.opcode("load{0}".format(self.type), r1=r, arg=repr(self.value)) 
    14691411        return r 
    14701412 
     
    14791421    def compile(self, template): 
    14801422        r = template._allocreg() 
    1481         template.opcode("load%s" % self.type, r1=r, arg=self.value.isoformat()) 
     1423        template.opcode("load{0}".format(self.type), r1=r, arg=self.value.isoformat()) 
    14821424        return r 
    14831425 
     
    14881430    def compile(self, template): 
    14891431        r = template._allocreg() 
    1490         template.opcode("load%s" % self.type, r1=r, arg="%02x%02x%02x%02x" % self.value) 
     1432        template.opcode("load{0}".format(self.type), r1=r, arg="{0:02x}{1:02x}{2:02x}{3:02x}".format(*self.value)) 
    14911433        return r 
    14921434 
     
    14981440 
    14991441    def __repr__(self): 
    1500         return "%s(%r, %r, %s)" % (self.__class__.__name__, self.start, self.end, repr(self.items)[1:-1]) 
     1442        return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.start, self.end, repr(self.items)[1:-1]) 
    15011443 
    15021444    def compile(self, template): 
     
    15161458 
    15171459    def __repr__(self): 
    1518         return "%s(%r, %r, %s)" % (self.__class__.__name__, self.start, self.end, repr(self.items)[1:-1]) 
     1460        return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.start, self.end, repr(self.items)[1:-1]) 
    15191461 
    15201462    def compile(self, template): 
     
    15441486 
    15451487    def __repr__(self): 
    1546         return "%s(%r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.name) 
     1488        return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.start, self.end, self.name) 
    15471489 
    15481490    def compile(self, template): 
     
    15591501 
    15601502    def __repr__(self): 
    1561         return "%s(%r, %r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.iter, self.cont) 
     1503        return "{0}({1!r}, {2!r}, {3!r}, {4!r})".format(self.__class__.__name__, self.start, self.end, self.iter, self.cont) 
    15621504 
    15631505    def compile(self, template): 
     
    15851527 
    15861528    def __repr__(self): 
    1587         return "%s(%r, %r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.obj, self.attr) 
     1529        return "{0}({1!r}, {2!r}, {3!r}, {4!r})".format(self.__class__.__name__, self.start, self.end, self.obj, self.attr) 
    15881530 
    15891531    def compile(self, template): 
     
    16011543 
    16021544    def __repr__(self): 
    1603         return "%s(%r, %r, %r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.obj, self.index1, self.index2) 
     1545        return "{0}({1!r}, {2!r}, {3!r}, {4!r}, {5!r})".format(self.__class__.__name__, self.start, self.end, self.obj, self.index1, self.index2) 
    16041546 
    16051547    def compile(self, template): 
     
    16211563 
    16221564    def __repr__(self): 
    1623         return "%s(%r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.obj) 
     1565        return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.start, self.end, self.obj) 
    16241566 
    16251567    def compile(self, template): 
     
    16461588 
    16471589    def __repr__(self): 
    1648         return "%s(%r, %r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.obj1, self.obj2) 
     1590        return "{0}({1!r}, {2!r}, {3!r}, {4!r})".format(self.__class__.__name__, self.start, self.end, self.obj1, self.obj2) 
    16491591 
    16501592    def compile(self, template): 
     
    17411683 
    17421684    def __repr__(self): 
    1743         return "%s(%r, %r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.name, self.value) 
     1685        return "{0}({1!r}, {2!r}, {3!r}, {4!r})".format(self.__class__.__name__, self.start, self.end, self.name, self.value) 
    17441686 
    17451687    def compile(self, template): 
     
    17831725 
    17841726    def __repr__(self): 
    1785         return "%s(%r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.name) 
     1727        return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.start, self.end, self.name) 
    17861728 
    17871729    def compile(self, template): 
     
    17971739    def __repr__(self): 
    17981740        if self.args: 
    1799             return "%s(%r, %r, %r, %s)" % (self.__class__.__name__, self.start, self.end, self.name, repr(self.args)[1:-1]) 
     1741            return "{0}({1!r}, {2!r}, {3!r}, {4})".format(self.__class__.__name__, self.start, self.end, self.name, repr(self.args)[1:-1]) 
    18001742        else: 
    1801             return "%s(%r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.name) 
     1743            return "{0}({1!r}, {2!r}, {3!r})".format(self.__class__.__name__, self.start, self.end, self.name) 
    18021744 
    18031745    def compile(self, template): 
     
    18071749            return r 
    18081750        elif len(self.args) > 4: 
    1809             raise ValueError("%d function arguments not supported" % len(self.args)) 
     1751            raise ValueError("{0} function arguments not supported".format(len(self.args))) 
    18101752        else: 
    18111753            rs = [arg.compile(template) for arg in self.args] 
    1812             template.opcode("callfunc%d" % len(self.args), rs[0], *rs, **dict(arg=self.name.name)) # FIXME: Replace **dict(arg=) with arg= in Python 2.6? 
     1754            template.opcode("callfunc{0}".format(len(self.args)), rs[0], *rs, **dict(arg=self.name.name)) # FIXME: Replace **dict(arg=) with arg= in Python 2.6? 
    18131755            for i in xrange(1, len(self.args)): 
    18141756                template._freereg(rs[i]) 
     
    18251767    def __repr__(self): 
    18261768        if self.args: 
    1827             return "%s(%r, %r, %r, %r, %s)" % (self.__class__.__name__, self.start, self.end, self.name, self.obj, repr(self.args)[1:-1]) 
     1769            return "{0}({1!r}, {2!r}, {3!r}, {4!r}, {5})".format(self.__class__.__name__, self.start, self.end, self.name, self.obj, repr(self.args)[1:-1]) 
    18281770        else: 
    1829             return "%s(%r, %r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.name, self.obj) 
     1771            return "{0}({1!r}, {2!r}, {3!r}, {4!r})".format(self.__class__.__name__, self.start, self.end, self.name, self.obj) 
    18301772 
    18311773    def compile(self, template): 
    18321774        if len(self.args) > 3: 
    1833             raise ValueError("%d method arguments not supported" % len(self.args)) 
     1775            raise ValueError("{0} method arguments not supported".format(len(self.args))) 
    18341776        ro = self.obj.compile(template) 
    18351777        rs = [arg.compile(template) for arg in self.args] 
    1836         template.opcode("callmeth%d" % len(self.args), ro, ro, *rs, **dict(arg=self.name.name)) 
     1778        template.opcode("callmeth{0}".format(len(self.args)), ro, ro, *rs, **dict(arg=self.name.name)) 
    18371779        for r in rs: 
    18381780            template._freereg(r) 
     
    18481790 
    18491791    def __repr__(self): 
    1850         return "%s(%r, %r, %r, %r, %r)" % (self.__class__.__name__, self.start, self.end, self.name, self.obj, self.args) 
     1792        return "{0}({1!r}, {2!r}, {3!r}, {4!r}, {5!r})".format(self.__class__.__name__, self.start, self.end, self.name, self.obj, self.args) 
    18511793 
    18521794    def compile(self, template): 
     
    18791821 
    18801822    def __repr__(self): 
    1881         return "%s(%r, %r, %r, %s)" % (self.__class__.__name__, self.start, self.end, self.template, repr(self.variables)[1:-1]) 
     1823        return "{0}({1!r}, {2!r}, {3!r}, {4})".format(self.__class__.__name__, self.start, self.end, self.template, repr(self.variables)[1:-1]) 
    18821824 
    18831825    def compile(self, template): 
     
    21192061            return Color(start, end, value) 
    21202062        else: 
    2121             raise TypeError("can't convert %r" % value) 
     2063            raise TypeError("can't convert {0!r}".format(value)) 
    21222064 
    21232065    # To implement operator precedence, each expression rule has the precedence in its name. The highest precedence is 11 for atomic expressions. 
     
    25342476    elif isinstance(obj, color.Color): 
    25352477        if obj[3] == 0xff: 
    2536             s = "#%02x%02x%02x" % (obj[0], obj[1], obj[2]) 
     2478            s = "#{0:02x}{1:02x}{2:02x}".format(obj[0], obj[1], obj[2]) 
    25372479            if s[1]==s[2] and s[3]==s[4] and s[5]==s[6]: 
    2538                 return "#%s%s%s" % (s[1], s[3], s[5]) 
     2480                return "#{0}{1}{2}".format(s[1], s[3], s[5]) 
    25392481            return s 
    25402482        else: 
    2541             s = "#%02x%02x%02x%02x" % obj 
     2483            s = "#{0:02x}{1:02x}{2:02x}{3:02x}".format(*obj) 
    25422484            if s[1]==s[2] and s[3]==s[4] and s[5]==s[6] and s[7]==s[8]: 
    2543                 return "#%s%s%s%s" % (s[1], s[3], s[5], s[7]) 
     2485                return "#{0}{1}{2}{4}".format(s[1], s[3], s[5], s[7]) 
    25442486            return s 
    25452487    elif isinstance(obj, list): 
    2546         return u"[%s]" % u", ".join(_repr(item) for item in obj) 
     2488        return u"[{0}]".format(u", ".join(_repr(item) for item in obj)) 
    25472489    elif isinstance(obj, dict): 
    2548         return u"{%s}" % u", ".join(u"%s: %s" % (_repr(key), _repr(value)) for (key, value) in obj.iteritems()) 
     2490        return u"{{0}}".format(u", ".join(u"{0}: {1}".format(_repr(key), _repr(value)) for (key, value) in obj.iteritems())) 
    25492491    else: 
    25502492        return unicode(repr(obj)) 
     
    25722514        obj = _repr(obj) 
    25732515    if any(c in obj for c in ',"\n'): 
    2574         return u'"%s"' % obj.replace('"', '""') 
     2516        return u'"{0}"'.format(obj.replace('"', '""')) 
    25752517    return obj 
    25762518 
     
    26032545        return u"color" 
    26042546    return None 
     2547 
     2548 
     2549def _mimeformat(obj): 
     2550    """ 
     2551    Helper for the ``mimeformat`` method. 
     2552    """ 
     2553    weekdayname = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun") 
     2554    monthname = (None, "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec") 
     2555    return "{1}, {0.day:02d} {2:3} {0.year:4} {0.hour:02}:{0.minute:02}:{0.second:02} GMT".format(obj, weekdayname[obj.weekday()], monthname[obj.month]) 
  • src/ll/url.py

    r3930 r3933  
    5353 
    5454try: 
    55     import py 
     55    import execnet 
    5656except ImportError: 
    57     py = None 
     57    execnet = None 
    5858 
    5959try: 
     
    9090    :var:`dt` is a :class:`datetime.datetime` object in UTC. 
    9191    """ 
    92     return "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (weekdayname[dt.weekday()], dt.day, monthname[dt.month], dt.year, dt.hour, dt.minute, dt.second) 
     92    return "{1}, {0.day:02d} {2:3} {0.year:4} {0.hour:02}:{0.minute:02}:{0.second:02} GMT".format(dt, weekdayname[dt.weekday()], monthname[dt.month]) 
    9393 
    9494 
     
    101101        for i in xrange(l): 
    102102            segment = path_segments[i] 
    103             if segment==(".",) or segment==("",): 
     103            if not segment: 
    104104                if i==l-1: 
    105                     new_path_segments.append(("",)) 
    106             elif segment==("..",) and len(new_path_segments) and new_path_segments[-1]!=("..",): 
     105                    new_path_segments.append("") 
     106            elif segment==".." and len(new_path_segments) and new_path_segments[-1] != "..": 
    107107                new_path_segments.pop() 
    108108                if i==l-1: 
    109                     new_path_segments.append(("",)) 
     109                    new_path_segments.append("") 
    110110            else: 
    111111                new_path_segments.append(segment) 
     
    130130additionalsafe = "[]" 
    131131safe = alphanum + mark + additionalsafe 
    132 pathsafe = safe + ":@&=+$," + "|" # add "|" for Windows paths 
     132pathsafe = safe + ":@&=+$,;" + "|" # add "|" for Windows paths 
    133133querysafe = alphanum 
    134134fragsafe = alphanum 
     
    151151                values.sort() 
    152152            for value in values: 
    153                 res.append("%s=%s" % (_escape(name, querysafe), _escape(value, querysafe))) 
     153                res.append("{0}={1}".format(_escape(name, querysafe), _escape(value, querysafe))) 
    154154        return "&".join(res) 
    155155    else: 
     
    353353        Return the MIME headers for the file/resource :var:`url`. 
    354354        """ 
    355         return mimetools.Message( 
    356             cStringIO.StringIO( 
    357                 "Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n" % 
    358                 (self.mimetype(url), self.size(url), httpdate(self.mdate(url))) 
    359             ) 
    360         ) 
     355        return mimetools.Message(cStringIO.StringIO("Content-Type: {0}\nContent-Length: {1}\nLast-modified: {2}\n".format(self.mimetype(url), self.size(url), httpdate(self.mdate(url))))) 
    361356 
    362357    @misc.notimplemented 
     
    488483                Request body to use for an HTTP POST request. 
    489484 
    490             :var:`remotepython` : string 
     485            :var:`remotepython` : string or ``None`` 
    491486                Name of the Python interpreter to use on the remote side (used by 
    492487                ``ssh`` URLs) 
    493488 
    494             :var:`ssh_config` : string 
    495                 SSH configuration file (used by ``ssh`` URLs) 
     489            :var:`nice` : int or ``None`` 
     490                Nice level for the remote python (used by ``ssh`` URLs) 
    496491        """ 
    497492 
     
    658653 
    659654 
    660 if py is not None: 
    661     class SshConnection(Connection): 
    662         remote_code = py.code.Source(""" 
    663             import os, urllib, cPickle, fnmatch 
    664  
    665             os.stat_float_times(True) 
    666             files = {} 
    667             iterators = {} 
    668  
    669             def ownergroup(filename, owner=None, group=None): 
    670                 if owner is not None or group is not None: 
    671                     if owner is None or group is None: 
    672                         if isinstance(filename, basestring): 
    673                             stat = os.stat(filename) 
     655class SshConnection(Connection): 
     656    remote_code = """ 
     657        import os, urllib, cPickle, fnmatch 
     658 
     659        os.stat_float_times(True) 
     660        files = {} 
     661        iterators = {} 
     662 
     663        def ownergroup(filename, owner=None, group=None): 
     664            if owner is not None or group is not None: 
     665                if owner is None or group is None: 
     666                    if isinstance(filename, basestring): 
     667                        stat = os.stat(filename) 
     668                    else: 
     669                        stat = os.fstat(files[filename].fileno()) 
     670                if owner is None: 
     671                    owner = stat.st_uid 
     672                elif isinstance(owner, basestring): 
     673                    import pwd 
     674                    owner = pwd.getpwnam(owner)[2] 
     675 
     676                if group is None: 
     677                    group = stat.st_gid 
     678                elif isinstance(group, basestring): 
     679                    import grp 
     680                    group = grp.getgrnam(group)[2] 
     681            return (owner, group) 
     682 
     683        def _walk(base, name, pattern, which): 
     684            if name: 
     685                fullname = os.path.join(base, name) 
     686            else: 
     687                fullname = base 
     688            for childname in os.listdir(fullname): 
     689                ful4childname = os.path.join(fullname, childname) 
     690                relchildname = os.path.join(name, childname) 
     691                isdir = os.path.isdir(ful4childname) 
     692                if (pattern is None or fnmatch.fnmatch(childname, pattern)) and which[isdir]: 
     693                    url = urllib.pathname2url(relchildname) 
     694                    if isdir: 
     695                        url += "/" 
     696                    yield url 
     697                if isdir: 
     698                    for subchild in _walk(base, relchildname, pattern, which): 
     699                        yield subchild 
     700     
     701        def walk(filename, pattern=None): 
     702            return _walk(filename, "", pattern, (True, True)) 
     703 
     704        def walkfiles(filename, pattern=None): 
     705            return _walk(filename, "", pattern, (True, False)) 
     706 
     707        def walkdirs(filename, pattern=None): 
     708            return _walk(filename, "", pattern, (False, True)) 
     709 
     710        while True: 
     711            (filename, cmdname, args, kwargs) = channel.receive() 
     712            if isinstance(filename, basestring): 
     713                filename = os.path.expanduser(urllib.url2pathname(filename)) 
     714            data = None 
     715            try: 
     716                if cmdname == "open": 
     717                    try: 
     718                        stream = open(filename, *args, **kwargs) 
     719                    except IOError, exc: 
     720                        if "w" not in args[0] or exc[0] != 2: # didn't work for some other reason than a non existing directory 
     721                            raise 
     722                        (splitpath, splitname) = os.path.split(filename) 
     723                        if splitpath: 
     724                            os.makedirs(splitpath) 
     725                            stream = open(filename, *args, **kwargs) 
    674726                        else: 
    675                             stat = os.fstat(files[filename].fileno()) 
    676                     if owner is None: 
    677                         owner = stat.st_uid 
    678                     elif isinstance(owner, basestring): 
    679                         import pwd 
    680                         owner = pwd.getpwnam(owner)[2] 
    681  
    682                     if group is None: 
    683                         group = stat.st_gid 
    684                     elif isinstance(group, basestring): 
    685                         import grp 
    686                         group = grp.getgrnam(group)[2] 
    687                 return (owner, group) 
    688  
    689             def _walk(base, name, pattern, which): 
    690                 if name: 
    691                     fullname = os.path.join(base, name) 
     727                            raise # we don't have a directory to make so pass the error on 
     728                    data = id(stream) 
     729                    files[data] = stream 
     730                elif cmdname == "stat": 
     731                    if isinstance(filename, basestring): 
     732                        data = tuple(os.stat(filename)) 
     733                    else: 
     734                        data = tuple(os.fstat(files[filename].fileno())) 
     735                elif cmdname == "lstat": 
     736                    data = os.lstat(filename) 
     737                elif cmdname == "close": 
     738                    try: 
     739                        stream = files[filename] 
     740                    except KeyError: 
     741                        pass 
     742                    else: 
     743                        stream.close() 
     744                        del files[filename] 
     745                elif cmdname == "chmod": 
     746                    data = os.chmod(filename, *args, **kwargs) 
     747                elif cmdname == "chown": 
     748                    (owner, group) = ownergroup(filename, *args, **kwargs) 
     749                    if owner is not None: 
     750                        data = os.chown(filename, owner, group) 
     751                elif cmdname == "lchown": 
     752                    (owner, group) = ownergroup(filename, *args, **kwargs) 
     753                    if owner is not None: 
     754                        data = os.lchown(filename, owner, group) 
     755                elif cmdname == "uid": 
     756                    stat = os.stat(filename) 
     757                    data = stat.st_uid 
     758                elif cmdname == "gid": 
     759                    stat = os.stat(filename) 
     760                    data = stat.st_gid 
     761                elif cmdname == "owner": 
     762                    import pwd 
     763                    stat = os.stat(filename) 
     764                    data = pwd.getpwuid(stat.st_uid)[0] 
     765                elif cmdname == "group": 
     766                    import grp 
     767                    stat = os.stat(filename) 
     768                    data = grp.getgrgid(stat.st_gid)[0] 
     769                elif cmdname == "exists": 
     770                    data = os.path.exists(filename) 
     771                elif cmdname == "isfile": 
     772                    data = os.path.isfile(filename) 
     773                elif cmdname == "isdir": 
     774                    data = os.path.isdir(filename) 
     775                elif cmdname == "islink": 
     776                    data = os.path.islink(filename) 
     777                elif cmdname == "ismount": 
     778                    data = os.path.ismount(filename) 
     779                elif cmdname == "access": 
     780                    data = os.access(filename, *args, **kwargs) 
     781                elif cmdname == "remove": 
     782                    data = os.remove(filename) 
     783                elif cmdname == "rmdir": 
     784                    data = os.rmdir(filename) 
     785                elif cmdname == "rename": 
     786                    data = os.rename(filename, os.path.expanduser(args[0])) 
     787                elif cmdname == "link": 
     788                    data = os.link(filename, os.path.expanduser(args[0])) 
     789                elif cmdname == "symlink": 
     790                    data = os.symlink(filename, os.path.expanduser(args[0])) 
     791                elif cmdname == "chdir": 
     792                    data = os.chdir(filename) 
     793                elif cmdname == "mkdir": 
     794                    data = os.mkdir(filename) 
     795                elif cmdname == "makedirs": 
     796                    data = os.makedirs(filename) 
     797                elif cmdname == "makefifo": 
     798                    data = os.makefifo(filename) 
     799                elif cmdname == "listdir": 
     800                    data = [] 
     801                    for f in os.listdir(filename): 
     802                        if args[0] is None or fnmatch.fnmatch(f, args[0]): 
     803                            data.append((os.path.isdir(os.path.join(filename, f)), f)) 
     804                elif cmdname == "files": 
     805                    data = [] 
     806                    for f in os.listdir(filename): 
     807                        if args[0] is None or fnmatch.fnmatch(f, args[0]): 
     808                            if os.path.isfile(os.path.join(filename, f)): 
     809                                data.append(f) 
     810                elif cmdname == "dirs": 
     811                    data = [] 
     812                    for f in os.listdir(filename): 
     813                        if args[0] is None or fnmatch.fnmatch(f, args[0]): 
     814                            if os.path.isdir(os.path.join(filename, f)): 
     815                                data.append(f) 
     816                elif cmdname == "walk": 
     817                    iterator = walk(filename, *args, **kwargs) 
     818                    data = id(iterator) 
     819                    iterators[data] = iterator 
     820                elif cmdname == "walkfiles": 
     821                    iterator = walkfiles(filename, *args, **kwargs) 
     822                    data = id(iterator) 
     823                    iterators[data] = iterator 
     824                elif cmdname == "walkdirs": 
     825                    iterator = walkdirs(filename, *args, **kwargs) 
     826                    data = id(iterator) 
     827                    iterators[data] = iterator 
     828                elif cmdname == "iteratornext": 
     829                    try: 
     830                        data = iterators[filename].next() 
     831                    except StopIteration: 
     832                        del iterators[filename] 
     833                        raise 
    692834                else: 
    693                     fullname = base 
    694                 for childname in os.listdir(fullname): 
    695                     ful4childname = os.path.join(fullname, childname) 
    696                     relchildname = os.path.join(name, childname) 
    697                     isdir = os.path.isdir(ful4childname) 
    698                     if (pattern is None or fnmatch.fnmatch(childname, pattern)) and which[isdir]: 
    699                         url = urllib.pathname2url(relchildname) 
    700                         if isdir: 
    701                             url += "/" 
    702                         yield url 
    703                     if isdir: 
    704                         for subchild in _walk(base, relchildname, pattern, which): 
    705                             yield subchild 
    706          
    707             def walk(filename, pattern=None): 
    708                 return _walk(filename, "", pattern, (True, True)) 
    709  
    710             def walkfiles(filename, pattern=None): 
    711                 return _walk(filename, "", pattern, (True, False)) 
    712  
    713             def walkdirs(filename, pattern=None): 
    714                 return _walk(filename, "", pattern, (False, True)) 
    715  
    716             while True: 
    717                 (filename, cmdname, args, kwargs) = channel.receive() 
    718                 if isinstance(filename, basestring): 
    719                     filename = os.path.expanduser(urllib.url2pathname(filename)) 
    720                 data = None 
    721                 try: 
    722                     if cmdname == "open": 
    723                         try: 
    724                             stream = open(filename, *args, **kwargs) 
    725                         except IOError, exc: 
    726                             if "w" not in args[0] or exc[0] != 2: # didn't work for some other reason than a non existing directory 
    727                                 raise 
    728                             (splitpath, splitname) = os.path.split(filename) 
    729                             if splitpath: 
    730                                 os.makedirs(splitpath) 
    731                                 stream = open(filename, *args, **kwargs) 
    732                             else: 
    733                                 raise # we don't have a directory to make so pass the error on 
    734                         data = id(stream) 
    735                         files[data] = stream 
    736                     elif cmdname == "stat": 
    737                         if isinstance(filename, basestring): 
    738                             data = tuple(os.stat(filename)) 
    739                         else: 
    740                             data = tuple(os.fstat(files[filename].fileno())) 
    741                     elif cmdname == "lstat": 
    742                         data = os.lstat(filename) 
    743                     elif cmdname == "close": 
    744                         try: 
    745                             stream = files[filename] 
    746                         except KeyError: 
    747                             pass 
    748                         else: 
    749                             stream.close() 
    750                             del files[filename] 
    751                     elif cmdname == "chmod": 
    752                         data = os.chmod(filename, *args, **kwargs) 
    753                     elif cmdname == "chown": 
    754                         (owner, group) = ownergroup(filename, *args, **kwargs) 
    755                         if owner is not None: 
    756                             data = os.chown(filename, owner, group) 
    757                     elif cmdname == "lchown": 
    758                         (owner, group) = ownergroup(filename, *args, **kwargs) 
    759                         if owner is not None: 
    760                             data = os.lchown(filename, owner, group) 
    761                     elif cmdname == "uid": 
    762                         stat = os.stat(filename) 
    763                         data = stat.st_uid 
    764                     elif cmdname == "gid": 
    765                         stat = os.stat(filename) 
    766                         data = stat.st_gid 
    767                     elif cmdname == "owner": 
    768                         import pwd 
    769                         stat = os.stat(filename) 
    770                         data = pwd.getpwuid(stat.st_uid)[0] 
    771                     elif cmdname == "group": 
    772                         import grp 
    773                         stat = os.stat(filename) 
    774                         data = grp.getgrgid(stat.st_gid)[0] 
    775                     elif cmdname == "exists": 
    776                         data = os.path.exists(filename) 
    777                     elif cmdname == "isfile": 
    778                         data = os.path.isfile(filename) 
    779                     elif cmdname == "isdir": 
    780                         data = os.path.isdir(filename) 
    781                     elif cmdname == "islink": 
    782                         data = os.path.islink(filename) 
    783                     elif cmdname == "ismount": 
    784                         data = os.path.ismount(filename) 
    785                     elif cmdname == "access": 
    786                         data = os.access(filename, *args, **kwargs) 
    787                     elif cmdname == "remove": 
    788                         data = os.remove(filename) 
    789                     elif cmdname == "rmdir": 
    790                         data = os.rmdir(filename) 
    791                     elif cmdname == "rename": 
    792                         data = os.rename(filename, os.path.expanduser(args[0])) 
    793                     elif cmdname == "link": 
    794                         data = os.link(filename, os.path.expanduser(args[0])) 
    795                     elif cmdname == "symlink": 
    796                         data = os.symlink(filename, os.path.expanduser(args[0])) 
    797                     elif cmdname == "chdir": 
    798                         data = os.chdir(filename) 
    799                     elif cmdname == "mkdir": 
    800                         data = os.mkdir(filename) 
    801                     elif cmdname == "makedirs": 
    802                         data = os.makedirs(filename) 
    803                     elif cmdname == "makefifo": 
    804                         data = os.makefifo(filename) 
    805                     elif cmdname == "listdir": 
    806                         data = [] 
    807                         for f in os.listdir(filename): 
    808                             if args[0] is None or fnmatch.fnmatch(f, args[0]): 
    809                                 data.append((os.path.isdir(os.path.join(filename, f)), f)) 
    810                     elif cmdname == "files": 
    811                         data = [] 
    812                         for f in os.listdir(filename): 
    813                             if args[0] is None or fnmatch.fnmatch(f, args[0]): 
    814                                 if os.path.isfile(os.path.join(filename, f)): 
    815                                     data.append(f) 
    816                     elif cmdname == "dirs": 
    817                         data = [] 
    818                         for f in os.listdir(filename): 
    819                             if args[0] is None or fnmatch.fnmatch(f, args[0]): 
    820                                 if os.path.isdir(os.path.join(filename, f)): 
    821                                     data.append(f) 
    822                     elif cmdname == "walk": 
    823                         iterator = walk(filename, *args, **kwargs) 
    824                         data = id(iterator) 
    825                         iterators[data] = iterator 
    826                     elif cmdname == "walkfiles": 
    827                         iterator = walkfiles(filename, *args, **kwargs) 
    828                         data = id(iterator) 
    829                         iterators[data] = iterator 
    830                     elif cmdname == "walkdirs": 
    831                         iterator = walkdirs(filename, *args, **kwargs) 
    832                         data = id(iterator) 
    833                         iterators[data] = iterator 
    834                     elif cmdname == "iteratornext": 
    835                         try: 
    836                             data = iterators[filename].next() 
    837                         except StopIteration: 
    838                             del iterators[filename] 
    839                             raise 
    840                     else: 
    841                         data = getattr(files[filename], cmdname) 
    842                         data = data(*args, **kwargs) 
    843                 except Exception, exc: 
    844                     if exc.__class__.__module__ != "exceptions": 
    845                         raise 
    846                     channel.send((True, cPickle.dumps(exc))) 
    847                 else: 
    848                     channel.send((False, data)) 
    849         """) 
    850         def __init__(self, context, server, remotepython="python", ssh_config=None): 
    851             # We don't have to store the context (this avoids cycles) 
    852             self.server = server 
    853             gateway = py.execnet.SshGateway(server, remotepython=remotepython, ssh_config=ssh_config) 
     835                    data = getattr(files[filename], cmdname) 
     836                    data = data(*args, **kwargs) 
     837            except Exception, exc: 
     838                if exc.__class__.__module__ != "exceptions": 
     839                    raise 
     840                channel.send((True, cPickle.dumps(exc))) 
     841            else: 
     842                channel.send((False, data)) 
     843    """ 
     844    def __init__(self, context, server, remotepython=None, nice=None): 
     845        # We don't have to store the context (this avoids cycles) 
     846        self.server = server 
     847        self.remotepython = remotepython 
     848        self.nice = nice 
     849        self._channel = None 
     850 
     851    def close(self): 
     852        if self._channel is not None and not self._channel.isclosed(): 
     853            self._channel.close() 
     854            self._channel.gateway.exit() 
     855            self._channel.gateway.join() 
     856 
     857    def _url2filename(self, url): 
     858        if url.scheme != "ssh": 
     859            raise ValueError("URL {0!r} is not an ssh URL".format(url)) 
     860        filename = str(url.path) 
     861        if filename.startswith("/~"): 
     862            filename = filename[1:] 
     863        return filename 
     864 
     865    def _send(self, filename, cmd, *args, **kwargs): 
     866        if self._channel is None: 
     867            server = "ssh={0}".format(self.server) 
     868            if self.remotepython is not None: 
     869                server += "//python={0}".format(self.remotepython) 
     870            if self.nice is not None: 
     871                server += "//nice={0}".format(self.nice) 
     872            gateway = execnet.makegateway(server) # This requires ``execnet`` (http://codespeak.net/execnet/) 
    854873            self._channel = gateway.remote_exec(self.remote_code) 
    855  
    856         def close(self): 
    857             if not self._channel.isclosed(): 
    858                 self._channel.close() 
    859                 self._channel.gateway.exit() 
    860                 self._channel.gateway.join() 
    861  
    862         def _url2filename(self, url): 
    863             if url.scheme != "ssh": 
    864                 raise ValueError("URL %r is not an ssh URL" % url) 
    865             filename = str(url.path) 
    866             if filename.startswith("/~"): 
    867                 filename = filename[1:] 
    868             return filename 
    869  
    870         def _send(self, filename, cmd, *args, **kwargs): 
    871             self._channel.send((filename, cmd, args, kwargs)) 
    872             (isexc, data) = self._channel.receive() 
    873             if isexc: 
    874                 raise cPickle.loads(data) 
    875             else: 
    876                 return data 
    877  
    878         def stat(self, url): 
    879             filename = self._url2filename(url) 
    880             data = self._send(filename, "stat") 
    881             return os.stat_result(data) # channel returned a tuple => wrap it 
    882  
    883         def lstat(self): 
    884             filename = self._url2filename(url) 
    885             data = self._send(filename, "lstat") 
    886             return os.stat_result(data) # channel returned a tuple => wrap it 
    887  
    888         def chmod(self, url, mode): 
    889             return self._send(self._url2filename(url), "chmod", mode) 
    890  
    891         def chown(self, url, owner=None, group=None): 
    892             return self._send(self._url2filename(url), "chown", owner, group) 
    893  
    894         def lchown(self, url, owner=None, group=None): 
    895             return self._send(self._url2filename(url), "lchown", owner, group) 
    896  
    897         def chdir(self, url): 
    898             return self._send(self._url2filename(url), "chdir") 
    899  
    900         def mkdir(self, url, mode=0777): 
    901             return self._send(self._url2filename(url), "mkdir", mode) 
    902  
    903         def makedirs(self, url, mode=0777): 
    904             return self._send(self._url2filename(url), "makedirs", mode) 
    905  
    906         def uid(self, url): 
    907             return self._send(self._url2filename(url), "uid") 
    908  
    909         def gid(self, url): 
    910             return self._send(self._url2filename(url), "gid") 
    911  
    912         def owner(self, url): 
    913             return self._send(self._url2filename(url), "owner") 
    914  
    915         def group(self, url): 
    916             return self._send(self._url2filename(url), "group") 
    917  
    918         def exists(self, url): 
    919             return self._send(self._url2filename(url), "exists") 
    920  
    921         def isfile(self, url): 
    922             return self._send(self._url2filename(url), "isfile") 
    923  
    924         def isdir(self, url): 
    925             return self._send(self._url2filename(url), "isdir") 
    926  
    927         def islink(self, url): 
    928             return self._send(self._url2filename(url), "islink") 
    929  
    930         def ismount(self, url): 
    931             return self._send(self._url2filename(url), "ismount") 
    932  
    933         def access(self, url, mode): 
    934             return self._send(self._url2filename(url), "access", mode) 
    935  
    936         def remove(self, url): 
    937             return self._send(self._url2filename(url), "remove") 
    938  
    939         def rmdir(self, url): 
    940             return self._send(self._url2filename(url), "rmdir") 
    941  
    942         def _cmdwithtarget(self, cmdname, url, target): 
    943             filename = self._url2filename(url) 
    944             if not isinstance(target, URL): 
    945                 target = URL(target) 
    946             targetname = self._url2filename(target) 
    947             if target.server != url.server: 
    948                 raise OSError(errno.EXDEV, os.strerror(errno.EXDEV)) 
    949             return self._send(filename, cmdname, targetname) 
    950  
    951         def rename(self, url, target): 
    952             return self._cmdwithtarget("rename", url, target) 
    953  
    954         def link(self, url, target): 
    955             return self._cmdwithtarget("link", url, target) 
    956  
    957         def symlink(self, url, target): 
    958             return self._cmdwithtarget("symlink", url, target) 
    959  
    960         def listdir(self, url, pattern=None): 
    961             filename = self._url2filename(url) 
    962             result = [] 
    963             for (isdir, name) in self._send(filename, "listdir", pattern): 
    964                 name = urllib.pathname2url(name) 
    965                 if isdir: 
    966                     name += "/" 
    967                 result.append(URL(name)) 
    968             return result 
    969  
    970         def files(self, url, pattern=None): 
    971             filename = self._url2filename(url) 
    972             return [URL(urllib.pathname2url(name)) for name in self._send(filename, "files", pattern)] 
    973  
    974         def dirs(self, url, pattern=None): 
    975             filename = self._url2filename(url) 
    976             return [URL(urllib.pathname2url(name)+"/") for name in self._send(filename, "dirs", pattern)] 
    977  
    978         def walk(self, url, pattern=None): 
    979             filename = self._url2filename(url) 
    980