diff --git a/JumpScale9RecordChain/clients/zdb/ZDBClientNS.py b/JumpScale9RecordChain/clients/zdb/ZDBClientNS.py
index b3cf5f8..358cf92 100644
--- a/JumpScale9RecordChain/clients/zdb/ZDBClientNS.py
+++ b/JumpScale9RecordChain/clients/zdb/ZDBClientNS.py
@@ -8,9 +8,10 @@
 
 JSBASE = j.application.jsbase_get_class()
 
+
 class ZDBClientNS(JSBASE):
 
-    def __init__(self,zdbclient,nsname ):
+    def __init__(self, zdbclient, nsname):
         """
         is connection to ZDB
 
@@ -27,26 +28,25 @@ def __init__(self,zdbclient,nsname ):
 
         self.zdbclient = zdbclient
         self.redis = j.clients.redis.get(ipaddr=zdbclient.config.data['addr'],
-                                    port=zdbclient.config.data['port'],
-                                    fromcache=False)
+                                         port=zdbclient.config.data['port'],
+                                         fromcache=False)
 
         self.redis = self._patch_redis_client(self.redis)
 
-
         self.nsname = nsname.lower().strip()
         self.mode = self.zdbclient.mode
 
         if self.adminsecret is not "":
             self.redis.execute_command("AUTH", self.adminsecret)
 
-        #put secret on namespace & select namespace
+        # put secret on namespace & select namespace
         if self.secret is "":
             self.redis.execute_command("SELECT", self.nsname)
         else:
             self.redis.execute_command("SELECT", self.nsname, self.secret)
 
     @property
-    def adminsecret(self):        
+    def adminsecret(self):
         return self.zdbclient.adminsecret
 
     @property
@@ -60,28 +60,30 @@ def _patch_redis_client(self, redis):
         # don't auto parse response for set, cause it's not 100% redis compatible
         # 0-db does return a key after in set
         del redis.response_callbacks['SET']
+        # don't auto parse response for del, 0-db returns OK for success instead of the number of key deleted
+        del redis.response_callbacks['DEL']
         return redis
 
-    def _key_get(self,key,set=True):
-        
-        if self.mode=="seq":
+    def _key_get(self, key, set=True):
+
+        if self.mode == "seq":
             if key is None:
-                key=""
+                key = ""
             else:
-                key = struct.pack("<I", key) 
-        elif self.mode=="direct":
+                key = struct.pack("<I", key)
+        elif self.mode == "direct":
             if set:
-                if not key in ["",None]:
+                if not key in ["", None]:
                     raise j.exceptions.Input("key need to be None or empty string")
                 if key is None:
-                    key=""                
+                    key = ""
             else:
-                if key in ["",None]:
-                    raise j.exceptions.Input("key cannot be None or empty string")                
-        elif self.mode=="user":
-            if key in ["",None]:
+                if key in ["", None]:
+                    raise j.exceptions.Input("key cannot be None or empty string")
+        elif self.mode == "user":
+            if key in ["", None]:
                 raise j.exceptions.Input("key cannot be None or empty string")
-        return key        
+        return key
 
     def set(self, data, key=None):
         """[summary]
@@ -98,9 +100,9 @@ def set(self, data, key=None):
 
 
         """
-        key = self._key_get(key,set=True)
-        
-        key = struct.unpack("<I",self.redis.execute_command("SET", key, data))[0]
+        key = self._key_get(key, set=True)
+
+        key = struct.unpack("<I", self.redis.execute_command("SET", key, data))[0]
         return key
 
     def get(self, key):
@@ -116,7 +118,7 @@ def get(self, key):
             key {[6 byte binary]} -- is binary position is for direct mode
 
         """
-        key = self._key_get(key,set=False)
+        key = self._key_get(key, set=False)
         return self.redis.execute_command("GET", key)
 
     def exists(self, key):
