Skip to content

Updated Password & Array Validator #18

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jul 2, 2025
Merged

Updated Password & Array Validator #18

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
6ccd9d1
Update password_validator.py
bandirevanth Jun 29, 2025
7e16d03
Update array_validator.py
bandirevanth Jun 29, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
71 changes: 47 additions & 24 deletions sanatio/array_validator.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,32 +1,55 @@
from typing import Any, List, Optional
from sanatio.base_class import BaseValidator


class ArrayValidator(BaseValidator):

def isArray(self, value) -> bool:
""" check if the string is array or not """
def is_array(self, value: Any) -> bool:
"""Check if the value is a list (array)."""
return isinstance(value, list)

def isArrayLength(self, value, min: int = 0, max: int = None) -> bool:
""" check if the array length is between min and max """
return min <= len(value) <= max

def isContains(self, value, contains) -> bool:
""" check if the array contains the element or not """
return contains in value

def isUnique(self, value) -> bool:
""" check if the array contains unique elements or not """
return len(value) == len(set(value))

def isMultidimensional(self, value) -> bool:
""" check if the array is multidimensional or not """
def is_array_length(self, value: List[Any], min_length: int = 0, max_length: Optional[int] = None) -> bool:
"""Check if the array length is between min_length and max_length (inclusive)."""
if not self.is_array(value):
return False
if max_length is not None:
return min_length <= len(value) <= max_length
return len(value) >= min_length

def is_contains(self, value: List[Any], item: Any) -> bool:
"""Check if the array contains a given element."""
if not self.is_array(value):
return False
return item in value

def is_unique(self, value: List[Any]) -> bool:
"""Check if all elements in the array are unique."""
if not self.is_array(value):
return False
try:
return len(value) == len(set(value))
except TypeError:
# Handles case where elements are unhashable (e.g., lists)
seen = []
for i in value:
if i in seen:
return False
seen.append(i)
return True

def is_multidimensional(self, value: List[Any]) -> bool:
"""Check if the array is multidimensional (contains at least one list)."""
if not self.is_array(value):
return False
return any(isinstance(i, list) for i in value)

def isMinlength(self, value, min: int) -> bool:
""" check if the array length is greater than min """
return len(value) > min

def isMaxlength(self, value, max: int) -> bool:
""" check if the array length is less than max """
return len(value) < max
def is_min_length(self, value: List[Any], min_length: int) -> bool:
"""Check if the array length is greater than or equal to min_length."""
if not self.is_array(value):
return False
return len(value) >= min_length

def is_max_length(self, value: List[Any], max_length: int) -> bool:
"""Check if the array length is less than or equal to max_length."""
if not self.is_array(value):
return False
return len(value) <= max_length
146 changes: 75 additions & 71 deletions sanatio/password_validator.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,85 +1,89 @@
import re
from typing import List, Optional

from sanatio.base_class import BaseValidator


class PasswordValidator(BaseValidator):

def isStrongPassword(self, value: str,
min_length: int = 8,
special_chars: bool = True,
numbers: bool = True,
uppercase: bool = True,
lowercase: bool = True) -> bool:
""" check if the string is strong password or not

requirements:
1. At least 8 characters long
2. At least one uppercase letter
3. At least one lowercase letter
4. At least one number
5. At least one special character
def is_strong_password(self, value: str,
min_length: int = 8,
special_chars: bool = True,
numbers: bool = True,
uppercase: bool = True,
lowercase: bool = True) -> bool:
"""Check if the string is a strong password.

