def create(self, test):
     session = test.session()
     with session.begin() as t:
         for name, typ, ccy in zip(self.inames, self.itypes, self.iccys):
             t.add(Instrument(name=name, type=typ, ccy=ccy))
         for name in self.gnames:
             t.add(Group(name=name))
         for name, ccy in zip(self.inames, self.iccys):
             t.add(Fund(name=name, ccy=ccy))
     yield t.on_result
     iall = yield test.session().query(Instrument).load_only('id').all()
     fall = yield test.session().query(Fund).load_only('id').all()
     with session.begin() as t:
         for i in iall:
             t.add(ObjectAnalytics(model_type=Instrument, object_id=i.id))
         for i in fall:
             t.add(ObjectAnalytics(model_type=Fund, object_id=i.id))
     yield t.on_result
     obj_len = self.size[1]
     groups = yield session.query(Group).all()
     objs = yield session.query(ObjectAnalytics).all()
     groups = self.populate('choice', obj_len, choice_from=groups)
     objs = self.populate('choice', obj_len, choice_from=objs)
     with test.session().begin() as t:
         for g, o in zip(groups, objs):
             t.add(AnalyticData(group=g, object=o))
     yield t.on_result

 def create(self, test, use_transaction=True):
     session = test.session()
     models = test.mapper
     eq = assertEqual if isinstance(test, type) else test.assertEqual
     c = yield models.instrument.query().count()
     eq(c, 0)
     if use_transaction:
         with session.begin() as t:
             for name, ccy in zip(self.fund_names, self.fund_ccys):
                 t.add(models.fund(name=name, ccy=ccy))
             for name, typ, ccy in zip(self.inst_names, self.inst_types,
                                       self.inst_ccys):
                 t.add(models.instrument(name=name, type=typ, ccy=ccy))
         yield t.on_result
     else:
         test.register()
         for name, typ, ccy in zip(self.inst_names, self.inst_types,
                                   self.inst_ccys):
             yield models.instrument.new(name=name, type=typ, ccy=ccy)
         for name, ccy in zip(self.fund_names, self.fund_ccys):
             yield models.fund(name=name, ccy=ccy)
     self.num_insts = yield models.instrument.query().count()
     self.num_funds = yield models.fund.query().count()
     eq(self.num_insts, len(self.inst_names))
     eq(self.num_funds, len(self.fund_names))
     yield session

    def load_related(self, result):
        '''load related fields into the query result.

:parameter result: a result from a queryset.
:rtype: the same queryset qith related models loaded.'''
        if self.qs.select_related:
            if not hasattr(result,'__len__'):
                result = list(result)
            meta = self.meta
            for field in self.qs.select_related:
                name = field.name
                attname = field.attname
                vals = [getattr(r,attname) for r in result]
                if field in meta.scalarfields:
                    related = field.relmodel.objects.filter(id__in = vals)
                    for r,val in zip(result,related):
                        setattr(r,name,val)
                else:
                    with self.backend.transaction() as t:
                        for val in vals:
                            val.reload(t)
                    for val,r in zip(vals,t.get_result()):
                        val.set_cache(r)
                        
        return result

 def setUp(self):
     '''Create Instruments and Funds'''
     session = self.session()
     with session.begin():
         for name,typ,ccy in zip(inst_names,inst_types,inst_ccys):
             session.add(Instrument(name = name, type = typ, ccy = ccy))
         for name,ccy in zip(fund_names,fund_ccys):
             session.add(Fund(name = name, ccy = ccy))