@@ -125,10 +127,20 @@ def exists(self, key):
         Arguments:
             key {[type]} - - [description] is id or key
         """
-        key = self._key_get(key,set=False)
+        key = self._key_get(key, set=False)
 
         return self.redis.execute_command("EXISTS", key) == 1
 
+    def delete(self, key):
+        """
+        delete a key
+
+        :param key: key of the entry to delete
+        :type key: str
+        """
+        key = self._key_get(key, set=False)
+        if self.redis.execute_command("EXISTS", key) == 1:
+            self.redis.execute_command('DEL', key)
 
         # if self.mode=="seq":
         #     id = struct.pack("<I", key)
@@ -169,13 +181,14 @@ def nsinfo(self):
                 res[key] = str(val).strip()
         return res
 
-    def list(self, key_start=None, direction="forward", nrrecords=100000,result=None):
+    def list(self, key_start=None, direction="forward", nrrecords=100000, result=None):
         if result is None:
-            result=[]
-        def do(arg,result):
+            result = []
+
+        def do(arg, result):
             result.append(arg)
             return result
-        self.iterate(do,key_start=key_start,direction=direction,nrrecords=nrrecords,_keyonly=True,result=result)
+        self.iterate(do, key_start=key_start, direction=direction, nrrecords=nrrecords, _keyonly=True, result=result)
         return result
 
     def iterate(self, method, key_start=None, direction="forward", nrrecords=100000, _keyonly=False, result=None):
@@ -198,37 +211,42 @@ def iterate(self, method, key_start=None, direction="forward", nrrecords=100000,
 
         """
         if result is None:
-            result=[]
-        keyb = self._key_get(key_start,set=False)
-        if direction=="forward":
+            result = []
+        keyb = self._key_get(key_start, set=False)
+        if direction == "forward":
             CMD = "SCANX"
         else:
             CMD = "RSCAN"
 
-        nr=0
-        while nr<nrrecords:
+        nr = 0
+        while nr < nrrecords:
             try:
-                if keyb in [None,""]:
+                if keyb in [None, ""]:
                     keyb_new = self.redis.execute_command(CMD)[0]
                 else:
-                    keyb_new = self.redis.execute_command(CMD,keyb)[0]
+                    keyb_new = self.redis.execute_command(CMD, keyb)[0]
             except redis.ResponseError as e:
-                if e.args[0]=='No more data':
+                if e.args[0] == 'No more data':
                     return result
+                raise e
 
             if self.mode == "seq":
-                key_new = struct.unpack("<I",keyb_new)[0]
+                key_new = struct.unpack("<I", keyb_new)[0]
             else:
                 key_new = keyb_new
 
+            # if key return by scan is 0, we are done
+            if key_new == 0:
+                return
+
             if _keyonly:
-                result = method(key_new,result)
+                result = method(key_new, result)
             else:
                 data = self.redis.execute_command("GET", keyb_new)
-                result = method(key_new, data,result)
+                result = method(key_new, data, result)
 
             keyb = keyb_new
-            nr+=1
+            nr += 1
 
         return result
 
@@ -246,16 +264,16 @@ def test(self):
         assert id == 0
         assert self.get(id) == b"r"
 
-        id2= self.set(b"b")
+        id2 = self.set(b"b")
         assert id2 == 1
 
-        #NEED TO DO THIS WHEN DB SUPPORTS NOT TO UPDATE EXISTING VALUES
+        # NEED TO DO THIS WHEN DB SUPPORTS NOT TO UPDATE EXISTING VALUES
         # newid, exists = self.set(b"r", id=id, checknew=True)
         # assert exists is False
         # assert newid == id
 
         nr = self.nsinfo["entries"]
-        assert nr==2
+        assert nr == 2
 
         # self.set("test", 1)
         # print (self.nsinfo)
@@ -265,12 +283,10 @@ def test(self):
         assert self.list(1) == []
         assert self.list(0) == [1]
 
-
-
-        from IPython import embed;embed(colors='Linux')
+        from IPython import embed
+        embed(colors='Linux')
         ss
 
-
         print(res)
 
         result = {}
@@ -299,7 +315,7 @@ def dumpdata():
                     key = self.set(data, key=str(i))
                     inputs[key] = data
 
-            elif self.id_enable: #NO LONGER SUPPORTED
+            elif self.id_enable:  # NO LONGER SUPPORTED
                 inputs = {}
                 for i in range(4):
                     data = os.urandom(4096)
@@ -318,7 +334,7 @@ def dumpdata():
             if not exists:
                 break
 
-        print ("count:%s" % self.count)
+        print("count:%s" % self.count)
 
         self.nsname_new(nsname, secret="1234", maxsize=1000, instance=None)
 
@@ -345,7 +361,7 @@ def dumpdata():
         except Exception as e:
             assert "No space left" in str(e)
 
