Back of some of the last disasm changes

Was failing test_disasm and I don't want to deal with that now.

Add more 2.7 bytecode tests

pytest/test_disasm.py

@@ -24,7 +24,7 @@ os.chdir(src_dir)
 def test_funcoutput(capfd, test_tuple, function_to_test):
 
     in_file , filename_expected = test_tuple
-    function_to_test(in_file)
+    function_to_test(in_file, native=False)
     resout, reserr = capfd.readouterr()
     expected = open(filename_expected, "r").read()
     if resout != expected:

pytest/testdata/if-2.7.right

@@ -7,5 +7,6 @@
    7      6	LOAD_NAME             1  'False'
           9	STORE_NAME            2  'b'
          12	JUMP_FORWARD          0  '15'
+       15_0	COME_FROM                '12'
          15	LOAD_CONST            0  ''
          18	RETURN_VALUE             ''

pytest/testdata/ifelse-2.7.right

@@ -10,5 +10,6 @@
 
    6     15	LOAD_CONST            1  2
          18	STORE_NAME            2  'd'
+       21_0	COME_FROM                '12'
          21	LOAD_CONST            2  ''
          24	RETURN_VALUE             ''

test/ok_lib2.7/bsddb/dbobj.py

@@ -0,0 +1,266 @@
+#-------------------------------------------------------------------------
+#  This file contains real Python object wrappers for DB and DBEnv
+#  C "objects" that can be usefully subclassed.  The previous SWIG
+#  based interface allowed this thanks to SWIG's shadow classes.
+#   --  Gregory P. Smith
+#-------------------------------------------------------------------------
+#
+# (C) Copyright 2001  Autonomous Zone Industries
+#
+# License:  This is free software.  You may use this software for any
+#           purpose including modification/redistribution, so long as
+#           this header remains intact and that you do not claim any
+#           rights of ownership or authorship of this software.  This
+#           software has been tested, but no warranty is expressed or
+#           implied.
+#
+
+#
+# TODO it would be *really nice* to have an automatic shadow class populator
+# so that new methods don't need to be added  here manually after being
+# added to _bsddb.c.
+#
+
+import sys
+absolute_import = (sys.version_info[0] >= 3)
+if absolute_import :
+    # Because this syntaxis is not valid before Python 2.5
+    exec("from . import db")
+else :
+    import db
+
+if sys.version_info < (2, 6) :
+    from UserDict import DictMixin as MutableMapping
+else :
+    import collections
+    MutableMapping = collections.MutableMapping
+
+class DBEnv:
+    def __init__(self, *args, **kwargs):
+        self._cobj = db.DBEnv(*args, **kwargs)
+
+    def close(self, *args, **kwargs):
+        return self._cobj.close(*args, **kwargs)
+    def open(self, *args, **kwargs):
+        return self._cobj.open(*args, **kwargs)
+    def remove(self, *args, **kwargs):
+        return self._cobj.remove(*args, **kwargs)
+    def set_shm_key(self, *args, **kwargs):
+        return self._cobj.set_shm_key(*args, **kwargs)
+    def set_cachesize(self, *args, **kwargs):
+        return self._cobj.set_cachesize(*args, **kwargs)
+    def set_data_dir(self, *args, **kwargs):
+        return self._cobj.set_data_dir(*args, **kwargs)
+    def set_flags(self, *args, **kwargs):
+        return self._cobj.set_flags(*args, **kwargs)
+    def set_lg_bsize(self, *args, **kwargs):
+        return self._cobj.set_lg_bsize(*args, **kwargs)
+    def set_lg_dir(self, *args, **kwargs):
+        return self._cobj.set_lg_dir(*args, **kwargs)
+    def set_lg_max(self, *args, **kwargs):
+        return self._cobj.set_lg_max(*args, **kwargs)
+    def set_lk_detect(self, *args, **kwargs):
+        return self._cobj.set_lk_detect(*args, **kwargs)
+    if db.version() < (4,5):
+        def set_lk_max(self, *args, **kwargs):
+            return self._cobj.set_lk_max(*args, **kwargs)
+    def set_lk_max_locks(self, *args, **kwargs):
+        return self._cobj.set_lk_max_locks(*args, **kwargs)
+    def set_lk_max_lockers(self, *args, **kwargs):
+        return self._cobj.set_lk_max_lockers(*args, **kwargs)
+    def set_lk_max_objects(self, *args, **kwargs):
+        return self._cobj.set_lk_max_objects(*args, **kwargs)
+    def set_mp_mmapsize(self, *args, **kwargs):
+        return self._cobj.set_mp_mmapsize(*args, **kwargs)
+    def set_timeout(self, *args, **kwargs):
+        return self._cobj.set_timeout(*args, **kwargs)
+    def set_tmp_dir(self, *args, **kwargs):
+        return self._cobj.set_tmp_dir(*args, **kwargs)
+    def txn_begin(self, *args, **kwargs):
+        return self._cobj.txn_begin(*args, **kwargs)
+    def txn_checkpoint(self, *args, **kwargs):
+        return self._cobj.txn_checkpoint(*args, **kwargs)
+    def txn_stat(self, *args, **kwargs):
+        return self._cobj.txn_stat(*args, **kwargs)
+    def set_tx_max(self, *args, **kwargs):
+        return self._cobj.set_tx_max(*args, **kwargs)
+    def set_tx_timestamp(self, *args, **kwargs):
+        return self._cobj.set_tx_timestamp(*args, **kwargs)
+    def lock_detect(self, *args, **kwargs):
+        return self._cobj.lock_detect(*args, **kwargs)
+    def lock_get(self, *args, **kwargs):
+        return self._cobj.lock_get(*args, **kwargs)
+    def lock_id(self, *args, **kwargs):
+        return self._cobj.lock_id(*args, **kwargs)
+    def lock_put(self, *args, **kwargs):
+        return self._cobj.lock_put(*args, **kwargs)
+    def lock_stat(self, *args, **kwargs):
+        return self._cobj.lock_stat(*args, **kwargs)
+    def log_archive(self, *args, **kwargs):
+        return self._cobj.log_archive(*args, **kwargs)
+
+    def set_get_returns_none(self, *args, **kwargs):
+        return self._cobj.set_get_returns_none(*args, **kwargs)
+
+    def log_stat(self, *args, **kwargs):
+        return self._cobj.log_stat(*args, **kwargs)
+
+    def dbremove(self, *args, **kwargs):
+        return self._cobj.dbremove(*args, **kwargs)
+    def dbrename(self, *args, **kwargs):
+        return self._cobj.dbrename(*args, **kwargs)
+    def set_encrypt(self, *args, **kwargs):
+        return self._cobj.set_encrypt(*args, **kwargs)
+
+    if db.version() >= (4,4):
+        def fileid_reset(self, *args, **kwargs):
+            return self._cobj.fileid_reset(*args, **kwargs)
+
+        def lsn_reset(self, *args, **kwargs):
+            return self._cobj.lsn_reset(*args, **kwargs)
+
+
+class DB(MutableMapping):
+    def __init__(self, dbenv, *args, **kwargs):
+        # give it the proper DBEnv C object that its expecting
+        self._cobj = db.DB(*((dbenv._cobj,) + args), **kwargs)
+
+    # TODO are there other dict methods that need to be overridden?
+    def __len__(self):
+        return len(self._cobj)
+    def __getitem__(self, arg):
+        return self._cobj[arg]
+    def __setitem__(self, key, value):
+        self._cobj[key] = value
+    def __delitem__(self, arg):
+        del self._cobj[arg]
+
+    if sys.version_info >= (2, 6) :
+        def __iter__(self) :
+            return self._cobj.__iter__()
+
+    def append(self, *args, **kwargs):
+        return self._cobj.append(*args, **kwargs)
+    def associate(self, *args, **kwargs):
+        return self._cobj.associate(*args, **kwargs)
+    def close(self, *args, **kwargs):
+        return self._cobj.close(*args, **kwargs)
+    def consume(self, *args, **kwargs):
+        return self._cobj.consume(*args, **kwargs)
+    def consume_wait(self, *args, **kwargs):
+        return self._cobj.consume_wait(*args, **kwargs)
+    def cursor(self, *args, **kwargs):
+        return self._cobj.cursor(*args, **kwargs)
+    def delete(self, *args, **kwargs):
+        return self._cobj.delete(*args, **kwargs)
+    def fd(self, *args, **kwargs):
+        return self._cobj.fd(*args, **kwargs)
+    def get(self, *args, **kwargs):
+        return self._cobj.get(*args, **kwargs)
+    def pget(self, *args, **kwargs):
+        return self._cobj.pget(*args, **kwargs)
+    def get_both(self, *args, **kwargs):
+        return self._cobj.get_both(*args, **kwargs)
+    def get_byteswapped(self, *args, **kwargs):
+        return self._cobj.get_byteswapped(*args, **kwargs)
+    def get_size(self, *args, **kwargs):
+        return self._cobj.get_size(*args, **kwargs)
+    def get_type(self, *args, **kwargs):
+        return self._cobj.get_type(*args, **kwargs)
+    def join(self, *args, **kwargs):
+        return self._cobj.join(*args, **kwargs)
+    def key_range(self, *args, **kwargs):
+        return self._cobj.key_range(*args, **kwargs)
+    def has_key(self, *args, **kwargs):
+        return self._cobj.has_key(*args, **kwargs)
+    def items(self, *args, **kwargs):
+        return self._cobj.items(*args, **kwargs)
+    def keys(self, *args, **kwargs):
+        return self._cobj.keys(*args, **kwargs)
+    def open(self, *args, **kwargs):
+        return self._cobj.open(*args, **kwargs)
+    def put(self, *args, **kwargs):
+        return self._cobj.put(*args, **kwargs)
+    def remove(self, *args, **kwargs):
+        return self._cobj.remove(*args, **kwargs)
+    def rename(self, *args, **kwargs):
+        return self._cobj.rename(*args, **kwargs)
+    def set_bt_minkey(self, *args, **kwargs):
+        return self._cobj.set_bt_minkey(*args, **kwargs)
+    def set_bt_compare(self, *args, **kwargs):
+        return self._cobj.set_bt_compare(*args, **kwargs)
+    def set_cachesize(self, *args, **kwargs):
+        return self._cobj.set_cachesize(*args, **kwargs)
+    def set_dup_compare(self, *args, **kwargs) :
+        return self._cobj.set_dup_compare(*args, **kwargs)
+    def set_flags(self, *args, **kwargs):
+        return self._cobj.set_flags(*args, **kwargs)
+    def set_h_ffactor(self, *args, **kwargs):
+        return self._cobj.set_h_ffactor(*args, **kwargs)
+    def set_h_nelem(self, *args, **kwargs):
+        return self._cobj.set_h_nelem(*args, **kwargs)
+    def set_lorder(self, *args, **kwargs):
+        return self._cobj.set_lorder(*args, **kwargs)
+    def set_pagesize(self, *args, **kwargs):
+        return self._cobj.set_pagesize(*args, **kwargs)
+    def set_re_delim(self, *args, **kwargs):
+        return self._cobj.set_re_delim(*args, **kwargs)
+    def set_re_len(self, *args, **kwargs):
+        return self._cobj.set_re_len(*args, **kwargs)
+    def set_re_pad(self, *args, **kwargs):
+        return self._cobj.set_re_pad(*args, **kwargs)
+    def set_re_source(self, *args, **kwargs):
+        return self._cobj.set_re_source(*args, **kwargs)
+    def set_q_extentsize(self, *args, **kwargs):
+        return self._cobj.set_q_extentsize(*args, **kwargs)
+    def stat(self, *args, **kwargs):
+        return self._cobj.stat(*args, **kwargs)
+    def sync(self, *args, **kwargs):
+        return self._cobj.sync(*args, **kwargs)
+    def type(self, *args, **kwargs):
+        return self._cobj.type(*args, **kwargs)
+    def upgrade(self, *args, **kwargs):
+        return self._cobj.upgrade(*args, **kwargs)
+    def values(self, *args, **kwargs):
+        return self._cobj.values(*args, **kwargs)
+    def verify(self, *args, **kwargs):
+        return self._cobj.verify(*args, **kwargs)
+    def set_get_returns_none(self, *args, **kwargs):
+        return self._cobj.set_get_returns_none(*args, **kwargs)
+
+    def set_encrypt(self, *args, **kwargs):
+        return self._cobj.set_encrypt(*args, **kwargs)
+
+
+class DBSequence:
+    def __init__(self, *args, **kwargs):
+        self._cobj = db.DBSequence(*args, **kwargs)
+
+    def close(self, *args, **kwargs):
+        return self._cobj.close(*args, **kwargs)
+    def get(self, *args, **kwargs):
+        return self._cobj.get(*args, **kwargs)
+    def get_dbp(self, *args, **kwargs):
+        return self._cobj.get_dbp(*args, **kwargs)
+    def get_key(self, *args, **kwargs):
+        return self._cobj.get_key(*args, **kwargs)
+    def init_value(self, *args, **kwargs):
+        return self._cobj.init_value(*args, **kwargs)
+    def open(self, *args, **kwargs):
+        return self._cobj.open(*args, **kwargs)
+    def remove(self, *args, **kwargs):
+        return self._cobj.remove(*args, **kwargs)
+    def stat(self, *args, **kwargs):
+        return self._cobj.stat(*args, **kwargs)
+    def set_cachesize(self, *args, **kwargs):
+        return self._cobj.set_cachesize(*args, **kwargs)
+    def set_flags(self, *args, **kwargs):
+        return self._cobj.set_flags(*args, **kwargs)
+    def set_range(self, *args, **kwargs):
+        return self._cobj.set_range(*args, **kwargs)
+    def get_cachesize(self, *args, **kwargs):
+        return self._cobj.get_cachesize(*args, **kwargs)
+    def get_flags(self, *args, **kwargs):
+        return self._cobj.get_flags(*args, **kwargs)
+    def get_range(self, *args, **kwargs):
+        return self._cobj.get_range(*args, **kwargs)

