Код-ревью

import io
import sys
from copy import deepcopy
import requests
from bs4 import BeautifulSoup
import sqlite3
import time
 
#ссылки, которые используются:
#https://kazan.hh.ru/login
#https://kazan.hh.ru/search/vacancy?order_by=publication_time&schedule=remote&clusters=true&enable_snippets=true&search_period=7&page=0&items_on_page=100&no_magic=true
CONFIG = {
    "kazan.hh.ru": {
        "login_form_url": "https://kazan.hh.ru/login",
        "url": "https://kazan.hh.ru/account/login?backurl=%2F",
        "vacancies_url": "https://kazan.hh.ru/search/vacancy",
        "login_data": {
            "backUrl": "https://kazan.hh.ru/",
            "failUrl": "/account/login?backurl=%2F",
            # "username": "login@gmail.com",
            # "password": "password",
        },
        "search_data": {
            "order_by": "publication_time",
            "schedule": "remote",
            "enable_snippets": "true",
            "clusters": "true",
            "search_period": "7",
            "page": "0",
            "items_on_page": "100",
            "no_magic": "true"
        },
    }
}
 
DB_PATH = 'test.db'
 
DISALLOWED_WORDS = 'ведущий, журналист, автор, копирайтер, инженер, водитель, директор, писатель' \
                   'телефон, call, саll, сall'
 
 
DISALLOWED_COMPANIES = 'Макдоналдс'
 
s = requests.Session()
s.headers.update({'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; WOW64)'
                  'AppleWebKit/537.36 (KHTML, like Gecko)'
                  'Chrome/72.0.3626.121 Safari/537.36'})
 
 
def write_to_db(vacancies, path=DB_PATH):
    conn = sqlite3.connect(path)
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS attempts (
                     id INTEGER PRIMARY KEY,
                     timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                 )''')
    c.execute('''CREATE TABLE IF NOT EXISTS vacancies (
                     id INTEGER PRIMARY KEY,
                     title TEXT,
                     link TEXT,
                     company TEXT,
                     city TEXT,
                     attempt_id INTEGER,
                     FOREIGN KEY(attempt_id) REFERENCES
                         attempts (id)
                 )''')
 
    c.execute('''INSERT INTO attempts DEFAULT VALUES''')
    attempt_id = c.lastrowid
    for v in vacancies:
        c.execute("INSERT INTO vacancies (title,link,company,city,attempt_id) VALUES (?,?,?,?,?)", [v["title"], v["link"], v["company"], v["city"], attempt_id])
 
    conn.commit()
    conn.close()
 
 
def get_response(url, session, data=None):
    if data is not None:
        return session.get(url, data=data)
    return session.get(url)
 
 
def get_xsrf(url, session):
    html = get_response(url, session).text
    bs = BeautifulSoup(html, "lxml")
    return bs.find("input", {"name": "_xsrf"})["value"]
 
 
def login(session, config):
    login_data = deepcopy(config["login_data"])
    login_data["_xsrf"] = get_xsrf(config["login_form_url"], session)
    r = session.post(config["url"], data=login_data)
 
 
def get_last_link(path=DB_PATH):
    try:
        conn = sqlite3.connect(path)
        c = conn.cursor()
        c.execute('''SELECT * FROM attempts ORDER BY timestamp DESC LIMIT 1''')
        last_attempt_id = c.fetchone()[0]
        c.execute('''SELECT * FROM vacancies WHERE attempt_id = ?''', (last_attempt_id,))
        result = c.fetchone()[2]
        conn.close()
    except:
        result = ''
    return result
 
 
def is_allowed(text, disallowed_words):
    for dw in disallowed_words.split(','):
        if dw.strip().lower() in text.lower():
            return False
    return True
 
 
def get_data(html, last_link):
    last_vacancy_reached = False
    bs = BeautifulSoup(html, "lxml")
    items = bs.find("div", class_="vacancy-serp") \
              .find_all("div", class_="vacancy-serp-item")
    result = []
    for item in items:
        if len(item["class"]) != 1:
            continue
        link = item.find("span", class_="resume-search-item__name").find("a")
        title = link.text.strip()
        if not is_allowed(title, DISALLOWED_WORDS):
            continue
 
        link = link["href"]
        if link == last_link:
            last_vacancy_reached = True
            break
        divs = item.find_all("div", class_="vacancy-serp-item__meta-info")
        company = divs[0].find("a").text.strip()
 
        last_title = title
        last_company = company
 
        if not is_allowed(company, DISALLOWED_COMPANIES):
            continue
        city = divs[1].find("span").text.strip()
 
        data = {"title": title,
                "link": link,
                "company": company,
                "city": city}
        result.append(data)
    return result, last_vacancy_reached
 
 
def get_vacancies(last_link, config):
    result = []
    search_data = deepcopy(config["search_data"])
    while True:
        vacancies_html = get_response(config["vacancies_url"], s, search_data).text
        data_list, last_vacancy_reached = get_data(vacancies_html, last_link)
        result = result + data_list
        if last_vacancy_reached or int(search_data["page"]) >= 19:
            break
        search_data["page"] = str(int(search_data["page"]) + 1)
    return result
 
 
def remove_duplicates(vacancies):
    titles = [t['title'] for t in vacancies]
    companies = [c['company'] for c in vacancies]
    tc = list(zip(titles, companies))
    inds = []
    seen = set()
    for i, ele in enumerate(tc):
        if ele not in seen:
            inds.append(i)
        seen.add(ele)
 
    result = [vacancies[i] for i in inds]
    return result
 
def main():
    #залогиниться на hh.ru
    login(s, config=CONFIG["kazan.hh.ru"])
    #last_link - это ссылка на последнюю полученную вкансию из предыдущего сбора вакансий
    last_link = get_last_link()
    #собрать вакансии. Передаю last_link, чтобы собирать каждую новую вакансию, пока ее ссылка не будет
    #равна last_link
    vacancies = get_vacancies(last_link, config=CONFIG["kazan.hh.ru"])
    if len(vacancies) > 0:
        vacancies = remove_duplicates(vacancies)
        write_to_db(vacancies)
 
 
if __name__ == '__main__':
    main()