-        self.nsname_new(nsname+"2", secret="1234", instance=None)
+        self.nsname_new(nsname + "2", secret="1234", instance=None)
 
         nritems = 100000
         j.tools.timer.start("zdb")
diff --git a/JumpScale9RecordChain/data/bcdb/BCDBTable.py b/JumpScale9RecordChain/data/bcdb/BCDBTable.py
index f5a7bfe..6cce63d 100644
--- a/JumpScale9RecordChain/data/bcdb/BCDBTable.py
+++ b/JumpScale9RecordChain/data/bcdb/BCDBTable.py
@@ -6,10 +6,9 @@
 JSBASE = j.application.jsbase_get_class()
 
 
-
 class BCDBTable(JSBASE):
 
-    def __init__(self,bcdb,schema,name=""):
+    def __init__(self, bcdb, schema, name=""):
         """
         """
 
@@ -26,42 +25,42 @@ def __init__(self,bcdb,schema,name=""):
         else:
             raise RuntimeError("input needs to be schema in text or obj format")
 
-        if self.name=="":
+        if self.name == "":
             self.name = schema.name
             if not schema.name:
                 raise RuntimeError("schema name cannot be empty")
 
-        self.db =   self.bcdb.zdbclient.namespace_new(name=name, maxsize=0, die=False)
-        self.index = j.core.db  #only for now, will need better solution in future
+        self.db = self.bcdb.zdbclient.namespace_new(name=name, maxsize=0, die=False)
+        self.index = j.core.db  # only for now, will need better solution in future
 
         self.schema = schema
 
-        self._index_key = "index:%s:%s"%(self.bcdb.zdbclient.instance,self.name)
+        self._index_key = "index:%s:%s" % (self.bcdb.zdbclient.instance, self.name)
 
         self.index_load()
 
     def index_delete(self):
-        for key in self.index.keys(self._index_key+"*"):
+        for key in self.index.keys(self._index_key + "*"):
             self.index.delete(key)
 
     def index_load(self):
         """
         """
         self.index_delete()
-        self.logger.debug("build index for: %s"%self.name)
-        def iload(id,data,result):
+        self.logger.debug("build index for: %s" % self.name)
+
+        def iload(id, data, result):
             if data:
-                index,bdata = msgpack.unpackb(data)
-                self._index(index,id)
+                index, bdata = msgpack.unpackb(data)
+                self._index(index, id)
 
         self.db.iterate(iload)
         self.logger.debug("build index done")
 
-
     def destroy(self):
         raise RuntimeError("not implemented yet, need to go to db and remove namespace")
 
-    def set(self,data,id=None,hook=None):
+    def set(self, data, id=None, hook=None):
         """
         if string -> will consider to be json
         if binary -> will consider data for capnp
@@ -69,9 +68,9 @@ def set(self,data,id=None,hook=None):
         if ddict will put inside JSOBJ
 
         @RETURN JSOBJ
-        
+
         """
-        if  j.data.types.string.check(data):
+        if j.data.types.string.check(data):
             data = j.data.serializer.json.loads(data)
             obj = self.schema.get(data)
         elif j.data.types.bytes.check(data):
@@ -79,90 +78,85 @@ def set(self,data,id=None,hook=None):
         elif "_JSOBJ" in data.__dict__:
             obj = data
             if id is None and obj.id is not None:
-                id=obj.id
+                id = obj.id
         elif j.data.types.dict.check(data):
             obj = self.schema.get(data)
         else:
             raise RuntimeError("Cannot find data type, str,bin,obj or ddict is only supported")
         bdata = obj.data
 
-        #we store data in list
-        l=[]
-        index={}
+        # we store data in list
+        l = []
+        index = {}
         for item in self.schema.index_list:
-            r=eval("obj.%s"%item)
+            r = eval("obj.%s" % item)
             if r:
-                index[item]=r
+                index[item] = r
 
-        #later:
+        # later:
         acl = b""
         crc = b""
         signature = b""
 
-        l=[index,bdata]
+        l = [index, bdata]
         data = msgpack.packb(l)
 
         if hook:
-            obj = hook(obj,index)
+            obj = hook(obj, index)
 