test/ok_lib2.7/bsddb/dbrecio.py

@@ -0,0 +1,190 @@
+
+"""
+File-like objects that read from or write to a bsddb record.
+
+This implements (nearly) all stdio methods.
+
+f = DBRecIO(db, key, txn=None)
+f.close()           # explicitly release resources held
+flag = f.isatty()   # always false
+pos = f.tell()      # get current position
+f.seek(pos)         # set current position
+f.seek(pos, mode)   # mode 0: absolute; 1: relative; 2: relative to EOF
+buf = f.read()      # read until EOF
+buf = f.read(n)     # read up to n bytes
+f.truncate([size])  # truncate file at to at most size (default: current pos)
+f.write(buf)        # write at current position
+f.writelines(list)  # for line in list: f.write(line)
+
+Notes:
+- fileno() is left unimplemented so that code which uses it triggers
+  an exception early.
+- There's a simple test set (see end of this file) - not yet updated
+  for DBRecIO.
+- readline() is not implemented yet.
+
+
+From:
+    Itamar Shtull-Trauring <itamar@maxnm.com>
+"""
+
+import errno
+import string
+
+class DBRecIO:
+    def __init__(self, db, key, txn=None):
+        self.db = db
+        self.key = key
+        self.txn = txn
+        self.len = None
+        self.pos = 0
+        self.closed = 0
+        self.softspace = 0
+
+    def close(self):
+        if not self.closed:
+            self.closed = 1
+            del self.db, self.txn
+
+    def isatty(self):
+        if self.closed:
+            raise ValueError, "I/O operation on closed file"
+        return 0
+
+    def seek(self, pos, mode = 0):
+        if self.closed:
+            raise ValueError, "I/O operation on closed file"
+        if mode == 1:
+            pos = pos + self.pos
+        elif mode == 2:
+            pos = pos + self.len
+        self.pos = max(0, pos)
+
+    def tell(self):
+        if self.closed:
+            raise ValueError, "I/O operation on closed file"
+        return self.pos
+
+    def read(self, n = -1):
+        if self.closed:
+            raise ValueError, "I/O operation on closed file"
+        if n < 0:
+            newpos = self.len
+        else:
+            newpos = min(self.pos+n, self.len)
+
+        dlen = newpos - self.pos
+
+        r = self.db.get(self.key, txn=self.txn, dlen=dlen, doff=self.pos)
+        self.pos = newpos
+        return r
+
+    __fixme = """
+    def readline(self, length=None):
+        if self.closed:
+            raise ValueError, "I/O operation on closed file"
+        if self.buflist:
+            self.buf = self.buf + string.joinfields(self.buflist, '')
+            self.buflist = []
+        i = string.find(self.buf, '\n', self.pos)
+        if i < 0:
+            newpos = self.len
+        else:
+            newpos = i+1
+        if length is not None:
+            if self.pos + length < newpos:
+                newpos = self.pos + length
+        r = self.buf[self.pos:newpos]
+        self.pos = newpos
+        return r
+
+    def readlines(self, sizehint = 0):
+        total = 0
+        lines = []
+        line = self.readline()
+        while line:
+            lines.append(line)
+            total += len(line)
+            if 0 < sizehint <= total:
+                break
+            line = self.readline()
+        return lines
+    """
+
+    def truncate(self, size=None):
+        if self.closed:
+            raise ValueError, "I/O operation on closed file"
+        if size is None:
+            size = self.pos
+        elif size < 0:
+            raise IOError(errno.EINVAL,
+                                      "Negative size not allowed")
+        elif size < self.pos:
+            self.pos = size
+        self.db.put(self.key, "", txn=self.txn, dlen=self.len-size, doff=size)
+
+    def write(self, s):
+        if self.closed:
+            raise ValueError, "I/O operation on closed file"
+        if not s: return
+        if self.pos > self.len:
+            self.buflist.append('\0'*(self.pos - self.len))
+            self.len = self.pos
+        newpos = self.pos + len(s)
+        self.db.put(self.key, s, txn=self.txn, dlen=len(s), doff=self.pos)
+        self.pos = newpos
+
+    def writelines(self, list):
+        self.write(string.joinfields(list, ''))
+
+    def flush(self):
+        if self.closed:
+            raise ValueError, "I/O operation on closed file"
+
+
+"""
+# A little test suite
+
+def _test():
+    import sys
+    if sys.argv[1:]:
+        file = sys.argv[1]
+    else:
+        file = '/etc/passwd'
+    lines = open(file, 'r').readlines()
+    text = open(file, 'r').read()
+    f = StringIO()
+    for line in lines[:-2]:
+        f.write(line)
+    f.writelines(lines[-2:])
+    if f.getvalue() != text:
+        raise RuntimeError, 'write failed'
+    length = f.tell()
+    print 'File length =', length
+    f.seek(len(lines[0]))
+    f.write(lines[1])
+    f.seek(0)
+    print 'First line =', repr(f.readline())
+    here = f.tell()
+    line = f.readline()
+    print 'Second line =', repr(line)
+    f.seek(-len(line), 1)
+    line2 = f.read(len(line))
+    if line != line2:
+        raise RuntimeError, 'bad result after seek back'
+    f.seek(len(line2), 1)
+    list = f.readlines()
+    line = list[-1]
+    f.seek(f.tell() - len(line))
+    line2 = f.read()
+    if line != line2:
+        raise RuntimeError, 'bad result after seek back from EOF'
+    print 'Read', len(list), 'more lines'
+    print 'File length =', f.tell()
+    if f.tell() != length:
+        raise RuntimeError, 'bad length'
+    f.close()
+
+if __name__ == '__main__':
+    _test()
+"""

