Пример #1
0
    def rule_MetaExpression(self):
        """ Meta expression. (@see page 12)

        func
        func[arg]
        func[arg;...;arg]
        """
        with self:
            _s = []
            _func = self.token_ATOM()
            _args = []
            if self[0] == '[':
                _delim = '['
                while self[0] != ']':
                    assert self[0] == _delim
                    _s += [self.consume(1)]  # '[' or ';'
                    _delim = ';'
                    _e = self.rule_SymbolicExpression()
                    _s += [_e.s]
                    _args += [_e]

                _s += [self.consume(1)]  # ']'

        _s = tuple(_s)
        _args = tuple(_args)
        return self.MetaExpression(s=_s, func=_func, args=_args)
Пример #2
0
    def get_all(cls, conn, book_id=None, title=None, publisher_name=None, publisher_id=None):
        query = """
                SELECT *
                FROM {}
                  WHERE B.bookId IS NOT NULL
                """
        tables = ['Book B']
        values = []

        if book_id:
            query+= ' AND bookId = ?'
            values.append(book_id)
        if title:
            query+= ' AND title LIKE ?'
            values.append('%'+title+'%')
        if publisher_name:
            tables.append('Publisher P')
            query+= ' AND B.publisherId = P.publisherId'
            query+= ' AND P.name LIKE ?'
            values.append('%'+publisher_name+'%')
        if publisher_id:
            query+= ' AND B.publisherId = ?'
            values.append(publisher_id)

        try:
            c = conn.cursor()
            c.execute(query.format(','.join(tables)), tuple(values))
            rows = c.fetchall()
        except sqlite3.Error as e:
            raise e

        books = [Book.create_from_books(conn, row) for row in rows]

        return books
Пример #3
0
    def rule_DataLine(self):
        r"""
        rule_DataLine = token_WHITESPACE? ( token_DATA token_WHITESPACE? )+ rule_EmptyLine
                      ;; the token_WHITESPACE at the start is the indent
        """
        with self:  # revert state on error
            _s = []
            _lineNumber = self.state.lineNumber
            _indent = self.maybe(self.token_WHITESPACE)
            if _indent is None:
                _indent = self.consume(0)
            _s += [_indent]
            _tokens = []
            while True:
                try:
                    _token = self.token_TOKEN()
                    _tokens += [_token]
                    _s += [_token]
                    _whitespace = self.maybe(self.token_WHITESPACE)
                    if _whitespace is not None:
                        _s += [_whitespace]
                except AssertionError:
                    break  # no more tokens
            _empty_line = self.rule_EmptyLine()
            _s += [_empty_line.s]

        assert len(_tokens) > 0  # expecting a token
        _s = tuple(_s)
        return self.DataLine(s=_s,
                             indent=_indent,
                             tokens=_tokens,
                             lineNumber=_lineNumber)
Пример #4
0
 def rule_Literal(self):
     r"""
     literal
         singleton
         range exclude
         '"' characters '"'
     """
     # NOTE range must come first because it starts with a singleton
     try:
         with self:  # restore state on error
             _range = self.rule_Range()
             _exclude = self.rule_Exclude()
         return tuple(list(_range) + ['.exclude', _exclude])
     except AssertionError:
         pass
     try:
         _singleton = self.rule_Singleton()
         return _singleton
     except AssertionError:
         pass
     try:
         with self:  # restore state on error
             _discard = self._str('"')
             _characters = self.token_CHARACTERS()
             _discard = self._str('"')
         return (
             'Characters',
             '.str',
             _characters,
         )
     except AssertionError:
         pass
     assert False, (self.state, )  # not a rule_Literal?
Пример #5
0
 def rule_Exclude(self):
     r"""
     exclude
         ""
         space '-' space singleton exclude
         space '-' space range exclude
     """
     _exclude = []  # zero or more
     while True:
         # NOTE range must come first because it starts with a singleton
         try:
             with self:  # restore state on error
                 _discard = self.token_SPACE()
                 _discard = self._str('-')
                 _discard = self.token_SPACE()
                 _range = self.rule_Range()
             _exclude += [_range]
             continue
         except AssertionError:
             pass
         try:
             with self:  # restore state on error
                 _discard = self.token_SPACE()
                 _discard = self._str('-')
                 _discard = self.token_SPACE()
                 _singleton = self.rule_Singleton()
             _exclude += [_singleton]
             continue
         except AssertionError:
             pass
         break  # ignore the rest
     return tuple(_exclude)
