code:

# terrible regex dsl for python, completely untested
# no attempt is made to eliminate redundant grouping
# terrible abuses of operator overloading ahead
# docs:
# use Rx(s) to create a regex matching s literally
# Rx[...] creates charclasses, use slices for ranges
# e.g. Rx['a':'z', 'A':'Z', '_'] === [a-zA-Z_]
# + is concatenation
# | is |
# use r.group() to create a group around a regex,
# use r.group(name) to create a named one
# unary + is +
# ~ is ?
# r.repeat() is *
# r * i matches i repetitions
# r * (i, j) matches between i and j repetitions
# unary minus creates non-greedy matches after
# using any of the previous 5 operations
# any methods that work on a normal python regex
# should also work on an Rx
# examples:
# Rx['a':'z', 'A':'Z', '_'] + Rx['a':'z', 'A':'Z', '0':'9', '_'].repeat()
#   === "[a-zA-Z_][a-zA-Z0-9_]*
# +(Rx('w') | 'a').group() + -Rx['ab'].repeat()
#   === "(w|a)+[ab]*?"

import re

def _charclass_entry_to_str(s):
    if isinstance(s, str):
        return re.sub("(-|])", r"\\\1", s) if isinstance(s, str) else s
    elif isinstance(s, slice):
        for x in [s.start, s.stop]: assert(isinstance(x, str) and len(x) == 1)
        return s.start + "-" + s.stop
    else:
        assert(False)

class _TerribleHack(type):
    def __getitem__(cls, s):
        if isinstance(s, tuple):
            s = reduce(str.__add__, map(_charclass_entry_to_str, s))
        else:
            s = _charclass_entry_to_str(s)
        return cls("[" + s + "]", False)

class Rx(object):
    _identifier_regex = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
    __metaclass__ = _TerribleHack

    def _maybe_escape(self, s):
        if isinstance(s, Rx):
            return s.s
        elif isinstance(s, str):
            return re.escape(s)
        else:
            assert(False)

    def __init__(self, s="", escape=True):
        if isinstance(s, Rx):
            self.s = s.s
        elif isinstance(s, str):
            self.s = re.escape(s) if escape else s
        else:
            assert(False)
        self.rx = None

    def _wrap(self):
        return "(?:" + str(self) + ")"

    def group(self, name=None):
        if name:
            assert(self._identifier_regex.match(name))
            return self.__class__("(P<" + name + ">" + str(self) + ")", False)
        else:
            return self.__class__("(" + str(self) +")", False)

    def repeat(self):
        return self.__class__(self._wrap() + '*', False)

    def __str__(self):
        return self.s

    def __add__(self, other):
        return self.__class__(str(self) + self._maybe_escape(other), False)
    def __radd__(self, other): self.__class__(other) + self

    def __mul__(self, other):
        if isinstance(other, int):
            return self.__class__(self._wrap() + "{%d}" % i, False)
        elif isinstance(other, tuple):
            assert(len(other) == 2)
            return self.__class__(self._wrap() + "{%d, %d}" % other, False)
        else:
            assert(False)

    def __or__(self, other):
        return self.__class__(self._wrap() + "|" + self.__class__(other)._wrap(), False)
    def __ror__(self, other): return self.__class__(other) | self

    def __neg__(self):
        assert(len(self.s) > 1 and ((self.s[-1] in "}*+" and self.s[-2] != "\\") or (self.s[-1] == "?" and self.s[-2] not in "?\\")))
        return self.__class__(str(self) + "?", False)

    def __invert__(self):
        return self.__class__(self._wrap() + "?", False)

    def __pos__(self):
        return self.__class__(self._wrap() + "+", False)

    def __getattr__(self, name):
        self.rx = self.rx or re.compile(self.s)
        try:
            return getattr(self.rx, name)
        except AttributeError:
            raise AttributeError("'" + self.__class__.__name__ + "' object has no attribute '" + name + "'")