test/ok_lib2.7/bsddb/dbshelve.py

@@ -0,0 +1,381 @@
+#------------------------------------------------------------------------
+#           Copyright (c) 1997-2001 by Total Control Software
+#                         All Rights Reserved
+#------------------------------------------------------------------------
+#
+# Module Name:  dbShelve.py
+#
+# Description:  A reimplementation of the standard shelve.py that
+#               forces the use of cPickle, and DB.
+#
+# Creation Date:    11/3/97 3:39:04PM
+#
+# License:      This is free software.  You may use this software for any
+#               purpose including modification/redistribution, so long as
+#               this header remains intact and that you do not claim any
+#               rights of ownership or authorship of this software.  This
+#               software has been tested, but no warranty is expressed or
+#               implied.
+#
+# 13-Dec-2000:  Updated to be used with the new bsddb3 package.
+#               Added DBShelfCursor class.
+#
+#------------------------------------------------------------------------
+
+"""Manage shelves of pickled objects using bsddb database files for the
+storage.
+"""
+
+#------------------------------------------------------------------------
+
+import sys
+absolute_import = (sys.version_info[0] >= 3)
+if absolute_import :
+    # Because this syntaxis is not valid before Python 2.5
+    exec("from . import db")
+else :
+    import db
+
+if sys.version_info[0] >= 3 :
+    import cPickle  # Will be converted to "pickle" by "2to3"
+else :
+    if sys.version_info < (2, 6) :
+        import cPickle
+    else :
+        # When we drop support for python 2.4
+        # we could use: (in 2.5 we need a __future__ statement)
+        #
+        #    with warnings.catch_warnings():
+        #        warnings.filterwarnings(...)
+        #        ...
+        #
+        # We can not use "with" as is, because it would be invalid syntax
+        # in python 2.4 and (with no __future__) 2.5.
+        # Here we simulate "with" following PEP 343 :
+        import warnings
+        w = warnings.catch_warnings()
+        w.__enter__()
+        try :
+            warnings.filterwarnings('ignore',
+                message='the cPickle module has been removed in Python 3.0',
+                category=DeprecationWarning)
+            import cPickle
+        finally :
+            w.__exit__()
+        del w
+
+HIGHEST_PROTOCOL = cPickle.HIGHEST_PROTOCOL
+def _dumps(object, protocol):
+    return cPickle.dumps(object, protocol=protocol)
+
+if sys.version_info < (2, 6) :
+    from UserDict import DictMixin as MutableMapping
+else :
+    import collections
+    MutableMapping = collections.MutableMapping
+
+#------------------------------------------------------------------------
+
+
+def open(filename, flags=db.DB_CREATE, mode=0660, filetype=db.DB_HASH,
+         dbenv=None, dbname=None):
+    """
+    A simple factory function for compatibility with the standard
+    shleve.py module.  It can be used like this, where key is a string
+    and data is a pickleable object:
+
+        from bsddb import dbshelve
+        db = dbshelve.open(filename)
+
+        db[key] = data
+
+        db.close()
+    """
+    if type(flags) == type(''):
+        sflag = flags
+        if sflag == 'r':
+            flags = db.DB_RDONLY
+        elif sflag == 'rw':
+            flags = 0
+        elif sflag == 'w':
+            flags =  db.DB_CREATE
+        elif sflag == 'c':
+            flags =  db.DB_CREATE
+        elif sflag == 'n':
+            flags = db.DB_TRUNCATE | db.DB_CREATE
+        else:
+            raise db.DBError, "flags should be one of 'r', 'w', 'c' or 'n' or use the bsddb.db.DB_* flags"
+
+    d = DBShelf(dbenv)
+    d.open(filename, dbname, filetype, flags, mode)
+    return d
+
+#---------------------------------------------------------------------------
+
+class DBShelveError(db.DBError): pass
+
+
+class DBShelf(MutableMapping):
+    """A shelf to hold pickled objects, built upon a bsddb DB object.  It
+    automatically pickles/unpickles data objects going to/from the DB.
+    """
+    def __init__(self, dbenv=None):
+        self.db = db.DB(dbenv)
+        self._closed = True
+        if HIGHEST_PROTOCOL:
+            self.protocol = HIGHEST_PROTOCOL
+        else:
+            self.protocol = 1
+
+
+    def __del__(self):
+        self.close()
+
+
+    def __getattr__(self, name):
+        """Many methods we can just pass through to the DB object.
+        (See below)
+        """
+        return getattr(self.db, name)
+
+
+    #-----------------------------------
+    # Dictionary access methods
+
+    def __len__(self):
+        return len(self.db)
+
+
+    def __getitem__(self, key):
+        data = self.db[key]
+        return cPickle.loads(data)
+
+
+    def __setitem__(self, key, value):
+        data = _dumps(value, self.protocol)
+        self.db[key] = data
+
+
+    def __delitem__(self, key):
+        del self.db[key]
+
+
+    def keys(self, txn=None):
+        if txn is not None:
+            return self.db.keys(txn)
+        else:
+            return self.db.keys()
+
+    if sys.version_info >= (2, 6) :
+        def __iter__(self) :  # XXX: Load all keys in memory :-(
+            for k in self.db.keys() :
+                yield k
+
+        # Do this when "DB"  support iteration
+        # Or is it enough to pass thru "getattr"?
+        #
+        # def __iter__(self) :
+        #    return self.db.__iter__()
+
+
+    def open(self, *args, **kwargs):
+        self.db.open(*args, **kwargs)
+        self._closed = False
+
+
+    def close(self, *args, **kwargs):
+        self.db.close(*args, **kwargs)
+        self._closed = True
+
+
+    def __repr__(self):
+        if self._closed:
+            return '<DBShelf @ 0x%x - closed>' % (id(self))
+        else:
+            return repr(dict(self.iteritems()))
+
+
+    def items(self, txn=None):
+        if txn is not None:
+            items = self.db.items(txn)
+        else:
+            items = self.db.items()
+        newitems = []
+
+        for k, v in items:
+            newitems.append( (k, cPickle.loads(v)) )
+        return newitems
+
+    def values(self, txn=None):
+        if txn is not None:
+            values = self.db.values(txn)
+        else:
+            values = self.db.values()
+
+        return map(cPickle.loads, values)
+
+    #-----------------------------------
+    # Other methods
+
+    def __append(self, value, txn=None):
+        data = _dumps(value, self.protocol)
+        return self.db.append(data, txn)
+
+    def append(self, value, txn=None):
+        if self.get_type() == db.DB_RECNO:
+            return self.__append(value, txn=txn)
+        raise DBShelveError, "append() only supported when dbshelve opened with filetype=dbshelve.db.DB_RECNO"
+
+
+    def associate(self, secondaryDB, callback, flags=0):
+        def _shelf_callback(priKey, priData, realCallback=callback):
+            # Safe in Python 2.x because expresion short circuit
+            if sys.version_info[0] < 3 or isinstance(priData, bytes) :
+                data = cPickle.loads(priData)
+            else :
+                data = cPickle.loads(bytes(priData, "iso8859-1"))  # 8 bits
+            return realCallback(priKey, data)
+
+        return self.db.associate(secondaryDB, _shelf_callback, flags)
+
+
+    #def get(self, key, default=None, txn=None, flags=0):
+    def get(self, *args, **kw):
+        # We do it with *args and **kw so if the default value wasn't
+        # given nothing is passed to the extension module.  That way
+        # an exception can be raised if set_get_returns_none is turned
+        # off.
+        data = self.db.get(*args, **kw)
+        try:
+            return cPickle.loads(data)
+        except (EOFError, TypeError, cPickle.UnpicklingError):
+            return data  # we may be getting the default value, or None,
+                         # so it doesn't need unpickled.
+
+    def get_both(self, key, value, txn=None, flags=0):
+        data = _dumps(value, self.protocol)
+        data = self.db.get(key, data, txn, flags)
+        return cPickle.loads(data)
+
+
+    def cursor(self, txn=None, flags=0):
+        c = DBShelfCursor(self.db.cursor(txn, flags))
+        c.protocol = self.protocol
+        return c
+
+
+    def put(self, key, value, txn=None, flags=0):
+        data = _dumps(value, self.protocol)
+        return self.db.put(key, data, txn, flags)
+
+
+    def join(self, cursorList, flags=0):
+        raise NotImplementedError
+
+
+    #----------------------------------------------
+    # Methods allowed to pass-through to self.db
+    #
+    #    close,  delete, fd, get_byteswapped, get_type, has_key,
+    #    key_range, open, remove, rename, stat, sync,
+    #    upgrade, verify, and all set_* methods.
+
+
+#---------------------------------------------------------------------------
+
+class DBShelfCursor:
+    """
+    """
+    def __init__(self, cursor):
+        self.dbc = cursor
+
+    def __del__(self):
+        self.close()
+
+
+    def __getattr__(self, name):
+        """Some methods we can just pass through to the cursor object.  (See below)"""
+        return getattr(self.dbc, name)
+
+
+    #----------------------------------------------
+
+    def dup(self, flags=0):
+        c = DBShelfCursor(self.dbc.dup(flags))
+        c.protocol = self.protocol
+        return c
+
+
+    def put(self, key, value, flags=0):
+        data = _dumps(value, self.protocol)
+        return self.dbc.put(key, data, flags)
+
+
+    def get(self, *args):
+        count = len(args)  # a method overloading hack
+        method = getattr(self, 'get_%d' % count)
+        method(*args)
+
+    def get_1(self, flags):
+        rec = self.dbc.get(flags)
+        return self._extract(rec)
+
+    def get_2(self, key, flags):
+        rec = self.dbc.get(key, flags)
+        return self._extract(rec)
+
+    def get_3(self, key, value, flags):
+        data = _dumps(value, self.protocol)
+        rec = self.dbc.get(key, flags)
+        return self._extract(rec)
+
+
+    def current(self, flags=0): return self.get_1(flags|db.DB_CURRENT)
+    def first(self, flags=0): return self.get_1(flags|db.DB_FIRST)
+    def last(self, flags=0): return self.get_1(flags|db.DB_LAST)
+    def next(self, flags=0): return self.get_1(flags|db.DB_NEXT)
+    def prev(self, flags=0): return self.get_1(flags|db.DB_PREV)
+    def consume(self, flags=0): return self.get_1(flags|db.DB_CONSUME)
+    def next_dup(self, flags=0): return self.get_1(flags|db.DB_NEXT_DUP)
+    def next_nodup(self, flags=0): return self.get_1(flags|db.DB_NEXT_NODUP)
+    def prev_nodup(self, flags=0): return self.get_1(flags|db.DB_PREV_NODUP)
+
+
+    def get_both(self, key, value, flags=0):
+        data = _dumps(value, self.protocol)
+        rec = self.dbc.get_both(key, flags)
+        return self._extract(rec)
+
+
+    def set(self, key, flags=0):
+        rec = self.dbc.set(key, flags)
+        return self._extract(rec)
+
+    def set_range(self, key, flags=0):
+        rec = self.dbc.set_range(key, flags)
+        return self._extract(rec)
+
+    def set_recno(self, recno, flags=0):
+        rec = self.dbc.set_recno(recno, flags)
+        return self._extract(rec)
+
+    set_both = get_both
+
+    def _extract(self, rec):
+        if rec is None:
+            return None
+        else:
+            key, data = rec
+            # Safe in Python 2.x because expresion short circuit
+            if sys.version_info[0] < 3 or isinstance(data, bytes) :
+                return key, cPickle.loads(data)
+            else :
+                return key, cPickle.loads(bytes(data, "iso8859-1"))  # 8 bits
+
+    #----------------------------------------------
+    # Methods allowed to pass-through to self.dbc
+    #
+    # close, count, delete, get_recno, join_item
+
+
+#---------------------------------------------------------------------------

