def test_top_from_grade_users(self):
con = self.connection_db
count_top = 1000
with con:
target_param = dict(test_target_user)
id_vk_target = target_param.pop("id_vk")
target_id = target_param.get("id")
db_engine.insert_update_user_vk(con, "target_users_vk",
id_vk_target, **target_param)
user_param1 = dict(test_user1)
id_vk1 = user_param1.pop("id_vk")
user_param1.pop("id")
dict_test = dict(test_grade1)
dict_test.pop("target_users_id")
dict_test.pop("users_id")
dict_test.pop("id")
points_auto = dict_test.pop("points_auto")
for num in range(1, count_top + 1):
user_param1.update({"id": num})
dict_test.update(points_auto=points_auto + num)
db_engine.insert_update_user_vk(con, "users_vk", id_vk1 + num,
**user_param1)
db_engine.insert_update_grade_users(con, target_id, num,
**dict_test)
result = db_engine.top_from_grade_users(con, count_top, target_id)
for num, grade in enumerate(result):
self.assertEqual(grade[3], points_auto + count_top - num)
def test_black_list(self):
con = self.connection_db
count_users = 10
with con:
target_param = dict(test_target_user)
id_vk_target = target_param.pop("id_vk")
target_id = target_param.get("id")
db_engine.insert_update_user_vk(con, "target_users_vk",
id_vk_target, **target_param)
user_param1 = dict(test_user1)
id_vk1 = user_param1.pop("id_vk")
user_param1.pop("id")
dict_test = dict(test_grade1)
dict_test.pop("target_users_id")
dict_test.pop("users_id")
dict_test.pop("id")
for num in range(1, count_users + 1):
user_param1.update({"id": num})
dict_test.update(points_user=(-1 if (num % 2) == 0 else num))
db_engine.insert_update_user_vk(con, "users_vk", id_vk1 + num,
**user_param1)
db_engine.insert_update_grade_users(con, target_id, num,
**dict_test)
with patch("db_engine.input", side_effect=["нет"]):
result = db_engine.black_list(con, target_id)
self.assertIsInstance(result, list)
self.assertEqual(len(result), count_users // 2)
def test_get_grade_users(self):
with self.connection_db as con:
target_param = dict(test_target_user)
id_vk_target = target_param.pop("id_vk")
db_engine.insert_update_user_vk(con, "target_users_vk",
id_vk_target, **target_param)
user_param1 = dict(test_user1)
id_vk1 = user_param1.pop("id_vk")
db_engine.insert_update_user_vk(con, "users_vk", id_vk1,
**user_param1)
dict_test = dict(test_grade1)
target_id = dict_test.pop("target_users_id")
users_id = dict_test.pop("users_id")
db_engine.insert_update_grade_users(con, target_id, users_id,
**dict_test)
result = db_engine.get_grade_users(con, target_id, id_vk1, False)
self.assertEqual(
result,
(
test_grade1.get("users_id"),
test_grade1.get("num_common_groups"),
test_grade1.get("points_auto"),
),
)
result = db_engine.get_grade_users(self.connection_db, target_id,
users_id, True)
self.assertIsNone(result)
def top_10_to_file_for_user(connection_db, vk_api, current_target_user):
if True:
dict_top10 = dict()
current_top10 = top_from_grade_users(
connection_db, 10, current_target_user.user_bd_id, False
)
users_id_bd_list = []
status_bar_top10 = StatusBar(len(current_top10))
print("Ищем самые лучшие фотографии пользователей")
for item in current_top10:
status_bar_top10.plus()
users_id_bd_list.append(item[2])
vk_id = get_user_of_id_vk(connection_db, "users_vk", item[2], bd=True)[1]
url_user = f"https://vk.com/id{vk_id}"
list_best_photo = get_best_photo(vk_api, vk_id)
dict_top10.update({vk_id: {"url": url_user, "photos": list_best_photo}})
filename = f'{current_target_user.user_vk_id}_{dt.now().strftime("%y%m%d_%H%M%S")}.json'
with open(filename, "w", encoding="utf-8") as file:
json.dump(dict_top10, file)
with connection_db:
for user_id_bd in users_id_bd_list:
insert_update_grade_users(
connection_db,
current_target_user.user_bd_id,
user_id_bd,
export_state=True,
)
return filename
def calc_top_for_user(connection_db, vk_api, current_target_user):
if vk_api and True:
# определяем топ 99 пользователей
top_100 = top_from_grade_users(
connection_db, 99, current_target_user.user_bd_id
)
# первый пользователь - целевой
top_100_ids_vk = [current_target_user.user_vk_id]
for item in top_100:
top_100_ids_vk.append(
get_user_of_id_vk(connection_db, "users_vk", item[2], True)[1]
)
# забираем для них и текущего пользователя группы
groups_top_100 = find_group_all_users_list_25(top_100_ids_vk, vk_api)
groups_target_user = groups_top_100[0].get(current_target_user.user_vk_id)
for num_user, user_groups in enumerate(groups_top_100[1:]):
for user, groups_user in user_groups.items():
common_groups = calc_common_param(groups_target_user, groups_user)
if common_groups:
grade_in = get_grade_users(
connection_db, current_target_user.user_bd_id, user
)
if grade_in and not grade_in[1]:
points_group = calc_points(common_groups, {1: 20, 2: 25, 3: 30})
points_auto = grade_in[2] + points_group
insert_update_grade_users(
connection_db,
current_target_user.user_bd_id,
grade_in[0],
points_auto=points_auto,
num_common_groups=common_groups,
)
def test_insert_update_grade_users(self):
dict_test = dict(test_grade1)
target_id = dict_test.pop("target_users_id")
users_id = dict_test.pop("users_id")
with self.connection_db as con:
with con.cursor() as curs:
curs.execute(
f"select * from grade_users where target_users_id = {target_id}"
f"and users_id = {users_id}")
curs.fetchall()
target_param = dict(test_target_user)
id_vk_target = target_param.pop("id_vk")
db_engine.insert_update_user_vk(con, "target_users_vk",
id_vk_target, **target_param)
user_param1 = dict(test_user1)
id_vk1 = user_param1.pop("id_vk")
db_engine.insert_update_user_vk(con, "users_vk", id_vk1,
**user_param1)
with self.connection_db as con:
result = db_engine.insert_update_grade_users(
con, target_id, users_id, **dict_test)
self.assertEqual(
result,
(
test_grade1.get("id"),
test_grade1.get("target_users_id"),
test_grade1.get("users_id"),
test_grade1.get("points_auto"),
test_grade1.get("points_user"),
test_grade1.get("num_common_friends"),
test_grade1.get("num_common_groups"),
test_grade1.get("export_state"),
),
)
def search_users_of_parametr(connection, vk_api, search_p, current_target_user):
all_users_id_search = []
count_all_iteration = len(search_p.status) * (
search_p.age_to - search_p.age_from + 1
)
print("Поиск подходящих пользователей")
status_bar_find = StatusBar(count_all_iteration)
for current_status in search_p.status:
count_errors = 0
for current_age in range(search_p.age_from, search_p.age_to + 1):
status_bar_find.plus(1)
dict_search = dict(
q=search_p.q,
city=search_p.city,
age_from=current_age,
age_to=current_age,
count=search_p.count,
sex=search_p.sex,
has_photo=search_p.has_photo,
status=current_status,
sort=random.choice((0, 1)),
fields=[
"bdate",
"relation",
"city",
"common_count",
"sex",
"activities",
"interests",
"music",
"movies",
"books",
"quotes",
"about",
"home_town",
],
)
users_search = api_reuest(vk_api, "users.search", **dict_search)
# счетчик ошибок, если на одном пользователе нет ответа, то выходим из цикла досрочно
if not users_search:
count_errors += 1
if count_errors == 10:
break
continue
with connection:
for user in users_search.get("items"):
# print(user)
try:
user_current_search = insert_update_user_vk(
connection,
"users_vk",
user.get("id"),
first_name=user.get("first_name"),
last_name=user.get("last_name"),
age=current_age,
city=search_p.city,
sex=user.get("sex"),
relation=current_status,
activities=list_from_string(user.get("activities")),
interests=list_from_string(user.get("interests")),
movies=list_from_string(user.get("movies")),
music=list_from_string(user.get("music")),
books=list_from_string(user.get("books")),
quotes=list_from_string(user.get("quotes")),
about=list_from_string(user.get("about")),
home_town=list_from_string(user.get("home_town")),
)
user_id_bd = user_current_search[0]
# print('user', user_current_search)
all_users_id_search.append(user_id_bd)
# if user_current_search[7]:
# common_activities = set(current_target_user.activities) & set(user_current_search[7])
# print(f'common_activities:{common_activities}')
common_activities = calc_common_param(
current_target_user.activities, user_current_search[7]
)
common_interests = calc_common_param(
current_target_user.interests, user_current_search[8]
)
common_movies = calc_common_param(
current_target_user.movies, user_current_search[9]
)
common_music = calc_common_param(
current_target_user.music, user_current_search[10]
)
common_books = calc_common_param(
current_target_user.books, user_current_search[11]
)
common_quotes = calc_common_param(
current_target_user.quotes, user_current_search[12]
)
common_about = calc_common_param(
current_target_user.about, user_current_search[13]
)
common_home_town = calc_common_param(
current_target_user.home_town, user_current_search[14]
)
points_relation = calc_points(current_status, {1: 5, 6: 15})
points_age = calc_points(
int(math.fabs(current_target_user.age - current_age)),
{0: 20, 1: 17, 2: 15, 3: 12, 4: 10, 5: 5},
)
points_activities = calc_points(
common_activities, {1: 10, 2: 20, 3: 30}
)
points_interests = calc_points(
common_interests, {1: 10, 2: 20, 3: 30}
)
points_movies = calc_points(
common_movies, {1: 10, 2: 13, 3: 15}
)
points_music = calc_points(common_music, {1: 20, 2: 25, 3: 30})
points_books = calc_points(common_books, {1: 10, 2: 15, 3: 20})
points_quotes = calc_points(
common_quotes, {1: 10, 2: 20, 3: 30}
)
points_about = calc_points(common_about, {1: 10, 2: 20, 3: 30})
points_home_town = calc_points(
common_home_town, {1: 20, 2: 25, 3: 30}
)
points_common_friends = calc_points(
user.get("common_count"), {1: 30, 2: 35, 3: 40}
)
points_auto = (
points_age
+ points_relation
+ points_activities
+ points_interests
+ points_movies
+ points_music
+ points_books
+ points_quotes
+ points_about
+ points_home_town
+ points_common_friends
)
insert_update_grade_users(
connection,
current_target_user.user_bd_id,
user_id_bd,
points_auto=points_auto,
num_common_friends=user.get("common_count"),
)
except TypeError as e:
print(f"Ошика типов: {e}")
if all_users_id_search:
return all_users_id_search