Пример #6
0
    def tuple_processor(data):
        if not isinstance(data, __builtin__.tuple) and not coerce_:
            raise DataTypeError('tuple')
        else:
            if not isinstance(data, basestring):
                try:
                    data = __builtin__.tuple(data)
                except TypeError:
                    data = (data, )
            else:
                data = (data, )

        cleandata = []
        for element in data:
            cleandata.append(checker.process(element))
        return __builtin__.tuple(cleandata)
Пример #7
0
 def rule_Codepoint(self):
     """ rule_Codepoint = byte_Leading byte_Continuation* """
     _sub_rules = [
         # _prefix, _prefix_mask, _data_mask, _n_continuation
         (
             self.HIGH_0,
             self.HIGH_1,
             self.LOW_7,
             0,
         ),  # 0xxxxxxx
         (
             self.HIGH_2,
             self.HIGH_3,
             self.LOW_5,
             1,
         ),  # 110xxxxx 10xxxxxx
         (
             self.HIGH_3,
             self.HIGH_4,
             self.LOW_4,
             2,
         ),  # 1110xxxx 10xxxxxx 10xxxxxx
         (
             self.HIGH_4,
             self.HIGH_5,
             self.LOW_3,
             3,
         ),  # 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
         (
             self.HIGH_5,
             self.HIGH_6,
             self.LOW_2,
             4,
         ),  # 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
         (
             self.HIGH_6,
             self.HIGH_7,
             self.LOW_1,
             5,
         ),  # 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
         # 11111110 is 0xFE, used for the BOM in UTF-16, currently meaningless in utf8
         # 11111111 is 0xFF, used for the BOM in UTF-16, currently meaningless in utf8
     ]
     with self:
         _leading = self.byte_Leading()
         _b = _leading.b
         for _prefix, _prefix_mask, _data_mask, _n_continuations in _sub_rules:
             if _prefix == (_b & _prefix_mask):
                 _codepoint = (_b & _data_mask)
                 break
         else:
             assert False, _b  # invalid utf8?
         _s = [_leading.s]
         for _ in range(_n_continuations):
             _continuation = self.byte_Continuation()
             _b = _continuation.b
             _codepoint = (_codepoint << 6) + (_b & self.LOW_6)
             _s += [_continuation.s]
     return self.Codepoint(codepoint=_codepoint, s=tuple(_s))
Пример #8
0
    def rule_DataNode(self, parent_indent=None):
        r"""
        rule_DataNode = ( rule_EmptyLine )* rule_DataLine rule_DataNode*
                      ;; the rule_DataNode at the end must be children
        """
        with self:  # revert cursor on error
            _s = []
            _lineNumber = self.state.lineNumber
            while True:
                _emptyline = self.maybe(self.rule_EmptyLine)
                if _emptyline is None:
                    break  # no more empty lines
                _s += [_emptyline.s]
            _dataline = self.rule_DataLine()
            _indent = _dataline.indent
            if parent_indent is None:
                assert _dataline.indent == ''  # must be at line start
            else:
                assert _dataline.indent != parent_indent  # must be a child
                assert _dataline.indent.startswith(parent_indent)  # must match
            _s += [_dataline.s]
            _children = []
            while True:
                try:
                    with self:
                        _child = self.rule_DataNode(parent_indent=_indent)
                        if _children:
                            assert _children[0].indent == _child.indent, (
                                _children[0].indent,
                                child.indent,
                            )  # must be at the same level
                        _children += [_child]
                        _s += [_child.s]
                except AssertionError as err:
                    break  # no more children

        _s = tuple(_s)
        _tokens = tuple(_dataline.tokens)
        _lines = slice(_lineNumber, self.state.lineNumber)
        _children = tuple(_children)
        _datanode = self.DataNode(s=_s,
                                  indent=_indent,
                                  tokens=_tokens,
                                  lines=_lines,
                                  children=_children)
        return _datanode