test/ok_lib2.7/bsddb/dbutils.py

@@ -0,0 +1,83 @@
+#------------------------------------------------------------------------
+#
+# Copyright (C) 2000 Autonomous Zone Industries
+#
+# License:      This is free software.  You may use this software for any
+#               purpose including modification/redistribution, so long as
+#               this header remains intact and that you do not claim any
+#               rights of ownership or authorship of this software.  This
+#               software has been tested, but no warranty is expressed or
+#               implied.
+#
+# Author: Gregory P. Smith <greg@krypto.org>
+#
+# Note: I don't know how useful this is in reality since when a
+#       DBLockDeadlockError happens the current transaction is supposed to be
+#       aborted.  If it doesn't then when the operation is attempted again
+#       the deadlock is still happening...
+#       --Robin
+#
+#------------------------------------------------------------------------
+
+
+#
+# import the time.sleep function in a namespace safe way to allow
+# "from bsddb.dbutils import *"
+#
+from time import sleep as _sleep
+
+import sys
+absolute_import = (sys.version_info[0] >= 3)
+if absolute_import :
+    # Because this syntaxis is not valid before Python 2.5
+    exec("from . import db")
+else :
+    import db
+
+# always sleep at least N seconds between retrys
+_deadlock_MinSleepTime = 1.0/128
+# never sleep more than N seconds between retrys
+_deadlock_MaxSleepTime = 3.14159
+
+# Assign a file object to this for a "sleeping" message to be written to it
+# each retry
+_deadlock_VerboseFile = None
+
+
+def DeadlockWrap(function, *_args, **_kwargs):
+    """DeadlockWrap(function, *_args, **_kwargs) - automatically retries
+    function in case of a database deadlock.
+
+    This is a function intended to be used to wrap database calls such
+    that they perform retrys with exponentially backing off sleeps in
+    between when a DBLockDeadlockError exception is raised.
+
+    A 'max_retries' parameter may optionally be passed to prevent it
+    from retrying forever (in which case the exception will be reraised).
+
+        d = DB(...)
+        d.open(...)
+        DeadlockWrap(d.put, "foo", data="bar")  # set key "foo" to "bar"
+    """
+    sleeptime = _deadlock_MinSleepTime
+    max_retries = _kwargs.get('max_retries', -1)
+    if 'max_retries' in _kwargs:
+        del _kwargs['max_retries']
+    while True:
+        try:
+            return function(*_args, **_kwargs)
+        except db.DBLockDeadlockError:
+            if _deadlock_VerboseFile:
+                _deadlock_VerboseFile.write(
+                    'dbutils.DeadlockWrap: sleeping %1.3f\n' % sleeptime)
+            _sleep(sleeptime)
+            # exponential backoff in the sleep time
+            sleeptime *= 2
+            if sleeptime > _deadlock_MaxSleepTime:
+                sleeptime = _deadlock_MaxSleepTime
+            max_retries -= 1
+            if max_retries == -1:
+                raise
+
+
+#------------------------------------------------------------------------