-        
-        if id==None:
-            #means a new one
-            id = self.db.set(data)
-        else:
-            id2 = self.db.set(data,id=id)
+        id = self.db.set(data, key=id)
 
         obj.id = id
         obj.index = index
 
-        self._index(index,id)
-            
+        self._index(index, id)
+
         return obj
 
-    def _index(self,index,id):
-        
-        for key,item in index.items():
+    def _index(self, index, id):
+
+        for key, item in index.items():
             if j.data.types.bytes.check(key):
-                key=key.decode()
-            key2=self._index_key+":%s"%key
-            res = self.index.hget(key2,item)
-            if res==None:
-                res = struct.pack("<I",id)                
-                self.index.hset(key2,item,res)
+                key = key.decode()
+            key2 = self._index_key + ":%s" % key
+            res = self.index.hget(key2, item)
+            if res == None:
+                res = struct.pack("<I", id)
+                self.index.hset(key2, item, res)
             else:
-                res=self._index_get(res)
+                res = self._index_get(res)
                 if id not in res:
                     res.append(id)
                     res = msgpack.packb(res)
-                    self.index.hset(key2,item,res)
+                    self.index.hset(key2, item, res)
 
-    def _index_get(self,res):
-        if len(res)==4:
-            res =[struct.unpack("<I",res)[0]]
+    def _index_get(self, res):
+        if len(res) == 4:
+            res = [struct.unpack("<I", res)[0]]
         else:
-            res=msgpack.unpackb(res) #is already list
+            res = msgpack.unpackb(res)  # is already list
         return res
 
     def new(self):
         return self.schema.get()
 
-    def get(self,id,capnp=False,hook=None):
+    def get(self, id, capnp=False, hook=None):
         """
         @PARAM capnp if true will return data as capnp binary object, no hook will be done !
         @RETURN obj    (.index is in obj)
         """
 
-        if id==None:
+        if id == None:
             raise RuntimeError("id cannot be None")
 
         data = self.db.get(id)
 
-        if data==None:
+        if data == None:
             return None
-        
-        res  = msgpack.unpackb(data)
 
-        if len(res)==2:
+        res = msgpack.unpackb(data)
+
+        if len(res) == 2:
             index, bdata = res
         else:
             raise RuntimeError("not supported format in table yet")
@@ -177,22 +171,22 @@ def get(self,id,capnp=False,hook=None):
                 obj = hook(obj)
             return obj
 
-    def find(self,hook=None,**args):
-        res=[]
-        for key,val in args.items():
-            indexkey=self._index_key+":%s"%key
-            res2=[]
+    def find(self, hook=None, **args):
+        res = []
+        for key, val in args.items():
+            indexkey = self._index_key + ":%s" % key
+            res2 = []
 
             if val == '*' or val == b'*':
                 for item in self.index.hkeys(indexkey):
-                    id=self.index.hget(indexkey,item)
-                    id=struct.unpack("<I",id)[0]            
+                    id = self.index.hget(indexkey, item)
+                    id = struct.unpack("<I", id)[0]
                     if id not in res2:
                         res2.append(id)
             else:
-                id=self.index.hget(indexkey,val)
+                id = self.index.hget(indexkey, val)
                 if id is not None:
-                    id=struct.unpack("<I",id)[0]            
+                    id = struct.unpack("<I", id)[0]
                     if id not in res2:
                         res2.append(id)
             res.append(res2)
@@ -203,13 +197,13 @@ def find(self,hook=None,**args):
             return []
 
         res3 = reduce(set.intersection, res)
-        res4=[]
+        res4 = []
         for item in res3:
-            obj=self.get(item)
+            obj = self.get(item)
             if hook:
                 obj = hook(obj)
-            res4.append(obj)     
+            res4.append(obj)
         return res4
 
-
-
+    def delete(self, id):
+        self.db.delete(id)
diff --git a/JumpScale9RecordChain/data/schema/Schema.py b/JumpScale9RecordChain/data/schema/Schema.py
index 247a8b1..93214e6 100755
--- a/JumpScale9RecordChain/data/schema/Schema.py
+++ b/JumpScale9RecordChain/data/schema/Schema.py
@@ -7,6 +7,7 @@
 
 
 class Schema(JSBASE):
+
     def __init__(self, text=None, url=""):
         JSBASE.__init__(self)
         self.properties = []
@@ -22,7 +23,7 @@ def __init__(self, text=None, url=""):
             self.url = url
         else:
             self.url = ""
