Cleanup

* Python 3 compatibility
* Docstrings
* Base64 functions

Author: robbiet480

python/py_vapid/__init__.py

@@ -10,8 +10,8 @@
 import logging
 from jose import jws
 
-
 class VapidException(Exception):
+    """An exception wrapper for Vapid."""
     pass
 
 
@@ -24,12 +24,14 @@ class Vapid(object):
     def __init__(self, private_key_file=None, private_key=None):
         """Initialize VAPID using an optional file containing a private key
         in PEM format.
-
         :param private_key_file: The name of the file containing the
         private key
         """
         if private_key_file:
-            private_key = open(private_key_file).read()
+            if not os.path.isfile(private_key_file):
+                self.save_key(private_key_file)
+                return
+            private_key = open(private_key_file, 'r').read()
         if private_key:
             try:
                 if "BEGIN EC" in private_key:
@@ -38,47 +40,59 @@ def __init__(self, private_key_file=None, private_key=None):
                     self._private_key = \
                         ecdsa.SigningKey.from_der(
                             base64.urlsafe_b64decode(private_key))
-            except Exception, exc:
+            except Exception as exc:
                 logging.error("Could not open private key file: %s", repr(exc))
                 raise VapidException(exc)
-            self._pubilcKey = self._private_key.get_verifying_key()
+            self._public_key = self._private_key.get_verifying_key()
 
     @property
     def private_key(self):
+        """Return the private key."""
         if not self._private_key:
             raise VapidException(
                 "No private key defined. Please import or generate a key.")
         return self._private_key
 
     @private_key.setter
     def private_key(self, value):
+        """Set the private key."""
         self._private_key = value
 
     @property
     def public_key(self):
+        """Return the public key."""
         if not self._public_key:
             self._public_key = self.private_key.get_verifying_key()
         return self._public_key
 
+    @property
+    def private_key_base64(self):
+        """Return the base64'ed private key."""
+        return base64.urlsafe_b64encode(self.private_key.to_string())
+
+    @property
+    def public_key_base64(self):
+        """Return the base64'ed public key."""
+        return base64.urlsafe_b64encode(self.public_key.to_string())
+
     def generate_keys(self):
         """Generate a valid ECDSA Key Pair."""
         self.private_key = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p)
         self.public_key
 
     def save_key(self, key_file):
         """Save the private key to a PEM file."""
-        file = open(key_file, "w")
+        file = open(key_file, "wb")
         if not self._private_key:
             self.generate_keys()
         file.write(self._private_key.to_pem())
         file.close()
 
     def save_public_key(self, key_file):
         """Save the public key to a PEM file.
-
         :param key_file: The name of the file to save the public key
         """
-        with open(key_file, "w") as file:
+        with open(key_file, "wb") as file:
             file.write(self.public_key.to_pem())
             file.close()
 
@@ -88,20 +102,21 @@ def validate(self, token):
         token = base64.urlsafe_b64encode(sig)
         return token
 
-    def verifyToken(self, sig, token):
+    def verify_token(self, sig, token):
+        """Verify the signature against the token."""
         hsig = base64.urlsafe_b64decode(sig)
         return self.public_key.verify(hsig, token,
                                       hashfunc=self._hasher)
 
     def sign(self, claims, crypto_key=None):
         """Sign a set of claims.
-
         :param claims: JSON object containing the JWT claims to use.
         :param crypto_key: Optional existing crypto_key header content. The
             vapid public key will be appended to this data.
         :returns result: a hash containing the header fields to use in
             the subscription update.
         """
+        from jose import jws
         if not claims.get('exp'):
             claims['exp'] = int(time.time()) + 86400
         if not claims.get('sub'):