test/ok_lib2.7/compiler/__init__.py

@@ -0,0 +1,31 @@
+"""Package for parsing and compiling Python source code
+
+There are several functions defined at the top level that are imported
+from modules contained in the package.
+
+parse(buf, mode="exec") -> AST
+    Converts a string containing Python source code to an abstract
+    syntax tree (AST).  The AST is defined in compiler.ast.
+
+parseFile(path) -> AST
+    The same as parse(open(path))
+
+walk(ast, visitor, verbose=None)
+    Does a pre-order walk over the ast using the visitor instance.
+    See compiler.visitor for details.
+
+compile(source, filename, mode, flags=None, dont_inherit=None)
+    Returns a code object.  A replacement for the builtin compile() function.
+
+compileFile(filename)
+    Generates a .pyc file by compiling filename.
+"""
+
+import warnings
+
+warnings.warn("The compiler package is deprecated and removed in Python 3.x.",
+              DeprecationWarning, stacklevel=2)
+
+from compiler.transformer import parse, parseFile
+from compiler.visitor import walk
+from compiler.pycodegen import compile, compileFile

test/ok_lib2.7/compiler/consts.py

@@ -0,0 +1,23 @@
+# operation flags
+OP_ASSIGN = 'OP_ASSIGN'
+OP_DELETE = 'OP_DELETE'
+OP_APPLY = 'OP_APPLY'
+
+SC_LOCAL = 1
+SC_GLOBAL_IMPLICIT = 2
+SC_GLOBAL_EXPLICIT = 3
+SC_FREE = 4
+SC_CELL = 5
+SC_UNKNOWN = 6
+
+CO_OPTIMIZED = 0x0001
+CO_NEWLOCALS = 0x0002
+CO_VARARGS = 0x0004
+CO_VARKEYWORDS = 0x0008
+CO_NESTED = 0x0010
+CO_GENERATOR = 0x0020
+CO_GENERATOR_ALLOWED = 0
+CO_FUTURE_DIVISION = 0x2000
+CO_FUTURE_ABSIMPORT = 0x4000
+CO_FUTURE_WITH_STATEMENT = 0x8000
+CO_FUTURE_PRINT_FUNCTION = 0x10000

