1import secret
  2
  3import re
  4import random
  5import string
  6
  7# I am generating the function parameters randomly to avoid
  8# having magic numbers in my code
  9
 10RANGE_BEGIN = 1
 11RANGE_END = 100000
 12
 13
 14def is_static_method(obj_searched, function_to_check):
 15    method = getattr(obj_searched, function_to_check.__name__, None)
 16
 17    if method:
 18        return callable(method) and getattr(method, '__self__', None) is None
 19
 20    return False
 21
 22
 23def generate_random_even():
 24    random_number = random.randint(RANGE_BEGIN, RANGE_END)
 25    if random_number % 2 == 0:
 26        return random_number
 27    else:
 28        # if the random number is odd, add 1 to make it even
 29        return random_number + 1
 30
 31
 32def generate_random_string():
 33    length = random.randint(RANGE_BEGIN, RANGE_END)
 34    characters = string.ascii_letters + string.digits + string.punctuation
 35    random_string = ''.join(random.choice(characters) for _ in range(length))
 36    return random_string
 37
 38
 39def check_for_conditions(function_to_check, obj_searched):
 40    function_name = function_to_check.__name__
 41
 42    # if the function is a part of a class, create an instance
 43    # of the class so that the method has 'self'
 44    if type(obj_searched) == type:
 45        x = obj_searched()
 46        function_to_check = getattr(x, function_name, None)
 47
 48    # first condition - if the function can be called with an int
 49    try:
 50        random_even_num = generate_random_even()
 51        random_odd_num = generate_random_even() + 1
 52        if (function_to_check(random_even_num) == random_even_num ** 2
 53                and function_to_check(random_odd_num) == 0):
 54            return True
 55    except Exception:
 56        pass  # do nothing, check the other conditions
 57
 58    # second condition - the function can be called without arguments
 59    # and throws BaseException or TypeError with a specific message
 60    try:
 61        function_to_check()
 62    except TypeError as data:
 63        if str(data) == "Опаааааа, тука има нещо нередно.":
 64            return True
 65        # else, do nothing - the type error could be caused from calling the function with wrong args
 66    except BaseException:
 67        return True
 68
 69    # third condition - if the function can be called with two strings that get concatenated
 70    try:
 71        left_argument = generate_random_string()
 72        right_argument = generate_random_string()
 73        concatenated = function_to_check(left=left_argument, right=right_argument)
 74        if concatenated != (left_argument + right_argument):
 75            return False
 76        else:
 77            return True
 78    except Exception:
 79        pass
 80
 81    # fourth condition - the method is static for the class
 82    return is_static_method(obj_searched, function_to_check)
 83
 84
 85unique_functions = set()  # keep track of the unique functions
 86
 87
 88def find_all(object_to_search):
 89    """Search for objects with a name containing 'clue' or 'interesting' methods"""
 90
 91    # filter out dunder methods since they aren't interesting anyway
 92    valid_names = [name for name in dir(object_to_search) if not name.startswith("__") and not name.endswith("__")]
 93
 94    for name in valid_names:  # iterate over attributes of the current object
 95        if re.search(r".*clue.*", name):  # regex match clue
 96            # search the current name
 97            find_all(getattr(object_to_search, name, None))
 98
 99        # check if the object is a function and its name is a letter or number
100        elif callable(getattr(object_to_search, name, None)) and re.search(r"^(?!_)\w$", name):
101            if (check_for_conditions(getattr(object_to_search, name, None), object_to_search)
102                    and name not in unique_functions):
103                unique_functions.add(getattr(object_to_search, name, None))
104
105
106def methodify():
107    find_all(secret)
108    return tuple(unique_functions)