Requirements:
1. At least `min_length` characters
2. At least one uppercase letter (optional)
3. At least one lowercase letter (optional)
4. At least one number (optional)
5. At least one special character (optional)
"""
if not self.isPasswordLength(value, min_length) or \
(special_chars and not self.isPasswordSpecialChar(value)) or \
(numbers and not self.isPasswordNumber(value)) or \
(uppercase and not self.isPasswordUppercase(value)) or \
(lowercase and not self.isPasswordLowercase(value)):
if not self.is_password_length(value, min_length):
return False
if special_chars and not self.is_password_special_char(value):
return False
if numbers and not self.is_password_number(value):
return False
if uppercase and not self.is_password_uppercase(value):
return False
if lowercase and not self.is_password_lowercase(value):
return False

return True

def isPasswordUppercase(self, value: str, min_length: int = 1) -> bool:
""" check if the string has uppercase letters """
if len(re.findall(r'[A-Z]', value)) >= min_length:
return True

def isPasswordLowercase(self, value: str, min_length: int = 1) -> bool:
""" check if the string has lowercase letters """
if len(re.findall(r'[a-z]', value)) >= min_length:
return True

def isPasswordNumber(self, value: str, min_length: int = 1) -> bool:
""" check if the string has numbers """
if len(re.findall(r'[0-9]', value)) >= min_length:
return True

def isPasswordLength(self, value: str, min_length: int = 8) -> bool:
""" check if the string length is between min and max """
if len(value) >= min_length:
return True

def isPasswordSpecialChar(self, value: str, min_length: int = 1) -> bool:
""" check if the string has special characters """
if len(re.findall(r'[_@$]', value)) >= min_length:
return True

def isPasswordMatch(self, value: str, match_value: str, ignore_case: bool = False) -> bool:
""" check if the string matches the match_value """
if ignore_case and value.lower() == match_value.lower():
return True
elif value == match_value:
return True

def isPasswordNotMatch(self, value: str, match_value: str, ignore_case: bool = False) -> bool:
""" check if the string does not match the match_value """
if ignore_case and value.lower() != match_value.lower():
return True
elif value != match_value:
return True

def isPasswordNotInList(self, value: str, list_values: list, ignore_case: bool = False) -> bool:
""" check if the string is not in the list """
if ignore_case and value.lower() not in [x.lower() for x in list_values]:
return True
elif value not in list_values:
return True

def isPasswordNotInFile(self, value: str, file_path: str, ignore_case: bool = False) -> bool:
""" check if the string is not in the file """
def is_password_uppercase(self, value: str, min_length: int = 1) -> bool:
"""Check if the string has at least `min_length` uppercase letters."""
return len(re.findall(r'[A-Z]', value)) >= min_length

def is_password_lowercase(self, value: str, min_length: int = 1) -> bool:
"""Check if the string has at least `min_length` lowercase letters."""
return len(re.findall(r'[a-z]', value)) >= min_length

def is_password_number(self, value: str, min_length: int = 1) -> bool:
"""Check if the string has at least `min_length` digits."""
return len(re.findall(r'\d', value)) >= min_length

def is_password_length(self, value: str, min_length: int = 8) -> bool:
"""Check if the string is at least `min_length` characters long."""
return len(value) >= min_length

def is_password_special_char(self, value: str, min_length: int = 1) -> bool:
"""Check if the string has at least `min_length` special characters."""
# Common special characters set: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
return len(re.findall(r'[^a-zA-Z0-9]', value)) >= min_length

def is_password_match(self, value: str, match_value: str, ignore_case: bool = False) -> bool:
"""Check if the password matches `match_value`."""
if ignore_case:
return value.lower() == match_value.lower()
return value == match_value

def is_password_not_match(self, value: str, match_value: str, ignore_case: bool = False) -> bool:
"""Check if the password does not match `match_value`."""
if ignore_case:
return value.lower() != match_value.lower()
return value != match_value

def is_password_not_in_list(self, value: str, list_values: Optional[List[str]] = None,
ignore_case: bool = False) -> bool:
"""Check if the password is not in a list of disallowed passwords."""
if list_values is None:
list_values = []

if ignore_case:
return value.lower() not in [x.lower() for x in list_values]
return value not in list_values

def is_password_not_in_file(self, value: str, file_path: str, ignore_case: bool = False) -> bool:
"""Check if the password is not in a file of disallowed passwords."""
if not hasattr(self, "read_file"):
raise NotImplementedError("read_file() method not implemented in BaseValidator or subclass.")

data = self.read_file(file_path, split_lines=True)

if ignore_case and value.lower() not in [x.lower() for x in data]:
return True
elif value not in data:
return True
if ignore_case:
return value.lower() not in [x.lower() for x in data]
return value not in data