test/ok_lib2.7/compiler/future.py

@@ -0,0 +1,74 @@
+"""Parser for future statements
+
+"""
+
+from compiler import ast, walk
+
+def is_future(stmt):
+    """Return true if statement is a well-formed future statement"""
+    if not isinstance(stmt, ast.From):
+        return 0
+    if stmt.modname == "__future__":
+        return 1
+    else:
+        return 0
+
+class FutureParser:
+
+    features = ("nested_scopes", "generators", "division",
+                "absolute_import", "with_statement", "print_function",
+                "unicode_literals")
+
+    def __init__(self):
+        self.found = {} # set
+
+    def visitModule(self, node):
+        stmt = node.node
+        for s in stmt.nodes:
+            if not self.check_stmt(s):
+                break
+
+    def check_stmt(self, stmt):
+        if is_future(stmt):
+            for name, asname in stmt.names:
+                if name in self.features:
+                    self.found[name] = 1
+                else:
+                    raise SyntaxError, \
+                          "future feature %s is not defined" % name
+            stmt.valid_future = 1
+            return 1
+        return 0
+
+    def get_features(self):
+        """Return list of features enabled by future statements"""
+        return self.found.keys()
+
+class BadFutureParser:
+    """Check for invalid future statements"""
+
+    def visitFrom(self, node):
+        if hasattr(node, 'valid_future'):
+            return
+        if node.modname != "__future__":
+            return
+        raise SyntaxError, "invalid future statement " + repr(node)
+
+def find_futures(node):
+    p1 = FutureParser()
+    p2 = BadFutureParser()
+    walk(node, p1)
+    walk(node, p2)
+    return p1.get_features()
+
+if __name__ == "__main__":
+    import sys
+    from compiler import parseFile, walk
+
+    for file in sys.argv[1:]:
+        print file
+        tree = parseFile(file)
+        v = FutureParser()
+        walk(tree, v)
+        print v.found
+        print