-            
+
         self.name = ""
         if text:
             self._schema_from_text(text)
@@ -79,7 +80,7 @@ def process(line):
             if "!" in line:
                 line, pointer_type = line.split("!", 1)
                 pointer_type = pointer_type.strip()
-                line=line.strip()
+                line = line.strip()
             else:
                 pointer_type = None
 
@@ -93,7 +94,7 @@ def process(line):
             if "(" in line:
                 line_proptype = line.split("(")[1].split(")")[0].strip().lower()
                 line_wo_proptype = line.split("(")[0].strip()
-                if line_proptype=="o": #special case where we have subject directly attached
+                if line_proptype == "o":  # special case where we have subject directly attached
                     js9type = j.data.types.get("jo")
                     js9type.SUBTYPE = pointer_type
                     defvalue = ""
@@ -109,8 +110,8 @@ def process(line):
             else:
                 alias = propname
 
-            if alias[-1]=="*":
-                alias=alias[:-1]
+            if alias[-1] == "*":
+                alias = alias[:-1]
 
             if propname in ["id"]:
                 raise RuntimeError("do not use 'id' in your schema, is reserved for system.")
@@ -141,8 +142,8 @@ def process(line):
             p = SchemaProperty()
 
             if propname.endswith("*"):
-                propname=propname[:-1]
-                p.index=True
+                propname = propname[:-1]
+                p.index = True
 
             p.name = propname
             p.default = defvalue
@@ -159,23 +160,22 @@ def process(line):
         for key, val in systemprops.items():
             self.__dict__[key] = val
 
-        nr=0
+        nr = 0
         for s in self.properties:
             s.nr = nr
             self.__dict__["property_%s" % s.name] = s
-            nr+=1
+            nr += 1
 
         for s in self.lists:
             s.nr = nr
             self.__dict__["property_%s" % s.name] = s
-            nr+=1
-
+            nr += 1
 
     @property
     def capnp_id(self):
-        if self.hash=="":
+        if self.hash == "":
             raise RuntimeError("hash cannot be empty")
-        return "f"+self.hash[1:16]  #first bit needs to be 1
+        return "f" + self.hash[1:16]  # first bit needs to be 1
 
     @property
     def code_template(self):
@@ -187,11 +187,11 @@ def code_template(self):
     def capnp_template(self):
         if self._capnp_template == None:
             self._capnp_template = j.data.schema.template_engine.get_template("schema.capnp")
-        return self._capnp_template        
+        return self._capnp_template
 
     @property
     def code(self):
-        #make sure the defaults render
+        # make sure the defaults render
         for prop in self.properties:
             prop.default_as_python_code
         for prop in self.lists:
@@ -207,40 +207,40 @@ def capnp_schema(self):
     @property
     def capnp(self):
         if not self._capnp:
-            self._capnp =  j.data.capnp3.getSchemaFromText(self.capnp_schema)
+            self._capnp = j.data.capnp3.getSchemaFromText(self.capnp_schema)
         return self._capnp
 
     @property
     def objclass(self):
         if self._obj_class is None:
-            url = self.url.replace(".","_")
+            url = self.url.replace(".", "_")
             path = j.sal.fs.joinPaths(j.data.schema.code_generation_dir, "%s.py" % url)
-            j.sal.fs.writeFile(path,self.code)
-            m=imp.load_source(name="url", pathname=path)
+            j.sal.fs.writeFile(path, self.code)
+            m = imp.load_source(name="url", pathname=path)
             self._obj_class = m.ModelOBJ
         return self._obj_class
 
-    def get(self,data={},capnpbin=None):
-        return self.objclass(schema=self,data=data,capnpbin=capnpbin)
+    def get(self, data={}, capnpbin=None):
+        return self.objclass(schema=self, data=data, capnpbin=capnpbin)
 
     def new(self):
         return self.get()
 
     @property
     def index_list(self):
-        if self._index_list==None:
+        if self._index_list == None:
             self._index_list = []
             for prop in self.properties:
                 if prop.index:
                     self._index_list.append(prop.alias)
-        return self._index_list                    
-            
+        return self._index_list
+
     def __str__(self):
-        out=""
+        out = ""
         for item in self.properties:
             out += str(item) + "\n"
         for item in self.lists:
             out += str(item) + "\n"
         return out
 
