get a redis RDB-like serialization of the object.

        :param name: str     the name of the redis key
        :return: Future()
541774
def dump(self, name):
        
        with self.pipe as pipe:
            return pipe.dump(self.redis_key(name))
248128
def hincrby(self, name, key, amount=1):
        
        with self.pipe as pipe:
            return pipe.hincrby(self.redis_key(name),
                                self.memberparse.encode(key),
                                amount)
1185548
def exists(self, name):
        
        with self.pipe as pipe:
            return pipe.exists(self.redis_key(name))
551218
def object(self, infotype, key):
        
        with self.pipe as pipe:
            return pipe.object(infotype, self.redis_key(key))
1039526
def get(self, name):
        
        schema = TagSchema()
        resp = self.service.get_id(self.base, name)
        return self.service.decode(schema, resp)
345568
async def redis(self) -> aioredis.Redis:
        
        # Use thread-safe asyncio Lock because this method without that is not safe
        async with self._connection_lock:
            if self._redis is None:
                self._redis = await aioredis.create_redis_pool((self._host, self._port),
                                                               db=self._db, password=self._password, ssl=self._ssl,
                                                               minsize=1, maxsize=self._pool_size,
                                                               loop=self._loop, **self._kwargs)
        return self._redis
539526
def hscan(self, name, cursor=0, match=None, count=None):
        
        with self.pipe as pipe:
            f = Future()
            res = pipe.hscan(self.redis_key(name), cursor=cursor,
                             match=match, count=count)

            def cb():
                data = {}
                m_decode = self.memberparse.decode
                for k, v in res[1].items():
                    k = m_decode(k)
                    v = self._value_decode(k, v)
                    data[k] = v

                f.set((res[0], data))

            pipe.on_execute(cb)
            return f
1098505
def get_record(self, name):
        

        result = {}
        result.update(self.records.get(name, {}))
        return result
1269472
def get(self, **kwargs):
        '''  '''
        redis = type(self.obj).get_redis()
        related = list(map(
            lambda id : self.model().get(debyte_string(id)),
            self.get_related_ids(redis, **kwargs)
        ))

        return related
1117505
def get(self, id):
        
        id = self.key_name(id)
        session_json = self.redis.get(id) or '{}'
        return json_loads(session_json)
1058166
def incrby(self, name, amount=1):
        
        with self.pipe as pipe:
            return pipe.incrby(self.redis_key(name), amount=amount)
575763
def ttl(self, name):
        
        with self.pipe as pipe:
            return pipe.ttl(self.redis_key(name))
311768
def fetch_by_relname(self, name):
        

        ormclass = self._mapped[name]
        query = self.session.query(ormclass)

        if name != carr_ormclass:

            query = query.filter(
                ormclass.scn_name == self.scn_name)

        if self.version:
            query = query.filter(ormclass.version == self.version)

        # TODO: Naming is not consistent. Change in database required.
        if name == 'Transformer':
            name = 'Trafo'

        df = pd.read_sql(query.statement,
                         self.session.bind,
                         index_col=name.lower() + '_id')
        if name == 'Link':
            df['bus0'] = df.bus0.astype(int)
            df['bus1'] = df.bus1.astype(int)

        if 'source' in df:
            df.source = df.source.map(self.id_to_source())

        return df
340210
def get(self, name: str, default: Optional[Any]=None) -> Any:
        """"""
        return self.__dict__.get(name, default)
590981
def get_object(self, name, obj):
        
        return self[name](obj, **self.opts(name))
528399
def zcard(self, name):
        
        with self.pipe as pipe:
            return pipe.zcard(self.redis_key(name))
79369
def get_redis_storage(data_type, full_name, args = {})
      self.class.redis_ping!
      case data_type.to_sym
      when :array
        Redis::List.new(full_name, {:marshal => true}.merge(args))
      when :hash
        Redis::HashKey.new(full_name)
      when :value
        Redis::Value.new(full_name, {:marshal => true}.merge(args))
      when :lock
        Redis::Lock.new(full_name, {:expiration => 60, :timeout => 0.1}.merge(args))
      when :stamped
        Stamped.new(full_name.sub("#{key}_", "").to_sym, get_redis_storage(:value, full_name), self)
      else
        raise TypeError.new("Unsupported caching data type encountered: #{data_type}")
      end
    end