test/ok_lib2.7/compiler/misc.py

@@ -0,0 +1,73 @@
+
+def flatten(tup):
+    elts = []
+    for elt in tup:
+        if isinstance(elt, tuple):
+            elts = elts + flatten(elt)
+        else:
+            elts.append(elt)
+    return elts
+
+class Set:
+    def __init__(self):
+        self.elts = {}
+    def __len__(self):
+        return len(self.elts)
+    def __contains__(self, elt):
+        return elt in self.elts
+    def add(self, elt):
+        self.elts[elt] = elt
+    def elements(self):
+        return self.elts.keys()
+    def has_elt(self, elt):
+        return elt in self.elts
+    def remove(self, elt):
+        del self.elts[elt]
+    def copy(self):
+        c = Set()
+        c.elts.update(self.elts)
+        return c
+
+class Stack:
+    def __init__(self):
+        self.stack = []
+        self.pop = self.stack.pop
+    def __len__(self):
+        return len(self.stack)
+    def push(self, elt):
+        self.stack.append(elt)
+    def top(self):
+        return self.stack[-1]
+    def __getitem__(self, index): # needed by visitContinue()
+        return self.stack[index]
+
+MANGLE_LEN = 256 # magic constant from compile.c
+
+def mangle(name, klass):
+    if not name.startswith('__'):
+        return name
+    if len(name) + 2 >= MANGLE_LEN:
+        return name
+    if name.endswith('__'):
+        return name
+    try:
+        i = 0
+        while klass[i] == '_':
+            i = i + 1
+    except IndexError:
+        return name
+    klass = klass[i:]
+
+    tlen = len(klass) + len(name)
+    if tlen > MANGLE_LEN:
+        klass = klass[:MANGLE_LEN-tlen]
+
+    return "_%s%s" % (klass, name)
+
+def set_filename(filename, tree):
+    """Set the filename attribute to filename on every node in tree"""
+    worklist = [tree]
+    while worklist:
+        node = worklist.pop(0)
+        node.filename = filename
+        worklist.extend(node.getChildNodes())