def as_dict(times, fields):
    lists = []
    names = []
    d = {}
    for name, value in fields.items():
        names.append(name)
        lists.append(value)
    for dt, data in zip(times, zip(*lists)):
        d[dt] = dict(zip(names, data))
    return d

 def generate(self):
     self.dates = self.populate('date')
     self.values = self.populate('float', start=10, end=400)
     self.dates2 = self.populate('date', start=date(2009,1,1),
                                         end=date(2010,1,1))
     self.big_strings = self.populate(min_len=300, max_len=1000)
     self.alldata   = list(zip(self.dates, self.values))
     self.alldata2  = list(zip(self.dates2, self.values))
     self.testdata  = dict(self.alldata)
     self.testdata2 = dict(self.alldata2)

 def unwind_query(self, meta, qset):
     """Unwind queryset"""
     table = meta.table()
     ids = list(qset)
     make_object = self.make_object
     for id, data in zip(ids, table.mget(ids)):
         yield make_object(meta, id, data)

 def create_one(self):
     ts = self.structure()
     ts.update(zip(self.data.dates, self.data.values))
     self.assertFalse(ts.cache.cache)
     self.assertTrue(ts.cache.toadd)
     self.assertFalse(ts.cache.toremove)
     return ts

 def setUp(self):
     size = self.sizes.get(getattr(self,'test_size','normal'))
     inst_names = populate('string',size, min_len = 5, max_len = 20)
     inst_types = populate('choice',size, choice_from = insts_types)
     inst_ccys  = populate('choice',size, choice_from = ccys_types)
     with transaction(Instrument) as t:
         for name,typ,ccy in zip(inst_names,inst_types,inst_ccys):
             Instrument(name = name, type = typ, ccy = ccy).save(t)

 def testPushBack(self):
     li = SimpleList().save()
     names = li.names
     for elem in elems:
         names.push_back(elem)
     li.save()
     for el,ne in zip(elems,names):
         self.assertEqual(el,ne)

 def testPushFront(self):
     li = SimpleList().save()
     names = li.names
     for elem in reversed(elems):
         names.push_front(elem)
     li.save()
     for el,ne in zip(elems,names):
         self.assertEqual(el,ne)

def zset_score_pairs(response, **options):
    """
    If ``withscores`` is specified in the options, return the response as
    a list of (value, score) pairs
    """
    if not response or not options['withscores']:
        return response
    return zip(response[::2], map(float, response[1::2]))

 def _wrap_commit(self, request, response, iids=None, **options):
     for id, iid in zip(response, iids):
         id, flag, info = id
         if int(flag):
             yield instance_session_result(iid, True, id, False, float(info))
         else:
             msg = info.decode(request.encoding)
             yield CommitException(msg)

 def callback(self, response, args, session=None):
     # The session has received the callback from redis client
     data = []
     for instance, id in list(zip(session, response)):
         instance = session.server_update(instance, id)
         if instance:
             data.append(instance)
     return data

 def setUp(self):
     '''Create Instruments and Funds commiting at the end for speed'''
     session = self.session()
     with session.begin():
         session.add(Dictionary(name='test'))
         session.add(Dictionary(name='test2'))
     self.assertEqual(session.query(Dictionary).count(),2)
     self.data = dict(zip(dict_keys,dict_values))

 def testPushFront(self):
     li = SimpleList().save()
     if li.session.backend.name == 'redis':
         names = li.names
         for elem in reversed(elems):
             names.push_front(elem)
         li.save()
         for el,ne in zip(elems,names):
             self.assertEqual(el,ne)

 def testPushBack(self):
     li = SimpleList().save()
     with li.session.begin():
         names = li.names
         for elem in elems:
             names.push_back(elem)
     for el, ne in zip(elems, names):
         self.assertEqual(el, ne)
     self.assertEqual(li.names.size(), len(elems))

def _load_missing_scripts(results, positions, res):
    for i,r in zip(positions,res):
        if i == -1:
            if isinstance(r, Exception):
                raise r
            else:
                continue
        results[i] = r
    return results

def pairs_to_dict(response, encoding, value_encoder=0):
    "Create a dict given a list of key/value pairs"
    if response:
        v1 = (r.decode(encoding) for r in response[::2])
        v2 = response[1::2]
        if value_encoder:
            v2 = (value_encoder(v) for v in v2)
        return zip(v1,v2)
    else:
        return ()

 def testData(self):
     ts = orm.TS()
     ts.update(zip(dates,values))
     ts.save()
     self.assertEqual(ts.size(),len(dates))
     front = ts.front()
     back = ts.back()
     self.assertTrue(back>front)
     range = list(ts.range(date(2009,10,1),date(2010,5,1)))
     self.assertTrue(range)