Python Shove.update方法代码示例

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]
class TestDbmStore(unittest.TestCase):

    def setUp(self): 
        self.store = Shove('dbm://test.dbm', compress=True)

    def tearDown(self): 
        self.store.close()
        os.remove('test.dbm')

    def test__getitem__(self):
        self.store['max'] = 3
        self.assertEqual(self.store['max'], 3)

    def test__setitem__(self):
        self.store['max'] = 3
        self.assertEqual(self.store['max'], 3)

    def test__delitem__(self):
        self.store['max'] = 3
        del self.store['max']
        self.assertEqual('max' in self.store, False)

    def test_get(self):
        self.store['max'] = 3        
        self.assertEqual(self.store.get('min'), None)
            
    def test__cmp__(self):
        tstore = Shove()
        self.store['max'] = 3
        tstore['max'] = 3
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.assertEqual(len(self.store), 2)

    def test_close(self):
        self.store.close()
        self.assertEqual(self.store, None)

    def test_clear(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.clear()
        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.items())
        self.assertEqual(('min', 6) in slist, True)

    def test_iteritems(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iteritems())
        self.assertEqual(('min', 6) in slist, True)

    def test_iterkeys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iterkeys())
        self.assertEqual('min' in slist, True)

    def test_itervalues(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store['max'] = 3
        self.store['min'] = 6
        item = self.store.pop('min')
        self.assertEqual(item, 6)
        
    def test_popitem(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        item = self.store.popitem()
        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['powl'] = 7
        self.store.setdefault('pow', 8)
        self.assertEqual(self.store['pow'], 8)

    def test_update(self):
        tstore = Shove()
        tstore['max'] = 3
        tstore['min'] = 6
#.........这里部分代码省略.........

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]

#.........这里部分代码省略.........
    def test_get(self):
        self.store['max'] = 3
        self.assertEqual(self.store.get('min'), None)

    def test__cmp__(self):
        from shove import Shove
        tstore = Shove()
        self.store['max'] = 3
        tstore['max'] = 3
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.assertEqual(len(self.store), 2)

    def test_close(self):
        self.store.close()
        self.assertEqual(self.store, None)

    def test_clear(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.clear()
        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.items())
        self.assertEqual(('min', 6) in slist, True)

    def test_iteritems(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iteritems())
        self.assertEqual(('min', 6) in slist, True)

    def test_iterkeys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iterkeys())
        self.assertEqual('min' in slist, True)

    def test_itervalues(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store['max'] = 3
        self.store['min'] = 6
        item = self.store.pop('min')
        self.assertEqual(item, 6)

    def test_popitem(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        item = self.store.popitem()
        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.setdefault('bow', 8)
        self.assertEqual(self.store['bow'], 8)

    def test_update(self):
        from shove import Shove
        tstore = Shove()
        tstore['max'] = 3
        tstore['min'] = 6
        tstore['pow'] = 7
        self.store['max'] = 2
        self.store['min'] = 3
        self.store['pow'] = 7
        self.store.update(tstore)
        self.assertEqual(self.store['min'], 6)

    def test_values(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = self.store.values()
        self.assertEqual(6 in slist, True)

    def test_keys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = self.store.keys()
        self.assertEqual('min' in slist, True)

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]

#.........这里部分代码省略.........

    def test__len__(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store.sync()
        self.assertEqual(len(self.store), 2)

    def test_clear(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        self.store.clear()
        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = list(self.store.items())
        self.assertEqual(('min', 6) in slist, True)

    def test_iteritems(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = list(self.store.iteritems())
        self.assertEqual(('min', 6) in slist, True)

    def test_iterkeys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = list(self.store.iterkeys())
        self.assertEqual('min' in slist, True)

    def test_itervalues(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store.sync()
        item = self.store.pop('min')
        self.assertEqual(item, 6)

    def test_popitem(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        item = self.store.popitem()
        self.store.sync()
        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['powl'] = 7
        self.store.setdefault('pow', 8)
        self.store.sync()
        self.assertEqual(self.store['pow'], 8)

    def test_update(self):
        from shove import Shove
        tstore = Shove()
        tstore['max'] = 3
        tstore['min'] = 6
        tstore['pow'] = 7
        self.store['max'] = 2
        self.store['min'] = 3
        self.store['pow'] = 7
        self.store.sync()
        self.store.update(tstore)
        self.store.sync()
        self.assertEqual(self.store['min'], 6)

    def test_values(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = self.store.values()
        self.assertEqual(6 in slist, True)

    def test_keys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = self.store.keys()
        self.assertEqual('min' in slist, True)

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]

#.........这里部分代码省略.........
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store.sync()
        self.assertEqual(len(self.store), 2)

    def test_clear(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.sync()
        self.store.clear()
        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.sync()
        slist = list(self.store.items())
        self.assertEqual(("min", 6) in slist, True)

    def test_iteritems(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.sync()
        slist = list(self.store.iteritems())
        self.assertEqual(("min", 6) in slist, True)

    def test_iterkeys(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.sync()
        slist = list(self.store.iterkeys())
        self.assertEqual("min" in slist, True)

    def test_itervalues(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.sync()
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store.sync()
        item = self.store.pop("min")
        self.assertEqual(item, 6)

    def test_popitem(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.sync()
        item = self.store.popitem()
        self.store.sync()
        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["powl"] = 7
        self.store.setdefault("pow", 8)
        self.store.sync()
        self.assertEqual(self.store["pow"], 8)

    def test_update(self):
        tstore = Shove()
        tstore["max"] = 3
        tstore["min"] = 6
        tstore["pow"] = 7
        self.store["max"] = 2
        self.store["min"] = 3
        self.store["pow"] = 7
        self.store.sync()
        self.store.update(tstore)
        self.store.sync()
        self.assertEqual(self.store["min"], 6)

    def test_values(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.sync()
        slist = self.store.values()
        self.assertEqual(6 in slist, True)

    def test_keys(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.sync()
        slist = self.store.keys()
        self.assertEqual("min" in slist, True)

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]

#.........这里部分代码省略.........
        del self.store['max']
        self.assertEqual('max' in self.store, False)

    def test_get(self):
        self.store['max'] = 3
        self.assertEqual(self.store.get('min'), None)

    def test__cmp__(self):
        from shove import Shove
        tstore = Shove()
        self.store['max'] = 3
        tstore['max'] = 3
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.assertEqual(len(self.store), 2)

#    def test_clear(self):
#        self.store['max'] = 3
#        self.store['min'] = 6
#        self.store['pow'] = 7
#        self.store.clear()
#        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.items())
        self.assertEqual(('min', 6) in slist, True)

    def test_iteritems(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iteritems())
        self.assertEqual(('min', 6) in slist, True)

    def test_iterkeys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iterkeys())
        self.assertEqual('min' in slist, True)

    def test_itervalues(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store['max'] = 3
        self.store['min'] = 6
        item = self.store.pop('min')
        self.assertEqual(item, 6)

#    def test_popitem(self):
#        self.store['max'] = 3
#        self.store['min'] = 6
#        self.store['pow'] = 7
#        item = self.store.popitem()
#        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store['max'] = 3
        self.store['min'] = 6
#        self.store['pow'] = 7
        self.store.setdefault('pow', 8)
        self.assertEqual(self.store.setdefault('pow', 8), 8)
        self.assertEqual(self.store['pow'], 8)

    def test_update(self):
        from shove import Shove
        tstore = Shove()
        tstore['max'] = 3
        tstore['min'] = 6
        tstore['pow'] = 7
        self.store['max'] = 2
        self.store['min'] = 3
        self.store['pow'] = 7
        self.store.update(tstore)
        self.assertEqual(self.store['min'], 6)

    def test_values(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = self.store.values()
        self.assertEqual(6 in slist, True)

    def test_keys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = self.store.keys()
        self.assertEqual('min' in slist, True)

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]
class DataManager():
    def __init__(self, filename, connection_details=VERTICA_CONNECTION):
        self.filename = filename
        self.store = Shove('file://'+self.filename, 'memory://', optimize=False)
        self.connection_details = connection_details

    @staticmethod
    def get_attribute_name(data_set, attribute):
        return '_' + data_set + '_' + attribute

    def get_data_set_attribute(self, data_set, key):
        attrib_name = self.get_attribute_name(data_set, key)
        if self.has_attribute(data_set, key):
            return self.store[attrib_name]
        else:
            return None
        self.store.close()
        gc.collect()
        self.store = Shove('file://'+self.filename, 'memory://', optimize=False)

    def set_data_set_attribute(self, data_set, key, value):
        attrib_name = self.get_attribute_name(data_set, key)
        self.store.update({attrib_name: value})
        self.store.sync()
        self.store.close()
        gc.collect()
        self.store = Shove('file://'+self.filename, 'memory://', optimize=False)

    def has_attribute(self, data_set, key):
        attrib_name = self.get_attribute_name(data_set, key)
        if attrib_name in self.store.keys():
            return True
        else:
            return False

    def remove_attribute(self, data_set, key):
        attrib_name = self.get_attribute_name(data_set, key)
        if attrib_name in self.store:
            del self.store[attrib_name]
            self.store.sync()

    def get_data_set_list(self):
        data_sets = [key.split('_')[1] for key in self.store.keys() if '_query' in key]
        return data_sets

    def fetch_from_vertica_to_df(self, data_set, query):
        data_set_query = self.get_data_set_attribute(data_set, 'query')
        if data_set_query != query:
            connection = connect(self.connection_details)
            cursor = connection.cursor()
            print 'Executing ', data_set, 'Query...'
            print query
            columns = get_column_names_from_sql_query(query)
            cursor.execute(query)

            data = []
            while True:
                rows = cursor.fetchmany(10000)
                data.extend([[str(ele) for ele in row] for row in rows])
                if len(rows) <= 1:
                    break

            df = MetadataDataFrame(data=data, columns=columns, meta_info={'query': query, 'built_features': [], 'aggregate_values': {},
                                                               'columns': columns})

            cursor.close()
            if len(df) == 0:
                raise(ValueError('SQL result in empty fetch!!'))
            else:
                self.set_data_set_attribute(data_set, 'data', df)
                self.set_data_set_attribute(data_set, 'query', query)
                self.set_data_set_attribute(data_set, 'columns', columns)
                self.set_data_set_attribute(data_set, 'built_features', [])

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]

#.........这里部分代码省略.........
        self.assertEqual(self.store.get("min"), None)

    def test__cmp__(self):
        from shove import Shove

        tstore = Shove()
        self.store["max"] = 3
        tstore["max"] = 3
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.assertEqual(len(self.store), 2)

    def test_close(self):
        self.store.close()
        self.assertEqual(self.store, None)

    def test_clear(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        self.store.clear()
        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        slist = list(self.store.items())
        self.assertEqual(("min", 6) in slist, True)

    def test_iteritems(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        slist = list(self.store.iteritems())
        self.assertEqual(("min", 6) in slist, True)

    def test_iterkeys(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        slist = list(self.store.iterkeys())
        self.assertEqual("min" in slist, True)

    def test_itervalues(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store["max"] = 3
        self.store["min"] = 6
        item = self.store.pop("min")
        self.assertEqual(item, 6)

    def test_popitem(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        item = self.store.popitem()
        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["powl"] = 7
        self.store.setdefault("pow", 8)
        self.assertEqual(self.store["pow"], 8)

    def test_update(self):
        from shove import Shove

        tstore = Shove()
        tstore["max"] = 3
        tstore["min"] = 6
        tstore["pow"] = 7
        self.store["max"] = 2
        self.store["min"] = 3
        self.store["pow"] = 7
        self.store.update(tstore)
        self.assertEqual(self.store["min"], 6)

    def test_values(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        slist = self.store.values()
        self.assertEqual(6 in slist, True)

    def test_keys(self):
        self.store["max"] = 3
        self.store["min"] = 6
        self.store["pow"] = 7
        slist = self.store.keys()
        self.assertEqual("min" in slist, True)

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]
def ngs_cdhit2d(lib_records, output_prefix, **kwargs):
    '''run cdhit2d on whole unique read library against designed library'''
    
    print >> sys.stderr, (
        'Aligning unique sequences to designed library with cd-hit-2d...')
    sys.stderr.flush()
    
    counts_filename = output_prefix+'.counts.fa'
    
    if kwargs['skip_finished'] and os.path.exists(output_prefix+'.clstr'):
        print >> sys.stderr, '\tFiles present; cd-hit-2d skipped.\n'
        sys.stderr.flush()
    else:
        if kwargs['multi']:
            query_file = open(counts_filename, 'r')
            query_file.close()
        else:
            query_file = tempfile.NamedTemporaryFile(delete=False)
            SeqIO.write(fq_unique_records, query_file, 'fasta')
            query_file.close()

        lib_file = tempfile.NamedTemporaryFile(delete=False)
        SeqIO.write(lib_records, lib_file, 'fasta')
        lib_file.close()
        
        #option_string='-G 1 -aL .9 -p 1 -d 0 -g 1 -c 0.8 -aS 1 -n 5 -t 5 -T 0'
        option_string='-G 1 -aS 1 -aL 1 -d 0 -g 1 -c 1 -n 5 -t 5 -T 0 -M 7500'
        
        align.call_cdhit2d(lib_file.name, query_file.name, output_prefix, 
            option_string=option_string, **kwargs)
        
    (queries, lib_mems) = align.parse_cdhit_clusters(
        output_prefix+'.clstr', plate_labels= False, **kwargs)

    print >> sys.stderr, (
        'Reading sequence dictionary objects...')
    sys.stderr.flush()
            
    fq_fhandle = open(counts_filename, 'r')
    
    #lm_shove = Shove('file://'+output_prefix + '.shove.libmems')
    lm_shove = Shove()
    #seqdict = Shove('file://'+output_prefix + '.shove.seqdict')
    seqdict = Shove()
    #seqannotdict = Shove('file://'+output_prefix + '.shove.sadict')
    
    seqdict = util.quick_fasta(counts_filename, 
        get_annotations= True, seqdict= seqdict)
    
    libdict = align.seqrecord_list_to_seqrecord_dict(lib_records)
    
    lm_shove.update(lib_mems)
    
    #for lm in lib_mems:
    #    lm_shove[lm] = lib_mems[lm]
    
    for member in queries:
        seqdict[member][1]['matched'] = True
        seqdict[member][1]['designed'] = queries[member]

    print >> sys.stderr, (
        '\tSeqRecord objects complete.\n')
    sys.stderr.flush()
    
    return libdict, seqdict

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]
class TestLevelDBStore(unittest2.TestCase):

    def setUp(self):
        from shove import Shove
        self.store = Shove('leveldb://test', compress=True)

    def tearDown(self):
        import shutil
        shutil.rmtree('test')

    def test__getitem__(self):
        self.store['max'] = 3
        self.assertEqual(self.store['max'], 3)

    def test__setitem__(self):
        self.store['max'] = 3
        self.assertEqual(self.store['max'], 3)

    def test__delitem__(self):
        self.store['max'] = 3
        del self.store['max']
        self.assertEqual('max' in self.store, False)

    def test_get(self):
        self.store['max'] = 3
        self.assertEqual(self.store.get('min'), None)

    def test__cmp__(self):
        from shove import Shove
        tstore = Shove()
        self.store['max'] = 3
        tstore['max'] = 3
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.assertEqual(len(self.store), 2)

    def test_close(self):
        self.store.close()
        self.assertEqual(self.store, None)

    def test_clear(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.clear()
        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.items())
        self.assertEqual(('min', 6) in slist, True)

    def test_iteritems(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iteritems())
        self.assertEqual(('min', 6) in slist, True)

    def test_iterkeys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iterkeys())
        self.assertEqual('min' in slist, True)

    def test_itervalues(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store['max'] = 3
        self.store['min'] = 6
        item = self.store.pop('min')
        self.assertEqual(item, 6)

    def test_popitem(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        item = self.store.popitem()
        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.setdefault('bow', 8)
        self.assertEqual(self.store['bow'], 8)

    def test_update(self):
        from shove import Shove
#.........这里部分代码省略.........

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]
class TestRedisStore(unittest.TestCase):

    def setUp(self):
        from shove import Shove
        self.store = Shove('redis://localhost:6379/0')

    def tearDown(self):
        self.store.clear()
        self.store.close()

    def test__getitem__(self):
        self.store['max'] = 3
        self.assertEqual(self.store['max'], 3)

    def test__setitem__(self):
        self.store['max'] = 3
        self.assertEqual(self.store['max'], 3)

    def test__delitem__(self):
        self.store['max'] = 3
        del self.store['max']
        self.assertEqual('max' in self.store, False)

    def test_get(self):
        self.store['max'] = 3
        self.assertEqual(self.store.get('min'), None)

    def test__cmp__(self):
        from shove import Shove
        tstore = Shove()
        self.store['max'] = 3
        tstore['max'] = 3
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.assertEqual(len(self.store), 2)

    def test_clear(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.clear()
        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.items())
        self.assertEqual(('min', 6) in slist, True)

    def test_iteritems(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iteritems())
        self.assertEqual(('min', 6) in slist, True)

    def test_iterkeys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iterkeys())
        self.assertEqual('min' in slist, True)

    def test_itervalues(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store['max'] = 3
        self.store['min'] = 6
        item = self.store.pop('min')
        self.assertEqual(item, 6)

    def test_popitem(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        item = self.store.popitem()
        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['powl'] = 7
        self.store.setdefault('pow', 8)
        self.assertEqual(self.store.setdefault('pow', 8), 8)
        self.assertEqual(self.store['pow'], 8)

    def test_update(self):
        from shove import Shove
        tstore = Shove()
        tstore['max'] = 3
        tstore['min'] = 6
#.........这里部分代码省略.........

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]
class Store(object):

    def setUp(self):
        from shove import Shove
        self.store = Shove(
            self.initstring, sync=0
        )

    def tearDown(self):
        self.store.close()

    def test__getitem__(self):
        self.store['max'] = 3
        self.store.sync()
        self.assertEqual(self.store['max'], 3)

    def test__setitem__(self):
        self.store['max'] = 3
        self.store['d'] = {'A': 1}, {'A': 1}
        self.store['d'] = {'AA': 1}, {'A': 1}
        self.store['d'] = {'AA': 1}, {'AA': 1}
        self.store.sync()
        self.assertEqual(self.store['max'], 3)

    def test__delitem__(self):
        self.store['max'] = 3
        self.store.sync()
        del self.store['max']
        self.store.sync()
        self.assertEqual('max' in self.store, False)

    def test_get(self):
        self.store['max'] = 3
        self.store.sync()
        self.assertEqual(self.store.get('min'), None)

    def test__cmp__(self):
        from shove import Shove
        tstore = Shove()
        self.store['max'] = 3
        self.store.sync()
        tstore['max'] = 3
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store.sync()
        self.assertEqual(len(self.store), 2)

    def test_items(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = list(items(self.store))
        self.assertEqual(('min', 6) in slist, True)

    def test_keys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = list(keys(self.store))
        self.assertEqual('min' in slist, True)

    def test_values(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.sync()
        slist = list(values(self.store))
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store.sync()
        item = self.store.pop('min')
        self.store.sync()
        self.assertEqual(item, 6)

    def test_setdefault(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store.sync()
        self.assertEqual(self.store.setdefault('pow', 8), 8)
        self.store.sync()
        self.assertEqual(self.store['pow'], 8)

    def test_update(self):
        from shove import Shove
        tstore = Shove()
        tstore['max'] = 3
        tstore['min'] = 6
        tstore['pow'] = 7
        self.store['max'] = 2
        self.store['min'] = 3
        self.store['pow'] = 7
        self.store.update(tstore)
#.........这里部分代码省略.........

# 需要导入模块: from shove import Shove [as 别名]
# 或者: from shove.Shove import update [as 别名]

#.........这里部分代码省略.........
        self.assertEqual(self.store.get('min'), None)

    def test__cmp__(self):
        from shove import Shove
        tstore = Shove()
        self.store['max'] = 3
        tstore['max'] = 3
        self.store.sync()
        tstore.sync()
        self.assertEqual(self.store, tstore)

    def test__len__(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.assertEqual(len(self.store), 2)

    def test_close(self):
        self.store.close()
        self.assertEqual(self.store, None)

    def test_clear(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        self.store.clear()
        self.assertEqual(len(self.store), 0)

    def test_items(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.items())
        self.assertEqual(('min', 6) in slist, True)

    def test_iteritems(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iteritems())
        self.assertEqual(('min', 6) in slist, True)

    def test_iterkeys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.iterkeys())
        self.assertEqual('min' in slist, True)

    def test_itervalues(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = list(self.store.itervalues())
        self.assertEqual(6 in slist, True)

    def test_pop(self):
        self.store['max'] = 3
        self.store['min'] = 6
        item = self.store.pop('min')
        self.assertEqual(item, 6)

    def test_popitem(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        item = self.store.popitem()
        self.assertEqual(len(item) + len(self.store), 4)

    def test_setdefault(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['powl'] = 7
        self.store.setdefault('pow', 8)
        self.assertEqual(self.store['pow'], 8)

    def test_update(self):
        from shove import Shove
        tstore = Shove()
        tstore['max'] = 3
        tstore['min'] = 6
        tstore['pow'] = 7
        self.store['max'] = 2
        self.store['min'] = 3
        self.store['pow'] = 7
        self.store.update(tstore)
        self.assertEqual(self.store['min'], 6)

    def test_values(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = self.store.values()
        self.assertEqual(6 in slist, True)

    def test_keys(self):
        self.store['max'] = 3
        self.store['min'] = 6
        self.store['pow'] = 7
        slist = self.store.keys()
        self.assertEqual('min' in slist, True)