Пример #9
0
    def rule_SymbolicExpression(self, abbreviation=False):
        """ Symbolic expression. (@see pages 11-12)

        Can be:
        ATOM
        (e1·e2)

        Abbreviations:
        (m)           -> (m·NIL)
        (m1,...,mn)   -> (m1·(...·(mn·NIL)))
        (m1,...,mn·x) -> (m1·(...·(mn·x)))
        ((AB,C),D)    -> ((AB·(C·NIL))·(D·NIL))
        ((A,B),C,D·E) -> ((A·(B·NIL))·(C·(D·E)))
        """
        with self:
            _atom = self.maybe(self.token_ATOM)
            if _atom is not None:
                # ATOM
                return _atom

            _s = []
            _e1 = None
            _e2 = None
            if abbreviation:
                _comma = self.token_COMMA()
                _s += [_comma.s]
            else:
                assert self[0] == '('
                _s += [self.consume(1)]  # '('

            _e1 = self.rule_S_expression()
            _s += [_e1.s]
            if self[0] == '·':
                # (e1·e2)
                _s += [self.consume(1)]  # '·'
                _e2 = self.rule_S_expression()
                _s += [_e2.s]
                assert self[0] == ')'
                _s += [self.consume(1)]  # ')'
            elif self[0] == ')':
                # abbreviation  (m)           -> (m·NIL)
                _e2 = self.ImplicitNilAtom(s=self.consume(0))
                _s += [self.consume(1)]  # ')'
            else:
                # abbreviation  (m1,...,mn)   -> (m1·(...·(mn·NIL)))
                # abbreviation  (m1,...,mn·x) -> (m1·(...·(mn·x)))
                _e2 = self.rule_S_expression(abreviation=True)
                _s += [_e2.s]

        _s = tuple(_s)
        assert _e1 is not None
        assert _e2 is not None
        return self.SymbolicExpression(s=_s, e1=_e1, e2=_e2)
Пример #10
0
    def _determine_arguments(self, arguments):
# #
        '''Determine right set of arguments for different method types.'''
        '''Avoid to add object or class references twice.'''
        if not self.arguments_determined:
            if self.method_type is builtins.classmethod:
                arguments = [self.class_object] + builtins.list(arguments)
            elif not (self.object is None or
                      self.method_type is builtins.staticmethod):
                arguments = [self.object] + builtins.list(arguments)
        if self.wrapped_decorator is not None:
            self.wrapped_decorator.arguments_determined = True
        return builtins.tuple(arguments)
Пример #11
0
 def rule_Alternatives(self):
     r"""
     alternatives
         alternative
         alternative alternatives
     """
     _alternatives = [self.rule_Alternative()]  # one or more
     while True:
         _alternative = self.maybe(self.rule_Alternative)
         if _alternative is None:
             break
         _alternatives += [_alternative]
     return tuple(_alternatives)
Пример #12
0
 def rule_Items(self):
     r"""
     items
         item
         item space items
     """
     _items = [self.rule_Item()]  # one or more
     while True:
         with self:  # restore state on error
             _space = self.maybe(self.token_SPACE)
             if _space is None:
                 break
             _item = self.maybe(self.rule_Item)
             if _item is None:
                 break
         _items += [_item]
     return tuple(_items)
Пример #13
0
 def rule_Rules(self):
     r"""
     rules
         rule
         rule newline rules
     """
     _rules = [self.rule_Rule()]  # one or more
     while True:
         try:
             with self:  # restore state on error
                 _discard = self.token_NEWLINE()
                 _rule = self.rule_Rule()
             _rules += [_rule]
             continue
         except AssertionError:
             pass
         break  # ignore the rest
     return tuple(_rules)
Пример #14
0
    def get_available_gui_toolkits(cls):
# #
        '''
            Determines available gui toolkits.

            Examples:

            >>> __test_globals__['qt'] = __test_globals__['gtk'] = None

            >>> Browser('google.de').available_gui_toolkits
            ('default',)
        '''
        toolkits = []
        for toolkit in builtins.globals():
            if(builtins.globals()[toolkit] is not None and
               '_initialize_%s_browser' % toolkit in cls.__dict__):
                toolkits.append(toolkit)
        toolkits.append('default')
        return builtins.tuple(toolkits)
Пример #15
0
    def rule_EmptyLine(self):
        r"""
        rule_EmptyLine = token_WHITESPACE? token_COMMENT? token_NEWLINE
                       ;
        """
        with self:  # revert state on error
            _s = []
            _whitespace = self.maybe(self.token_WHITESPACE)
            if _whitespace is not None:
                _s += [_whitespace]
            _comment = self.maybe(self.token_COMMENT)
            if _comment is not None:
                _s += [_comment]
            _newline = self.token_NEWLINE()
            _s += [_newline]

        _s = tuple(_s)
        _lineNumber = self.state.lineNumber
        return self.EmptyLine(s=_s, lineNumber=_lineNumber)
