Minor modifications on functions and vars names

Author: ddalu5

pyntegrity/core.py

@@ -23,36 +23,38 @@
 from .config import SUPPORTED_HASH_ALGOS
 
 
-def detect_hash_algo(hash_str: str):
+def detect_hash_algo(checksum_str: str):
     """
     Detects hash algorithm based on its length.
 
-    :param hash_str: the hash string
+    :param checksum_str: the hash string
     :return: the name of the hash algorithm
     :raises HashAlgorithmNotSupportedException: raised if the hash
         length isn't valid for any supported algorithm
     """
-    hash_len = len(hash_str)
+    hash_len = len(checksum_str)
     for name, infos in SUPPORTED_HASH_ALGOS.items():
         if infos["LENGTH"] == hash_len:
             return name
     else:
         raise HashAlgorithmNotSupportedException(
-            detected_length=hash_len, hash_str=hash_str
+            detected_length=hash_len, checksum_str=checksum_str
         )
 
 
-def validate_hash_str(hash_str: str):
+def validate_checksum_str(checksum_str: str):
     """
     Checks if the str is a valid checksum in the detected algorithm
 
-    :param hash_str:the hash string
+    :param checksum_str:the hash string
     :return: True if valid
     :raises HashStrNotValidException: raised if the hash str isn't valid
     """
-    hash_name = detect_hash_algo(hash_str)
+    hash_name = detect_hash_algo(checksum_str)
     pattern = re.compile(SUPPORTED_HASH_ALGOS[hash_name]["REX"])
-    if pattern.match(hash_str):
+    if pattern.match(checksum_str):
         return True
     else:
-        raise HashStrNotValidException(detected_hash_algo=hash_name, hash_str=hash_str)
+        raise HashStrNotValidException(
+            detected_hash_algo=hash_name, checksum_str=checksum_str
+        )

pyntegrity/exceptions.py

@@ -19,16 +19,16 @@
 
 
 class HashAlgorithmNotSupportedException(Exception):
-    def __init__(self, detected_length: int, hash_str: str):
+    def __init__(self, detected_length: int, checksum_str: str):
         """
         Exception raised when the hash length does not match
         any supported Hash algorithm;
 
         :param detected_length: the length of the checked hash string
-        :param hash_str: the hash string
+        :param checksum_str: the hash string
         """
         self.detected_length = detected_length
-        self.hash_str = hash_str
+        self.checksum_str = checksum_str
         self.message = (
             "[!] The hash string length does not "
             "match any supported hash algorithm: ["
@@ -42,16 +42,16 @@ def __init__(self, detected_length: int, hash_str: str):
 
 
 class HashStrNotValidException(Exception):
-    def __init__(self, detected_hash_algo: str, hash_str: str):
+    def __init__(self, detected_hash_algo: str, checksum_str: str):
         """
         Exception raised when hash string isn't valid
         for the detected hash algorithm;
 
         :param detected_hash_algo: the name of the detected algo
-        :param hash_str: the hash string
+        :param checksum_str: the hash string
         """
         self.detected_hash_algo = detected_hash_algo
-        self.hash_str = hash_str
+        self.checksum_str = checksum_str
         self.message = (
             f"[!] The hash string doesn't "
             f'seem valid for the detected algorithm"{detected_hash_algo}"'

tests/test_core.py

@@ -1,7 +1,7 @@
 from unittest import TestCase
 
 from pyntegrity.core import detect_hash_algo
-from pyntegrity.core import validate_hash_str
+from pyntegrity.core import validate_checksum_str
 
 from pyntegrity.exceptions import HashStrNotValidException
 from pyntegrity.exceptions import HashAlgorithmNotSupportedException
@@ -17,30 +17,30 @@ def test_detect_hash_algo_ok(self):
         self.assertEqual(hash_name, "sha256")
 
     def test_detect_hash_algo_nok(self):
-        invalid_hash_str = "6545ed"
+        invalid_checksum_str = "6545ed"
         with self.assertRaises(HashAlgorithmNotSupportedException):
-            detect_hash_algo(invalid_hash_str)
+            detect_hash_algo(invalid_checksum_str)
 
 
 class TestValidateHashStr(TestCase):
-    def test_validate_hash_str_md5_ok(self):
+    def test_validate_checksum_str_md5_ok(self):
         valid_md5 = "098f6bcd4621d373cade4e832627b4f6"
-        self.assertTrue(validate_hash_str(valid_md5))
+        self.assertTrue(validate_checksum_str(valid_md5))
 
-    def test_validate_hash_str_md5_nok(self):
+    def test_validate_checksum_str_md5_nok(self):
         invalid_md5 = "098f6bcd4621d373xade4e832627b4f6"
         with self.assertRaises(HashStrNotValidException):
-            validate_hash_str(invalid_md5)
+            validate_checksum_str(invalid_md5)
 
-    def test_validate_hash_str_sha256_ok(self):
+    def test_validate_checksum_str_sha256_ok(self):
         valid_sha256 = (
             "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
         )
-        self.assertTrue(validate_hash_str(valid_sha256))
+        self.assertTrue(validate_checksum_str(valid_sha256))
 
-    def test_validate_hash_str_sha256_nok(self):
+    def test_validate_checksum_str_sha256_nok(self):
         invalid_sha256 = (
             "9f86d081884x7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
         )
         with self.assertRaises(HashStrNotValidException):
-            validate_hash_str(invalid_sha256)
+            validate_checksum_str(invalid_sha256)