kvstore change empty to nil (#55)

* update keybase clients types to client at 5.4.0 release

* update for new kvstore empty as null

* in simplest kvstore example, explicitly use self-team

* handful of cleanuppy things

Author: xgess

examples/3_simple_storage.py

@@ -47,61 +47,69 @@ def noop_handler(*args, **kwargs):
 
     namespace = "current-favorites"
     key = "Sam"
+    teamName = f"{bot.username},{bot.username}"
 
     # using the default team, which is yourself (your implicit self-team
     # "yourusername,yourusername")
 
+    # get a non-existent entry
+    res = await bot.kvstore.get(namespace, key, team=teamName)
+    print("GET NON-EXISTENT: ", res)
+    assert res.entry_value is None
+
     # put with default revision
-    # note: if revision=None, the server does a get (to get
+    # note: if revision=None, the service does a get (to get
     # the latest revision number) then a put (with revision
     # number + 1); this operation is not atomic.
     value = "The Left Hand of Darkness"
-    res = await bot.kvstore.put(namespace, key, value, revision=None)
+    res = await bot.kvstore.put(namespace, key, value, revision=None, team=teamName)
     print("PUT: ", res)
     rev = res.revision
 
     # fail put
     try:
-        res = await bot.kvstore.put(namespace, key, "Fahrenheit 451", revision=rev)
+        res = await bot.kvstore.put(
+            namespace, key, "Fahrenheit 451", revision=rev, team=teamName
+        )
     except RevisionError as e:
         print("EXPECTING PUT FAIL: ", e)
 
     # list namespaces
-    res = await bot.kvstore.list_namespaces()
+    res = await bot.kvstore.list_namespaces(team=teamName)
     print("LIST NAMESPACES: ", res)
     assert len(res.namespaces) > 0
 
     # list entryKeys
-    res = await bot.kvstore.list_entrykeys(namespace)
+    res = await bot.kvstore.list_entrykeys(namespace, team=teamName)
     print("LIST ENTRYKEYS: ", res)
     assert len(res.entry_keys) > 0
 
     # get
-    res = await bot.kvstore.get(namespace, key)
+    res = await bot.kvstore.get(namespace, key, team=teamName)
     print("GET: ", res)
     assert res.entry_value == value
 
     # fail delete
     try:
-        res = await bot.kvstore.delete(namespace, key, revision=rev + 2)
+        res = await bot.kvstore.delete(namespace, key, revision=rev + 2, team=teamName)
     except RevisionError as e:
         print("EXPECTING DELETE FAIL: ", e)
 
     # delete
-    res = await bot.kvstore.delete(namespace, key, revision=rev + 1)
+    res = await bot.kvstore.delete(namespace, key, revision=rev + 1, team=teamName)
     print("DELETE: ", res)
     assert res.revision == rev + 1
 
     # fail delete
     try:
-        res = await bot.kvstore.delete(namespace, key, revision=rev + 2)
+        res = await bot.kvstore.delete(namespace, key, revision=rev + 2, team=teamName)
     except DeleteNonExistentError as e:
         print("EXPECTING DELETE FAIL: ", e)
 
     # get
-    res = await bot.kvstore.get(namespace, key)
+    res = await bot.kvstore.get(namespace, key, team=teamName)
     print("GET: ", res)
-    assert res.entry_value == ""
+    assert res.entry_value is None
 
 
 async def main():

examples/4_totp_storage.py

@@ -87,7 +87,7 @@ def to_json(self, secret):
 
     async def add(self, bot, team, issuer, secret):
         val = json.dumps(self.to_json(secret))
-        await bot.kvstore.put(self.NAMESPACE, issuer, val, team)
+        await bot.kvstore.put(self.NAMESPACE, issuer, val, team=team)
 
     async def remove(self, bot, team, issuer):
         # throws exception if nothing to delete

examples/5_secret_storage.py

@@ -18,6 +18,8 @@
 #
 # Here we've stored the HMAC secret and other entries in the team's kvstore;
 # you could also store the entries in the bot's own kvstore (the default team).
+#
+# TODO: this is currently not working exactly right. sorry.
 # ###################################
 
 import asyncio
@@ -69,15 +71,15 @@ def __init__(self, client):
 
     async def put(
         self,
-        team: str,
         namespace: str,
         entry_key: str,
         entry_value: Dict[str, str],
+        team: str,
         revision: Union[int, None] = None,
     ) -> Union[keybase1.KVPutResult, keybase1.KVGetResult]:
         try:
             res: keybase1.KVPutResult = await self.kvstore.put(
-                team, namespace, entry_key, entry_value, revision
+                namespace, entry_key, entry_value, team=team, revision=revision
             )
             return res  # successful put. return KVPutResult
         except RevisionError:
@@ -86,14 +88,14 @@ async def put(
 
     async def delete(
         self,
-        team: str,
         namespace: str,
         entry_key: str,
+        team: str,
         revision: Union[int, None] = None,
     ) -> Union[keybase1.KVDeleteEntryResult, keybase1.KVGetResult]:
         try:
             res: keybase1.KVDeleteEntryResult = await self.kvstore.delete(
-                team, namespace, entry_key, revision
+                namespace=namespace, entry_key=entry_key, revision=revision, team=team
             )
             return res  # successful delete. return KVDeleteEntryResult
         except (RevisionError, DeleteNonExistentError):
@@ -102,15 +104,15 @@ async def delete(
         return res
 
     async def get(
-        self, team: str, namespace: str, entry_key: str
+        self, namespace: str, entry_key: str, team: str
     ) -> keybase1.KVGetResult:
-        res = await self.kvstore.get(team, namespace, entry_key)
+        res = await self.kvstore.get(namespace, entry_key, team)
         return res
 
     async def list_entrykeys(
-        self, team: str, namespace: str
+        self, namespace: str, team: str
     ) -> keybase1.KVListEntryResult:
-        res = await self.kvstore.list_entrykeys(team, namespace)
+        res = await self.kvstore.list_entrykeys(namespace, team)
         return res
 
 
@@ -155,11 +157,15 @@ async def load_secret(self, team, namespace) -> bytes:
             try:
                 # we don't expect self.SECRET_KEY's revision > 0
                 await self.kvstore.put(
-                    namespace, self.SECRET_KEY, bytes_to_str(secret), 1, team
+                    namespace,
+                    self.SECRET_KEY,
+                    bytes_to_str(secret),
+                    revision=1,
+                    team=team,
                 )
             except RevisionError:
                 res: keybase1.KVGetResult = await self.kvstore.get(
-                    team, namespace, self.SECRET_KEY
+                    namespace, self.SECRET_KEY, team=team
                 )
                 secret = str_to_bytes(res.entry_value)
             if team not in self.secrets:
@@ -182,7 +188,7 @@ async def put(
         entry_value[SecretKeyKVStoreClient.KEY_KEY] = entry_key
         h = await self.hmac_key(team, namespace, entry_key)
         res = await self.kvstore.put(
-            namespace, h, json.dumps(entry_value), revision, team
+            namespace, h, json.dumps(entry_value), revision=revision, team=team
         )
         res.entry_key = entry_key
         return res
@@ -195,28 +201,28 @@ async def delete(
         revision: Union[int, None] = None,
     ) -> keybase1.KVDeleteEntryResult:
         h = await self.hmac_key(team, namespace, entry_key)
-        res = await self.kvstore.delete(namespace, h, revision, team)
+        res = await self.kvstore.delete(namespace, h, revision=revision, team=team)
         res.entry_key = entry_key
         return res
 
     async def get(
         self, team: str, namespace: str, entry_key: str
     ) -> keybase1.KVGetResult:
         h = await self.hmac_key(team, namespace, entry_key)
-        res = await self.kvstore.get(namespace, h, team)
+        res = await self.kvstore.get(namespace, h, team=team)
         res.entry_key = entry_key
         return res
 
     async def list_entrykeys(
         self, team: str, namespace: str
     ) -> keybase1.KVListEntryResult:
-        res = await self.kvstore.list_entrykeys(namespace, team)
+        res = await self.kvstore.list_entrykeys(namespace, team=team)
         if res.entry_keys:
             res.entry_keys = [
                 e for e in res.entry_keys if not e.entry_key.startswith("_")
             ]
             for e in res.entry_keys:
-                get_res = await self.kvstore.get(namespace, e.entry_key, team)
+                get_res = await self.kvstore.get(namespace, e.entry_key, team=team)
                 e.entry_key = json.loads(get_res.entry_value)[self.KEY_KEY]
         return res
 
@@ -242,7 +248,7 @@ async def add(self, team, tool) -> Tuple[bool, Union[keybase1.KVGetResult, None]
                 most recent get result if applicable)
         """
         res = await self.lookup(team, tool)
-        if res.entry_value != "":
+        if res.entry_value is not None:
             return (True, res)  # if tool already exists, return get
         expected_revision = res.revision + 1
         res = await self.kvstore.put(team, self.NAMESPACE, tool, {}, expected_revision)
@@ -260,10 +266,15 @@ async def remove(
                 most recent get result if applicable)
         """
         res = await self.lookup(team, tool)
-        if res.entry_value == "":
+        if res.entry_value is None:
             return (True, res)  # if tool already doesn't exist, return get
         expected_revision = res.revision + 1
-        res = await self.kvstore.delete(team, self.NAMESPACE, tool, expected_revision)
+        res = await self.kvstore.delete(
+            namespace=self.NAMESPACE,
+            entry_key=tool,
+            revision=expected_revision,
+            team=team,
+        )
         if type(res) == keybase1.KVGetResult:
             return (False, res)
         else:
@@ -281,14 +292,14 @@ async def reserve(
                 most recent get result if applicable)
         """
         res = await self.lookup(team, tool)
-        info = json.loads(res.entry_value) if res.entry_value != "" else {}
+        info = json.loads(res.entry_value) if res.entry_value is not None else {}
         if day in info:
             return (False, res)  # failed to put because day is already reserved.
         else:
             info[day] = user
         expected_revision = res.revision + 1
         res = await self.kvstore.put(
-            team, self.NAMESPACE, tool, info, expected_revision
+            self.NAMESPACE, tool, info, revision=expected_revision, team=team
         )
         if type(res) == keybase1.KVGetResult:
             return (False, res)
@@ -308,7 +319,7 @@ async def unreserve(
                 most recent get result if applicable)
         """
         res = await self.lookup(team, tool)
-        info = json.loads(res.entry_value) if res.entry_value != "" else {}
+        info = json.loads(res.entry_value) if res.entry_value is not None else {}
         if day not in info:
             # a noop because currently not reserved
             return (True, res)
@@ -319,20 +330,20 @@ async def unreserve(
         info.pop(day)
         expected_revision = res.revision + 1
         res = await self.kvstore.put(
-            team, self.NAMESPACE, tool, info, expected_revision
+            self.NAMESPACE, tool, info, revision=expected_revision, team=team
         )
         if type(res) == keybase1.KVGetResult:
             return (False, res)
         else:
             return (True, None)
 
     async def list_tools(self, team) -> List[str]:
-        res = await self.kvstore.list_entrykeys(team, self.NAMESPACE)
+        res = await self.kvstore.list_entrykeys(self.NAMESPACE, team=team)
         keys = [e.entry_key for e in res.entry_keys] if res.entry_keys else []
         return keys
 
 
-async def basic_rental_users(bot, rental, team):
+async def basic_rental_users(rental, team):
     user1 = "Jo"
     user2 = "Charlie"
     date1 = "2044-03-12"
@@ -397,7 +408,7 @@ async def basic_rental_users(bot, rental, team):
     assert SecretKeyKVStoreClient.KEY_KEY in info
 
 
-async def concurrent_rental_users(bot, rental, team):
+async def concurrent_rental_users(rental, team):
     tool = "time travel machine"
 
     async def concurrent_rental_user(user_id: int):
@@ -451,10 +462,10 @@ def noop_handler(*args, **kwargs):
     rental = RentalBotClient(bot)
 
     print("...basic rental actions...")
-    await basic_rental_users(bot, rental, team)
+    await basic_rental_users(rental, team)
 
     print("...multiple users try to reserve...")
-    await concurrent_rental_users(bot, rental, team)
+    await concurrent_rental_users(rental, team)
 
     print("...5_secret_storage example is complete.")
 

pykeybasebot/kvstore_client.py

@@ -98,10 +98,12 @@ async def list_entrykeys(
         return keybase1.KVListEntryResult.from_dict(res)
 
     def is_deleted(self, res: keybase1.KVGetResult) -> bool:
-        return res.revision > 0 and res.entry_value == ""
+        return res.revision > 0 and (res.entry_value is None or res.entry_value == "")
 
     def is_present(self, res: keybase1.KVGetResult) -> bool:
-        return res.revision > 0 and res.entry_value != ""
+        return (
+            res.revision > 0 and res.entry_value is not None and res.entry_value != ""
+        )
 
     async def execute(self, command):
         resp = await self.bot.submit("kvstore api", json.dumps(command).encode("utf-8"))