Пример #16
0
    def most_borrowed_books(self, limit=None):
        query = """
                SELECT bookId, Times
                FROM MostBorrowed
                  WHERE libId = ?
                """
        values = [self.lib_id]

        if limit is not None:
            query += ' LIMIT ?'
            values.append(limit)

        try:
            c = self.conn.cursor()
            c.execute(query, tuple(values))
            rows = c.fetchall()
        except sqlite3.Error:
            raise

        result = [dict(book=Books.get(self.conn, row[0]), times=row[1])
                  for row in rows]

        return result
Пример #17
0
    def frequent_borrowers(self, limit=None):
        query = """
                SELECT readerId, Times
                FROM FrequentBorrower
                WHERE libId = ?
                """
        values = [self.lib_id]

        if limit:
            query += ' LIMIT ?'
            values.append(limit)

        try:
            c = self.conn.cursor()
            c.execute(query, tuple(values))
            rows = c.fetchall()
        except sqlite3.Error:
            raise

        results = [dict(reader=Readers.get(self.conn, row[0]),
                        times=row[1])
                   for row in rows]

        return results
Пример #18
0
# return a memoized closure that's lazy and only executes when evaluated
def flazy(f, *a, **k):
    sortedtuple, state = fcompose(builtins.sorted, builtins.tuple), {}
    def lazy(*ap, **kp):
        A, K = a+ap, sortedtuple(k.items() + kp.items())
        return state[(A, K)] if (A, K) in state else state.setdefault((A, K), f(*A, **builtins.dict(k.items()+kp.items())))
    return lazy
fmemo = flazy
# return a closure with the function's arglist partially applied
fpartial = functools.partial
# return a closure that applies the provided arguments to the function ``f``.
fapply = lambda f, *a, **k: lambda *ap, **kp: f(*(a+ap), **builtins.dict(k.items() + kp.items()))
# return a closure that will use the specified arguments to call the provided function.
fcurry = lambda *a, **k: lambda f, *ap, **kp: f(*(a+ap), **builtins.dict(k.items() + kp.items()))
# return a closure that applies the initial arglist to the end of function ``f``.
frpartial = lambda f, *a, **k: lambda *ap, **kp: f(*(ap + builtins.tuple(builtins.reversed(a))), **builtins.dict(k.items() + kp.items()))
# return a closure that applies the arglist to function ``f`` in reverse.
freversed = freverse = lambda f, *a, **k: lambda *ap, **kp: f(*builtins.reversed(a + ap), **builtins.dict(k.items() + kp.items()))
# return a closure that executes function ``f`` and includes the caught exception (or None) as the first element in the boxed result.
def fcatch(f, *a, **k):
    def fcatch(*a, **k):
        try: return builtins.None, f(*a, **k)
        except: return sys.exc_info()[1], builtins.None
    return functools.partial(fcatch, *a, **k)
fexc = fexception = fcatch
# boolean inversion of the result of a function
fcomplement = fnot = frpartial(fcompose, operator.not_)
# converts a list to an iterator, or an iterator to a list
ilist, liter = fcompose(builtins.list, builtins.iter), fcompose(builtins.iter, builtins.list)
# converts a tuple to an iterator, or an iterator to a tuple
ituple, titer = fcompose(builtins.tuple, builtins.iter), fcompose(builtins.iter, builtins.tuple)
Пример #19
0
lista = ['A', 'B', 'C']
# Tuplas
# Semelhantes as lista, porem sao imutaveis:
# nao se pode alterar itens, apaga-los ou adicionar novos itens

# AS tuplas sao mais eficientes do que as listas convencionais, consomente
# menos recursos computacionais(memoria), por serem estruturaas mais simples
# igualmente sao as strings imutaveis em relacao as mutaveis

tupla = (1,[],2,3,4,10)     # os parentes sao opcionais

# TypeError: 'tuple' object does not support item assignment
# tupla[0] = 12

# uma lista pode ser convertida para uma tupla
tuplaA = tuple(lista)
# mesmo uma tupla formada por elementos mutaveis, nao pode
# ter seus elementos modificados
#tuplaA[1] = 'a'
#tuplaA += ['a']
#tuplaA[0].append('Z')
#tupla[0].append(6)
tupla[1].append(3)
tupla[1].append(56)

def addToTuple(tup, pos, e):
    tup = tup[:pos] + (e,) + tup[pos:]
    return tup

print tupla, (11,)
print addToTuple(tupla, 2, 100)
Пример #20
0
#!/usr/bin/python
from __builtin__ import tuple

