133 lines
4.4 KiB
Python
133 lines
4.4 KiB
Python
from modules.user import info as user_info
|
|
from modules.algorithms.univ import dict_key_verify
|
|
from modules.algorithms.uuid import hash_string
|
|
|
|
class User():
|
|
def __init__(self, username, origin=False):
|
|
self.username = username
|
|
self.friends = user_info.friend(username=username)
|
|
self.origin = origin
|
|
|
|
self.exclude = []
|
|
self.count = 1
|
|
self.depth = 0
|
|
self.score = 0
|
|
|
|
self.friend_list = []
|
|
|
|
def find_friends(self, exclude=[], **kwargs):
|
|
self.exclude += exclude
|
|
friends = self.friends.get()
|
|
if dict_key_verify(friends, "friends"):
|
|
self.__organise_friends(friends['friends'])
|
|
|
|
self.__find_excluded()
|
|
|
|
def __organise_friends(self, friends, **kwargs):
|
|
for friend in friends:
|
|
if friend['username'] not in self.exclude:
|
|
self.friend_list.append(User(friend['username']))
|
|
|
|
def __find_excluded(self):
|
|
if self.username not in self.exclude:
|
|
self.exclude.append(self.username)
|
|
if self.origin:
|
|
self.exclude = self.exclude + [friend.username for friend in self.friend_list]
|
|
requests = self.friends.get_requests()
|
|
print(f"requests: {requests}")
|
|
if dict_key_verify(requests, "requests"):
|
|
self.exclude = self.exclude + [request for request in requests["requests"]]
|
|
print(f"EXCLUDED: {self.exclude}")
|
|
|
|
def __hash__(self):
|
|
obj_hash = hash_string(self.username)
|
|
return obj_hash
|
|
|
|
class Graph():
|
|
def __init__(self, username):
|
|
self.origin_user = User(username, True)
|
|
self.graph = [[]] * (10**7+7)
|
|
|
|
self.friend_directory = [None] * (10**7+7)
|
|
self.friend_directory[hash(self.origin_user)] = self.origin_user
|
|
self.exclude = []
|
|
|
|
def generate(self, depth=1):
|
|
self.__add_user_friends(self.origin_user, self.origin_user, depth)
|
|
|
|
def __add_user_friends(self, origin, source, depth):
|
|
origin.find_friends(self.exclude + [source.username])
|
|
if hash(self.origin_user) == hash(origin):
|
|
self.exclude += origin.exclude
|
|
|
|
for friend in origin.friend_list:
|
|
friend_hash = hash(friend)
|
|
self.__add_edge(hash(origin), friend_hash)
|
|
if self.friend_directory[friend_hash]:
|
|
self.friend_directory[friend_hash].count += 1
|
|
self.friend_directory[friend_hash].depth += depth
|
|
else:
|
|
self.friend_directory[friend_hash] = friend
|
|
|
|
if depth-1 > 0:
|
|
self.__add_user_friends(friend, origin, depth-1)
|
|
|
|
def __add_edge(self, node, edge):
|
|
self.graph[node] = self.graph[node] + [edge]
|
|
|
|
|
|
def dft(self):
|
|
self.visted = []
|
|
self.edge_stack = [hash(self.origin_user)]
|
|
self.edge_queue = [hash(self.origin_user)]
|
|
|
|
self.__visit(self.edge_stack[0])
|
|
|
|
def __visit(self, origin):
|
|
start_pos = self.graph[origin]
|
|
self.__on_visit(origin)
|
|
|
|
self.edge_stack.pop(len(self.edge_stack)-1)
|
|
self.visted.append(origin)
|
|
|
|
for neigbour in start_pos:
|
|
if neigbour not in self.visted and neigbour not in self.edge_stack:
|
|
self.edge_stack.append(neigbour)
|
|
|
|
while len(self.edge_stack) > 0:
|
|
i = len(self.edge_stack) - 1
|
|
self.__visit(self.edge_stack[i])
|
|
|
|
def __on_visit(self, origin):
|
|
origin_obj = self.friend_directory[origin]
|
|
origin_obj.score += origin_obj.depth
|
|
|
|
def recomend_friends(self):
|
|
self.recomendations = []
|
|
while len(self.recomendations) != len(self.visted):
|
|
largest = User(username="")
|
|
largest.score = -1
|
|
for friend in self.visted:
|
|
friend_obj = self.friend_directory[friend]
|
|
if friend_obj not in self.recomendations and friend_obj.score > largest.score:
|
|
largest = friend_obj
|
|
self.recomendations.append(largest)
|
|
|
|
def recomend_friend(amount=1, depth=1):
|
|
if depth not in [1, 2, 3, 4]:
|
|
depth = 4
|
|
friend_graph = Graph("user1")
|
|
friend_graph.generate(depth)
|
|
friend_graph.dft()
|
|
friend_graph.recomend_friends()
|
|
|
|
recomended = [{'username': recomended.username} for recomended in friend_graph.recomendations[:amount]]
|
|
print(recomended)
|
|
return recomended
|
|
|
|
def main():
|
|
recomend_friend(3, 4)
|
|
|
|
if __name__ == "__main__":
|
|
main()
|