Contents

Source code for srcgen.python

from __future__ import with_statement
import pickle
import six
from contextlib import contextmanager
from srcgen.base import BaseModule, BaseE, R


class PythonModule(BaseModule):
    def comment(self, *lines, **kwargs):
        box = kwargs.pop("box", False)
        sep = kwargs.pop("sep", False)
        if sep and box:
            self._append("")
            self._append("#" * self._line_width)
        elif sep:
            self._append("#")
        elif box:
            self._append("#" * self._line_width)
        self._curr.extend("# %s" % (l,) for l in "\n".join(lines).splitlines())
        if sep and box:
            self._append("#" * self._line_width)
            self._append("")
        elif sep:
            self._append("#")
        elif box:
            self._append("#" * self._line_width)    
    
    #
    # Statements
    #
    def stmt(self, text, *args):
        self._append(text.format(*args) if args else text)
    def doc(self, text):
        self.stmt(repr(text))
    def break_(self):
        self.stmt("break")
    def continue_(self):
        self.stmt("continue")
    def return_(self, expr, *args):
        self.stmt("return %s" % (expr,), *args)
    def yield_(self, expr, *args):
        self.stmt("yield %s" % (expr,), *args)
    def raise_(self, expr, *args):
        self.stmt("raise %s" % (expr,), *args)
    def import_(self, modname):
        self.stmt("import %s" % (modname,))
    def from_(self, modname, *attrs):
        self.stmt("from %s import %s" % (modname, ", ".join(attrs)))
    def pass_(self):
        self.stmt("pass")
    
    #
    # Suites
    #
    @contextmanager
    def suite(self, headline, *args):
        self.stmt(headline, *args)
        prev = self._curr
        self._curr = []
        prev.append(self._curr)
        yield
        self._curr = prev
    def if_(self, cond, *args):
        return self.suite("if %s:" % (cond,), *args)
    def elif_(self, cond, *args):
        return self.suite("elif %s:" % (cond,), *args)
    def else_(self):
        return self.suite("else:")
    def for_(self, var, expr):
        return self.suite("for %s in %s:" % (var, expr))
    def while_(self, cond, *args):
        return self.suite("while %s:" % (cond,), *args)
    def try_(self):
        return self.suite("try:")
    def except_(self, exceptions, var = None):
        if var:
            return self.suite("except (%s) as %s:" % (", ".join(exceptions), var))
        else:
            return self.suite("except (%s):" % (", ".join(exceptions),))
    def finally_(self):
        return self.suite("finally:")
    @contextmanager
    def def_(self, name, *args):
        with self.suite("def %s(%s):" % (name, ", ".join(str(a) for a in args))): yield
        self.sep()

    @contextmanager
    def class_(self, name, bases = ("object",)):
        if isinstance(bases, six.string_types):
            bases = (bases,)
        with self.suite("class %s(%s):" % (name, ", ".join(bases,))): yield
        self.sep()

    @contextmanager
    def cython(self):
        mod = CythonModule()
        mod._curr = self._curr
        yield mod

    def method(self, name, *args):
        args = ("self",) + args
        return self.def_(name, *args)
    def classmethod(self, name, *args):
        args = ("cls",) + args
        self.stmt("@classmethod")
        return self.def_(name, *args)
    def staticmethod(self, name, *args):
        self.stmt("@staticmethod")
        return self.def_(name, *args)


class CythonModule(PythonModule):
    def __init__(self, *args, **kwargs):
        PythonModule.__init__(self, *args, **kwargs)
        self._in_cdef = False
        
    @property
    def cdef(self):
        self._in_cdef = True
        return self
    
    @contextmanager
    def __call__(self, name, *args):
        assert self._in_cdef
        with self.suite("%s(%s):" % (name, ", ".join(str(a) for a in args))): yield
        self.sep()
    
    def stmt(self, text, *args):
        in_cdef = self._in_cdef
        self._in_cdef = False
        PythonModule.stmt(self, ("cdef " + text) if in_cdef else text, *args)
    
    def typedef(self, type, newname):
        self.stmt("ctypedef %s %s" % (type, newname))
    
    @contextmanager
    def suite(self, text, *args):
        in_cdef = self._in_cdef
        self._in_cdef = False
        with PythonModule.suite(self, ("cdef " + text) if in_cdef else text, *args): yield
    
    def cppclass(self, name, bases = ()):
        return self.suite("cppclass %s:" % (name))
    
    @contextmanager
    def extern(self, from_ = None, namespace = None):
        head = "extern"
        if from_:
            head += ' from "%s"' % (repr(from_)[1:-1],)
        if namespace:
            head += ' namespace "%s"' % (repr(namespace)[1:-1],)
        with self.suite(head): yield
        self.sep()
    
    @contextmanager
    def struct(self, name):
        with self.suite("struct %s:" % (name,)): yield
        self.sep()
    @contextmanager
    def union(self, name):
        with self.suite("union %s:" % (name,)): yield
        self.sep()
    @contextmanager
    def enum(self, name):
        with self.suite("enum %s:" % (name,)): yield
        self.sep()

    @contextmanager
    def property(self, name):
        with self.suite("property %s:" % (name,)): yield
        self.sep()
    @contextmanager
    def get(self):
        with self.suite("def __get__(self):"): yield
        self.sep()
    @contextmanager
    def set(self):
        with self.suite("def __set__(self, value):"): yield
        self.sep()
    @contextmanager
    def get_property(self, name):
        with self.property(name):
            with self.get():
                yield


[docs]class P(object): """ Pickled object """ __slots__ = ["data"] def __init__(self, obj): self.data = "pickle.loads(%r)" % (pickle.dumps(obj),) def __str__(self): return self.data __repr__ = __str__
class E(BaseE): __slots__ = [] def __floordiv__(self, other): return E("(%r // %r)" % (self, other)) def __or__(self, other): return E("(%r or %r)" % (self, other)) def __and__(self, other): return E("(%r and %r)" % (self, other)) def __rfloordiv__(self, other): return E("(%r // %r)" % (other, self)) def __ror__(self, other): return E("(%r or %r)" % (other, self)) def __rand__(self, other): return E("(%r and %r)" % (other, self)) def __inv__(self): return E("not %r" % (self,)) __invert__ = __inv__ def __call__(self, *args, **kwargs): textargs = "" if args: textargs += ", ".join(repr(a) for a in args) if kwargs: if args: textargs += ", " textargs += ",".join("%s = %r" % (k, v) for k, v in kwargs.items()) return E("%r(%s)" % (self, textargs))

Contents