kurt_tupleEx = ('Kurt', 'Von', 'Scholtens', 49, '750 Navaronne Way', 'Concord', 'CA', 94518, '925-429-1724')
print kurt_tupleEx[4]
kurt_tupleEx2 = tuple('925-222-0566')
print kurt_tupleEx2
print kurt_tupleEx2[4:-1]

Пример #21
0
def as_tuple(iterable):
    return builtins.tuple(iterable)
Пример #22
0
    def get_all(cls, conn, book_id=None, lib_id=None, number=None, available=None):
        query = """
                SELECT C.copyId, C.number, C.bookId, C.libId
                FROM {}
                WHERE C.copyId IS NOT NULL
                """
        tables = ['Copy C']
        values = []

        if available is True:
            query += """  AND NOT EXISTS (SELECT R.copyId
                                         FROM Reserved R
                                         WHERE C.copyId = R.copyID
                                           AND R.isReserved = ?

                                         UNION

                                         SELECT B.copyId
                                         FROM Borrowed B
                                         WHERE C.copyId = B.copyId
                                           AND B.rDatetime IS NULL)
                     """
            values.append(True)
        elif available is False:
            query += """  AND NOT EXISTS (SELECT R.copyId
                                          FROM Reserved R
                                          WHERE C.copyId = R.copyID
                                            AND R.isReserved = ?

                                          UNION

                                          SELECT B.copyId
                                          FROM Borrowed B
                                          WHERE C.copyId = B.copyId
                                            AND B.rDatetime IS NOT NULL)
                          AND EXISTS (SELECT B.copyId
                                      FROM Borrowed B
                                      WHERE C.copyId = B.copyId

                                      UNION

                                      SELECT R.copyId
                                      FROM Reserved R
                                      WHERE C.copyId = R.copyId)
                     """
            values.append(False)
        if book_id:
            query += '  AND C.bookId = ?'
            values.append(book_id)
        if lib_id:
            query += '  AND C.libId = ?'
            values.append(lib_id)
        if number:
            query += '  AND C.number = ?'
            values.append(number)

        try:
            c = conn.cursor()
            c.execute(query.format(','.join(tables)), tuple(values))
            rows = c.fetchall()
        except sqlite3.Error as e:
            raise e

        copies = [Copy.create_from_copies(conn, row)
                  for row in rows]

        return copies
Пример #23
0
# return a memoized closure that's lazy and only executes when evaluated
def flazy(f, *a, **k):
    sortedtuple, state = fcompose(__builtin__.sorted, __builtin__.tuple), {}
    def lazy(*ap, **kp):
        A, K = a+ap, sortedtuple(k.items() + kp.items())
        return state[(A,K)] if (A,K) in state else state.setdefault((A,K), f(*A, **__builtin__.dict(k.items()+kp.items())))
    return lazy
fmemo = flazy
# return a closure with the function's arglist partially applied
fpartial = partial = functools.partial
# return a closure that applies the provided arguments to the function ``f``.
fapply = lambda f, *a, **k: lambda *ap, **kp: f(*(a+ap), **__builtin__.dict(k.items() + kp.items()))
# return a closure that will use the specified arguments to call the provided function.
fcurry = lambda *a, **k: lambda f, *ap, **kp: f(*(a+ap), **__builtin__.dict(k.items() + kp.items()))
# return a closure that applies the initial arglist to the end of function ``f``.
frpartial = lambda f, *a, **k: lambda *ap, **kp: f(*(ap + __builtin__.tuple(__builtin__.reversed(a))), **__builtin__.dict(k.items() + kp.items()))
# return a closure that applies the arglist to function ``f`` in reverse.
freversed = frev = lambda f, *a, **k: lambda *ap, **kp: f(*__builtin__.reversed(a + ap), **__builtin__.dict(k.items() + kp.items()))
# return a closure that executes function ``f`` and includes the caught exception (or None) as the first element in the boxed result.
def fcatch(f, *a, **k):
    def fcatch(*a, **k):
        try: return __builtin__.None, f(*a, **k)
        except: return sys.exc_info()[1], __builtin__.None
    return functools.partial(fcatch, *a, **k)
fexc = fexception = fcatch
# take ``count`` number of elements from an iterator
itake = lambda count: compose(iter, fap(*(next,)*count), tuple)
# get the ``nth`` element from an iterator
iget = lambda count: compose(iter, fap(*(next,)*(count)), tuple, operator.itemgetter(-1))
# copy from itertools
imap, ifilter = itertools.imap, itertools.ifilter