-    __repr__=__str__
+    __repr__ = __str__
diff --git a/JumpScale9RecordChain/data/schema/SchemaProperty.py b/JumpScale9RecordChain/data/schema/SchemaProperty.py
index dcc49ab..8294e97 100755
--- a/JumpScale9RecordChain/data/schema/SchemaProperty.py
+++ b/JumpScale9RecordChain/data/schema/SchemaProperty.py
@@ -5,6 +5,7 @@
 
 
 class SchemaProperty(JSBASE):
+
     def __init__(self):
         JSBASE.__init__(self)
         self.name = ""
@@ -15,11 +16,11 @@ def __init__(self):
         self.enumeration = []
         self.comment = ""
         self.pointer_type = None
-        self.nr=0
+        self.nr = 0
         self.index = False
 
         if self.name in ["schema"]:
-            raise RuntimeError("cannot have property name:%s"%self.name)
+            raise RuntimeError("cannot have property name:%s" % self.name)
 
     @property
     def default_as_python_code(self):
@@ -29,14 +30,13 @@ def default_as_python_code(self):
 
     @property
     def name_camel(self):
-        out=""
+        out = ""
         for item in self.name.split("_"):
             if out is "":
-                out=item.lower()
+                out = item.lower()
             else:
-                out+=item.capitalize()
+                out += item.capitalize()
         return out
-            
 
     @property
     def js9_typelocation(self):
@@ -44,19 +44,19 @@ def js9_typelocation(self):
 
     @property
     def capnp_schema(self):
-        return self.js9type.capnp_schema_get(self.name_camel,self.nr)
+        return self.js9type.capnp_schema_get(self.name_camel, self.nr)
 
     def __str__(self):
         if not self.js9type.NAME == "list":
-            out = "prop:%-25s (%s)"%(self.name,self.js9type.NAME)
+            out = "prop:%-25s (%s)" % (self.name, self.js9type.NAME)
         else:
-            out = "prop:%-25s (%s(%s))"%(self.name,self.js9type.NAME,self.js9type.SUBTYPE.NAME)
+            out = "prop:%-25s (%s(%s))" % (self.name, self.js9type.NAME, self.js9type.SUBTYPE.NAME)
 
-        if self.default not in [None,0,"",[]]:
-            out +="   default:%s"%self.default
+        if self.default not in [None, 0, "", []]:
+            out += "   default:%s" % self.default
 
         if self.pointer_type:
-            out+=" !%s"%self.pointer_type
+            out += " !%s" % self.pointer_type
         return out
-        
+
     __repr__ = __str__
diff --git a/JumpScale9RecordChain/servers/zdb/ZDBServer.py b/JumpScale9RecordChain/servers/zdb/ZDBServer.py
index 54bc9df..6917c9b 100644
--- a/JumpScale9RecordChain/servers/zdb/ZDBServer.py
+++ b/JumpScale9RecordChain/servers/zdb/ZDBServer.py
@@ -4,7 +4,7 @@
 import time
 
 TEMPLATE = """
-addr = "localhost"
+addr = "127.0.0.1"
 port = 9900
 path = ""
 mode = ""
@@ -22,12 +22,12 @@ def __init__(self, instance, data={}, parent=None, interactive=False):
         """
         JSConfigBase.__init__(self, instance=instance, data=data,
                               parent=parent, template=TEMPLATE, ui=None, interactive=interactive)
-        
+
         j.sal.fs.createDir(self.config.data["path"])
 
         self._initdir()
 
-    def client_get(self, secrets="",encryptionkey=""):
+    def client_get(self, secrets="", encryptionkey=""):
         return j.clients.zdb.configure(instance=self.instance,
                                        secrets=secrets,
                                        adminsecret=self.config.data['adminsecret_'],
@@ -52,9 +52,9 @@ def start(self):
 
         mode = self.config.data['mode']
 
-        d=self.config.data
-        if j.sal.nettools.tcpPortConnectionTest(d["addr"],d["port"]):
-            r=j.clients.redis.get(ipaddr=d["addr"], port=d["port"])
+        d = self.config.data
+        if j.sal.nettools.tcpPortConnectionTest(d["addr"], d["port"]):
+            r = j.clients.redis.get(ipaddr=d["addr"], port=d["port"])
             r.ping()
             return()