Cleaned up a bit.

Author: rohe

src/cryptojwt/key_bundle.py

@@ -189,22 +189,22 @@ def __init__(
         """
 
         self._keys = []
-        self.remote = False
-        self.local = False
         self.cache_time = cache_time
-        self.ignore_errors_period = ignore_errors_period
-        self.ignore_errors_until = None  # UNIX timestamp of last error
-        self.time_out = 0
         self.etag = ""
-        self.source = None
         self.fileformat = fileformat.lower()
+        self.ignore_errors_period = ignore_errors_period
+        self.ignore_errors_until = None  # UNIX timestamp of last error
+        self.ignore_invalid_keys = ignore_invalid_keys
+        self.imp_jwks = None
         self.keytype = keytype
         self.keyusage = keyusage
-        self.imp_jwks = None
-        self.last_updated = 0
-        self.last_remote = None  # HTTP Date of last remote update
         self.last_local = None  # UNIX timestamp of last local update
-        self.ignore_invalid_keys = ignore_invalid_keys
+        self.last_remote = None  # HTTP Date of last remote update
+        self.last_updated = 0
+        self.local = False
+        self.remote = False
+        self.source = None
+        self.time_out = 0
 
         if httpc:
             self.httpc = httpc
@@ -761,16 +761,22 @@ def dump(self, cutoff: Optional[list] = None):
 
         res = {
             "keys": _keys,
+            "cache_time": self.cache_time,
+            "etag": self.etag,
             "fileformat": self.fileformat,
-            "last_updated": self.last_updated,
-            "last_remote": self.last_remote,
-            "last_local": self.last_local,
             "httpc_params": self.httpc_params,
-            "remote": self.remote,
-            "local": self.local,
+            "ignore_errors_period": self.ignore_errors_period,
+            "ignore_errors_until": self.ignore_errors_until,
+            "ignore_invalid_keys": self.ignore_invalid_keys,
             "imp_jwks": self.imp_jwks,
+            "keytype": self.keytype,
+            "keyusage": self.keyusage,
+            "last_local": self.last_local,
+            "last_remote": self.last_remote,
+            "last_updated": self.last_updated,
+            "local": self.local,
+            "remote": self.remote,
             "time_out": self.time_out,
-            "cache_time": self.cache_time,
         }
 
         if self.source:
@@ -782,17 +788,45 @@ def load(self, spec):
         _keys = spec.get("keys", [])
         if _keys:
             self.do_keys(_keys)
-        self.source = spec.get("source", None)
+        self.cache_time = spec.get("cache_time", 0)
+        self.etag = spec.get("etag", "")
         self.fileformat = spec.get("fileformat", "jwks")
-        self.last_updated = spec.get("last_updated", 0)
-        self.last_remote = spec.get("last_remote", None)
+        self.httpc_params = spec.get("httpc_params", {})
+        self.ignore_errors_period = spec.get("ignore_errors_period", 0)
+        self.ignore_errors_until = spec.get("ignore_errors_until", None)
+        self.ignore_invalid_keys = spec.get("ignore_invalid_keys", True)
+        self.imp_jwks = spec.get("imp_jwks", None)
+        self.keytype = (spec.get("keytype", "RSA"),)
+        self.keyusage = (spec.get("keyusage", None),)
         self.last_local = spec.get("last_local", None)
-        self.remote = spec.get("remote", False)
+        self.last_remote = spec.get("last_remote", None)
+        self.last_updated = spec.get("last_updated", 0)
         self.local = spec.get("local", False)
-        self.imp_jwks = spec.get("imp_jwks", None)
+        self.remote = spec.get("remote", False)
+        self.source = spec.get("source", None)
         self.time_out = spec.get("time_out", 0)
-        self.cache_time = spec.get("cache_time", 0)
-        self.httpc_params = spec.get("httpc_params", {})
+        return self
+
+    def flush(self):
+        self._keys = []
+        self.cache_time = (300,)
+        self.etag = ""
+        self.fileformat = "jwks"
+        # self.httpc=None,
+        self.httpc_params = (None,)
+        self.ignore_errors_period = 0
+        self.ignore_errors_until = None
+        self.ignore_invalid_keys = True
+        self.imp_jwks = None
+        self.keytype = ("RSA",)
+        self.keyusage = (None,)
+        self.last_local = None  # UNIX timestamp of last local update
+        self.last_remote = None  # HTTP Date of last remote update
+        self.last_updated = 0
+        self.local = False
+        self.remote = False
+        self.source = None
+        self.time_out = 0
         return self
 
 

src/cryptojwt/key_issuer.py

@@ -378,7 +378,7 @@ def dump(self, exclude=None, cutoff: Optional[list] = None) -> dict:
     def load(self, info):
         """
 
-        :param items: A list with the information
+        :param items: A dictionary with the information to load
         :return:
         """
         self.name = info["name"]
@@ -390,6 +390,18 @@ def load(self, info):
         self._bundles = [KeyBundle().load(val) for val in info["bundles"]]
         return self
 
+    def flush(self):
+        self.ca_certs = (None,)
+        self.keybundle_cls = (KeyBundle,)
+        self.remove_after = (3600,)
+        self.httpc = (None,)
+        self.httpc_params = (None,)
+        self.name = ""
+        self.spec2key = None
+        self.remove_after = 0
+        self._bundles = []
+        return self
+
     def update(self):
         for kb in self._bundles:
             kb.update()

src/cryptojwt/key_jar.py

@@ -636,11 +636,11 @@ def dump(self, exclude: Optional[bool] = None, cutoff: Optional[list] = None) ->
         """
 
         info = {
-            "spec2key": self.spec2key,
             "ca_certs": self.ca_certs,
+            "httpc_params": self.httpc_params,
             "keybundle_cls": qualified_name(self.keybundle_cls),
             "remove_after": self.remove_after,
-            "httpc_params": self.httpc_params,
+            "spec2key": self.spec2key,
         }
 
         _issuers = {}
@@ -668,19 +668,34 @@ def load(self, info):
         :param info: A dictionary with the information
         :return:
         """
-        self.spec2key = info["spec2key"]
-        self.ca_certs = info["ca_certs"]
-        self.keybundle_cls = importer(info["keybundle_cls"])
-        self.remove_after = info["remove_after"]
-        self.httpc_params = info["httpc_params"]
+        self.ca_certs = info.get("ca_certs", None)
+        self.httpc_params = info.get("httpc_params", None)
+        self.keybundle_cls = importer(info.get("keybundle_cls", KeyBundle))
+        self.remove_after = info.get("remove_after", 3600)
+        self.spec2key = info.get("spec2key", {})
 
-        for _issuer_id, _issuer_desc in info["issuers"].items():
-            self._issuers[_issuer_id] = KeyIssuer().load(_issuer_desc)
+        _issuers = info.get("issuers", None)
+        if _issuers is None:
+            self._issuers = {}
+        else:
+            for _issuer_id, _issuer_desc in _issuers.items():
+                self._issuers[_issuer_id] = KeyIssuer().load(_issuer_desc)
         return self
 
     def loads(self, string):
         return self.load(json.loads(string))
 
+    def flush(self):
+        self.ca_certs = None
+        self.httpc_params = None
+        self._issuers = {}
+        self.keybundle_cls = KeyBundle
+        self.remove_after = 3600
+        self.spec2key = {}
+        # self.httpc=None,
+
+        return self
+
     @deprecated_alias(issuer="issuer_id", owner="issuer_id")
     def key_summary(self, issuer_id):
         _issuer = self._get_issuer(issuer_id)

tests/test_03_key_bundle.py

@@ -953,10 +953,16 @@ def test_export_inactive():
     res = kb.dump()
     assert set(res.keys()) == {
         "cache_time",
+        "etag",
         "fileformat",
         "httpc_params",
+        "ignore_errors_until",
+        "ignore_errors_period",
+        "ignore_invalid_keys",
         "imp_jwks",
         "keys",
+        "keytype",
+        "keyusage",
         "last_updated",
         "last_remote",
         "last_local",