refactured pypesa

Author: Kalebu

pypesa/__init__.py

@@ -29,7 +29,7 @@ class Mpesa(object):
     def __init__(
         self,
         auth_path: Optional[str] = "keys.json",
-        environment: Optional[str] = "testing",
+        environment: Optional[str] = "sandbox",
     ):
         """
         Mpesa API client for Python
@@ -44,14 +44,24 @@ def __init__(
 
     @property
     def authenticate(self) -> bool:
-        """"""
+        """
+            Property to check If the user is has has included auth keys
+            either manually or through auth json file(keys.json)
+
+            >> import pypesa
+            >> mpesa = pypesa()
+            >> mpesa.authenticate
+
+            Return True if the environment has auth keys
+                   False if auth are not included
+        """
 
         if self.auth_keys.get("public_key") and self.auth_keys.get("api_key"):
             self._encrypted_api_key = self.__generate_encrypted_key()
             return True
 
         elif os.path.isfile(self.auth_path):
-            print("loading from file")
+            # print("loading from file")
             self.auth_keys = self.load_keys(self.auth_path)
             if self.auth_keys:
                 self._encrypted_api_key = self.__generate_encrypted_key()
@@ -72,7 +82,17 @@ def authorized_method(self, *args, **kwargs):
 
     @staticmethod
     def load_keys(keys_filename: Union[str, Path]) -> dict:
-        """"""
+        """
+            Pypesa internal method to load the auth file 
+
+                >> import pypesa
+                >> mpesa = pypesa()
+                >> pypesa.load_keys()
+
+            Return keys Dict if auth file is present 
+
+            Raise FileNotFoundError if auth file is absent
+        """
         try:
 
             with open(keys_filename, "r") as auth:
@@ -88,7 +108,11 @@ def load_keys(keys_filename: Union[str, Path]) -> dict:
             raise LoadingKeyError
 
     def __generate_encrypted_key(self, session: Optional[bool] = False) -> str:
-        """"""
+        """
+
+            Method use to Encrypt the api key and public key 
+            so as to get a secure RSA Encrypted key
+        """
         try:
             pub_key = self.auth_keys.get("public_key")
             raw_key = self.auth_keys.get("api_key")
@@ -100,7 +124,6 @@ def __generate_encrypted_key(self, session: Optional[bool] = False) -> str:
             rsa_public_key = RSA.importKey(public_key_string)
             raw_cipher = rsa_cipher.new(rsa_public_key)
             encrypted_key = raw_cipher.encrypt(raw_key.encode())
-
             return base64.b64encode(encrypted_key).decode("utf-8")
 
         except Exception as bug:
@@ -111,10 +134,16 @@ def __generate_encrypted_key(self, session: Optional[bool] = False) -> str:
 
     @property
     def path_to_auth(self) -> str:
+        """
+            Return Path to Authentication file
+        """
         return self.auth_path
 
     @path_to_auth.setter
     def path_to_auth(self, auth_path: Union[str, Path]) -> str:
+        """
+            Setting new path to the authentication file
+        """
         if isinstance(auth_path, str):
             self.auth_path = auth_path
             return self.auth_path
@@ -124,20 +153,37 @@ def path_to_auth(self, auth_path: Union[str, Path]) -> str:
 
     @property
     def environment(self) -> Union[sandbox, production]:
+        """
+            Return the Environment the Pypesa is running 
+
+            whether its Sandbox | Production 
+        """
         return self.urls
 
     @environment.setter
     def environment(self, enviro: str) -> Union[sandbox, production]:
+        """
+            Set new pypesa environment 
+
+            Eg. changing env to production; 
+
+            >> import pypesa
+            >> mpesa = pypesa()
+            >> mpesa.environment = "production"
+            <Using Production Urls>
+        """
         if isinstance(enviro, str):
-            if enviro in ["testing", "production"]:
-                if enviro == "testing":
+            if enviro in ["sandbox", "production"]:
+                if enviro == "sandbox":
                     self.urls = sandbox()
                 else:
                     self.urls = production()
                 print(self.urls)
                 return self.urls
-            return ValueError("Environment must be either testing or production")
-        return TypeError(f"environment must be of type string not {type(enviro)}")
+            raise ValueError(
+                "Environment must be either sandbox or production")
+        raise TypeError(
+            f"environment must be of type string not {type(enviro)}")
 
     @property
     def api_key(self) -> str:
@@ -164,21 +210,33 @@ def api_key(self, Api_key: str) -> str:
 
     @property
     def public_key(self) -> str:
+        """
+            Return the current Public key
+        """
         return self.auth_keys.get("public_key")
 
     @public_key.setter
     def public_key(self, pb_key: str) -> str:
+        """
+            Set a new public key 
+        """
         if isinstance(pb_key, str):
             self.auth_keys["public_key"] = pb_key
             return self.auth_keys["public_key"]
         raise TypeError(f"Public key must be a string not a {type(pb_key)}")
 
     @property
     def origin_address(self) -> str:
+        """
+            Return the current origin address
+        """
         return self._origin_ip
 
     @origin_address.setter
     def origin_address(self, ip_address: str) -> str:
+        """
+            Set a new origin address 
+        """
         if isinstance(ip_address, str):
             self._origin_ip = ip_address
             return self._origin_ip
@@ -187,6 +245,10 @@ def origin_address(self, ip_address: str) -> str:
 
     @authenticated
     def default_headers(self, auth_key: Optional[str] = "") -> dict:
+        """
+            Generate Default header to be used during a Request
+
+        """
         if not auth_key:
             auth_key = self.__generate_encrypted_key(session=True)
         return {
@@ -205,9 +267,9 @@ def get_session_id(self) -> str:
             session_id = response["output_SessionID"]
             response_code = response["output_ResponseCode"]
             description = response["output_ResponseDesc"]
-            print(description, " ", response_code)
+            # print(description, " ", response_code)
             if response_code == "INS-989":
-                print("Session creation failed!!")
+                # print("Session creation failed!!")
                 raise AuthenticationError
             return session_id
         except Exception as bug:

pypesa/service_urls.py

@@ -73,11 +73,12 @@ class Required(object):
 
 
 class sandbox(Required):
-    def __init__(self):
-        """
-        Service URL to be used during sandbox Development
+    """
+    Service URL to be used during sandbox Development
+
+    """
 
-        """
+    def __init__(self):
         self.session_id = (
             "https://openapi.m-pesa.com/sandbox/ipg/v2/vodacomTZN/getSession/"
         )
@@ -105,12 +106,13 @@ def __str__(self) -> str:
 
 
 class production(Required):
-    def __init__(self):
-        """
+    """
+
+    Service URL to be used for Production Development
 
-        Service URL to be used for Production Development
+    """
 
-        """
+    def __init__(self):
         self.session_id = (
             "https://openapi.m-pesa.com/openapi/ipg/v2/vodacomTZN/getSession/"
         )