uncompyle6/disas.py

@@ -18,36 +18,26 @@ want to run on Python 2.7.
 
 from __future__ import print_function
 
-import datetime, sys
+import os, sys
 from collections import deque
 
 import uncompyle6
 
 from xdis.main import disassemble_file as xdisassemble_file
-from xdis.util import format_code_info
 from xdis.code import iscode
 from xdis.load import check_object_path, load_module
-from uncompyle6 import PYTHON_VERSION
 from uncompyle6.scanner import get_scanner
 
-
-def disco(version, co, timestamp, out=None):
+def disco(version, co, out=None):
     """
     diassembles and deparses a given code block 'co'
     """
 
     assert iscode(co)
 
-    out.write('# Python bytecode %s (disassembled from Python %s)\n' %
-              (version, PYTHON_VERSION))
-    if timestamp > 0:
-        value = datetime.datetime.fromtimestamp(timestamp)
-        out.write(value.strftime('# Timestamp in code: '
-                                 '%Y-%m-%d %H:%M:%S\n'))
-
     # store final output stream for case of error
     real_out = out or sys.stdout
-
+    print('# Python %s' % version, file=real_out)
     if co.co_filename:
         print('# Embedded file name: %s' % co.co_filename,
               file=real_out)
@@ -55,15 +45,16 @@ def disco(version, co, timestamp, out=None):
     scanner = get_scanner(version)
 
     queue = deque([co])
-    disco_loop(scanner.disassemble, version, queue, real_out)
+    disco_loop(scanner.disassemble, queue, real_out)
 
 
-def disco_loop(disasm, version, queue, real_out):
+def disco_loop(disasm, queue, real_out):
     while len(queue) > 0:
         co = queue.popleft()
-
-        print(format_code_info(co, version), file=real_out)
-
+        if co.co_name != '<module>':
+            print('\n# %s line %d of %s' %
+                      (co.co_name, co.co_firstlineno, co.co_filename),
+                      file=real_out)
         tokens, customize = disasm(co)
         for t in tokens:
             if iscode(t.pattr):
@@ -81,17 +72,17 @@ def disassemble_file(filename, outstream=None, native=False):
     If given a Python source file (".py") file, we'll
     try to find the corresponding compiled object.
     """
-
     if native:
         xdisassemble_file(filename, outstream)
         return
+
     filename = check_object_path(filename)
     version, timestamp, magic_int, co = load_module(filename)
     if type(co) == list:
         for con in co:
-            disco(version, con, outstream, native)
+            disco(version, con, outstream)
     else:
-        disco(version, co, timestamp, outstream)
+        disco(version, co, outstream)
     co = None
 
 def _test():