def is_acceptable_password(password: str) -> bool:
# TODO: Split into smaller funcs
"""
Checks if given password string meets required conditions:
- length > 6;
- contains at least one digit, but cannot consist of just digits (except condition 3);
- if password length > 9 then second condition is skipped;
- should not contain the word "password" in any case;
- should contain 3 different letters or digits regardless of length
:param password: Password string to analyze
:return: True if password is acceptable, False otherwise
"""
check_type(str, password)
blacklist_word = "password"
if len(password) <= 6:
return False
if blacklist_word in password.lower():
return False
full_alphabet = string.ascii_lowercase + string.digits
if len(set(password.lower()) & set(full_alphabet)) < 3:
return False
if len(password) > 9:
return True
if password.isdigit():
return False
if not set(string.digits) & set(password):
return False
return True
def is_all_upper(text: str) -> bool:
"""
Checks if all characters in text are uppercase
:param text: A string to analyse
:return: True if all characters are uppercase, False otherwise
"""
check_type(str, text)
return text.isupper()
def all_the_same(items: list) -> bool:
"""
Checks if all items in list are same
:param items: a list of items to compare
:return: True if all items are same, False if not
"""
check_type(list, items)
items_set = set(items)
return True if len(items_set) <= 1 else False
def validate_iterable(items: Iterable):
"""
Validates iterable for is_ascending func
:param items: Iterable of items
:return: None if all items are valid, raises Assertion
"""
if not isinstance(items, Iterable):
raise TypeError("Given object is not Iterable")
for item in items:
check_type(int, item)
def validate_files_list(files: list) -> None:
"""
Checks that all items in files list belong to 'str' type
:param files: A list of files to validate
:return: "Ok!" if list is correct, otherwise raises TypeError
"""
check_type(list, files)
if not files:
raise TypeError("List is empty")
for item in files:
check_type(str, item)
return
def sun_angle(time: str) -> typing.Union[int, float, str]:
"""
Calculates the sun angle using a time string
:param time: a string of time in format HH:MM (ex: 12:00)
:return: Sun angle if time of the day, otherwise "I don't see the sun!"
"""
check_type(str, time)
check_time_format(time)
hour, minute = list(map(int, time.split(':')))
check_time_values(hour, minute)
angle_of_the_sun = 15 * hour + minute / 4 - 90
return angle_of_the_sun if 0 <= angle_of_the_sun <= 180 else "I don't see the sun!"
def are_isometric(first_string: str, second_string: str) -> bool:
"""
Checks whether two given strings are isometric
:param first_string: First string to compare
:param second_string: Second string to compare
:return: True if strings are isometric, False if strings are not isometric or have different length
"""
check_type(str, first_string)
check_type(str, second_string)
if len(first_string) != len(second_string):
return False
letters = [letter for letter, _ in set(zip(first_string, second_string))]
return len(letters) == len(set(letters))
def is_acceptable_password(password: str) -> bool:
"""
Сhecks if given password length is >6 and it contains at least one digit
:param password: Password string to analyze
:return: True if password is acceptable, False otherwise
"""
check_type(str, password)
if len(password) <= 6:
return False
if not set(string.digits) & set(password):
return False
return True
def multiply_digits(number: int) -> int:
"""
Calculates the product of all digits in given number
:param number: An int number
:return: int product of digits in number, excluding zeroes
"""
check_type(int, number)
assert 0 < number < 1000000
digits = [int(digit) for digit in str(number) if int(digit)]
product = 1
for digit in digits:
product *= digit
return product
def words_order(text: str, words: list) -> bool:
"""
Checks if words in list appear in same order as in text
:param text: str text to analyze
:param words: list of words to search in text
:return: True if order same or len(words) == 1, False otherwise
"""
check_type(str, text)
check_type(list, words)
if not text or not words:
return False
words_from_text = [word for word in text.split() if word in words]
unique_words_from_text = list(dict.fromkeys(words_from_text))
result = unique_words_from_text == words
return result
def morse_decoder(code: str) -> str:
"""
Decodes given morse code
:param code: a string of morse code
:return: decoded string
"""
check_type(str, code)
encoded_words = code.split(" ")
decoded_words = []
for encoded_word in encoded_words:
decoded_word = get_decoded_word(encoded_word)
decoded_words.append(decoded_word)
decoded_string = " ".join(decoded_words)
decoded_string = decoded_string.capitalize()
return decoded_string
def is_acceptable_password(password: str) -> bool:
"""
Сhecks if given password length is >6 and it contains at least one digit
:param password: Password string to analyze
:return: True if password is acceptable, False otherwise
"""
check_type(str, password)
length_is_acceptable = False
has_digit = False
if len(password) > 6:
length_is_acceptable = True
for character in password:
if character.isdigit():
has_digit = True
return length_is_acceptable and has_digit
def validate_tree(tree: List[List[str]]) -> None:
"""
Validates type of given list of tree
:param tree: List of lists of strings, representing fathers and sons
:return: None if list is valid, raises TypeError otherwise
"""
check_contents_of_tree(tree)
check_type(list, tree)
for pair in tree:
check_type(list, pair)
for name in pair:
check_type(str, name)
def test_list_and_dict():
with pytest.raises(TypeError):
check_type(list, {"key": "value"})
def test_two_ints():
assert check_type(int, 1) is None
def test_integer_and_float():
with pytest.raises(TypeError):
check_type(int, 3.2)
def test_int_and_rounded_float():
assert check_type(int, round(1.3)) is None
def test_integer_and_string():
with pytest.raises(TypeError):
check_type(int, "d")
def test_no_arguments():
with pytest.raises(TypeError):
check_type()
def test_one_argument():
with pytest.raises(TypeError):
check_type(1)
def test_string_hypothesis(s):
assert check_type(str, s) is None
