├── resume
    ├── 把简历放这里.txt
    └── .DS_Store
├── .DS_Store
├── requirements.txt
├── config.py
├── README
├── test.py
├── functions.py
├── langchain_functions.py
├── finding_jobs.py
└── write_response.py


/resume/把简历放这里.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LouisCaixuran/auto_job_find_azure/HEAD/.DS_Store


--------------------------------------------------------------------------------
/resume/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/LouisCaixuran/auto_job_find_azure/HEAD/resume/.DS_Store


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | langchain==0.0.354
2 | openai==1.6.1
3 | packaging==23.2
4 | python-dotenv==1.0.0
5 | selenium==4.16.0
6 | robotframework
7 | robotframework-seleniumlibrary
8 | robotframework-pythonlibcore
9 | 


--------------------------------------------------------------------------------
/config.py:
--------------------------------------------------------------------------------
1 | #replace the values with your own
2 | 
3 | OPENAI_BASE_URL= <AZURE ENDPOINT> #e.g. "https://hkust.azure-api.net"
4 | OPENAI_API_KEY= <primary key> #your azure openai key
5 | OPENAI_VERSION= <version> #your api version e.g. "2023-05-15"
6 | OPENAI_DEPLOYMENT= <deployment> #deployment e.g. "gpt-35-turbo-16k"
7 | LABEL= <label> #e.g. "后端开发（深圳）"
8 | BROSWER_TYPE="chrome" #默认使用chrome浏览器，如使用其他请修改


--------------------------------------------------------------------------------
/README:
--------------------------------------------------------------------------------
 1 | 本程序是一个自动化求职程序，主要是通过azure openai的api来生成打招呼信息，然后通过selenium来自动化投递简历到boss直聘上
 2 | 
 3 | 本程序来自https://github.com/Frrrrrrrrank/auto_job__find__chatgpt__rpa/blob/master/auto_job_find/write_response.py
 4 | 在此基础上进行了修改，主要是将openai的api改为了azure的openai api.如使用openai的api请参考原版。
 5 | 
 6 | 使用方法：
 7 | 1.clone本项目到本地
 8 | 2.在目录下运行 pip install -r requirements.txt 安装所需包
 9 | 3.配置好azure的api，将api的key，endpoint，version，deployment，填入到config.py中,并修改label为你主页存在的你想要遍历的职位的tag
10 | 4.将想要投递的简历命名为“my_cover.pdf”，放入resume文件夹中
11 | 5.运行write_response.py
12 | 6.在自动打开的boss直聘中扫码登录
13 | 
14 | 注意提前关闭boss直聘账户中默认打招呼语句，否则会影响程序的运行
15 | 
16 | 


--------------------------------------------------------------------------------
/test.py:
--------------------------------------------------------------------------------
 1 | from selenium import webdriver
 2 | from selenium.webdriver.chrome.options import Options
 3 | from config import BROSWER_TYPE
 4 | 
 5 | def open_browser_with_options(url, browser):
 6 |     options = Options()
 7 |     options.add_experimental_option("detach", True)
 8 | 
 9 |     if browser == "chrome":
10 |         driver = webdriver.Chrome(options=options)
11 |         driver.maximize_window()
12 |     else:
13 |         raise ValueError("Browser type not supported")
14 | 
15 |     driver.get(url)
16 | 
17 | # Variables
18 | url = "https://www.zhipin.com/web/geek/job-recommend?ka=header-job-recommend"
19 | browser_type = BROSWER_TYPE
20 | 
21 | # Test case
22 | open_browser_with_options(url, browser_type)
23 | 


--------------------------------------------------------------------------------
/functions.py:
--------------------------------------------------------------------------------
 1 | import json
 2 | import os
 3 | from openai import AzureOpenAI as OpenAI
 4 | from dotenv import load_dotenv
 5 | from config import *
 6 | load_dotenv()
 7 | 
 8 | os.environ["OPENAI_API_TYPE"] = "azure"
 9 | os.environ["OPENAI_API_VERSION"] = OPENAI_VERSION
10 | os.environ["AZURE_OPENAI_ENDPOINT"] = OPENAI_BASE_URL
11 | os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
12 | 
13 | # Init OpenAI Client
14 | client = OpenAI(azure_deployment=OPENAI_DEPLOYMENT,api_key=OPENAI_API_KEY, api_version=OPENAI_VERSION, azure_endpoint=OPENAI_BASE_URL)
15 | assistant_instructions = """
16 |     本助手将扮演一位求职者的角色，根据上传的pdf简历以及应聘工作的描述，来直接给HR写一个礼貌专业的求职新消息，要求能够用专业的语言结合简历中的经历和技能，并结合应聘工作的描述，来阐述自己的优势，尽最大可能打动招聘者。并且请您始终使用中文来进行消息的编写,开头是招聘负责人，结尾是真诚的，付尧全。这是一封完整的求职信，不要包含求职信内容以外的东西，例如“根据您上传的求职要求和个人简历，我来帮您起草一封求职邮件：”这一类的内容，以便于我直接自动化复制粘贴发送
17 | """
18 | # Create or load assistant
19 | def create_assistant(client):
20 |   assistant_file_path = 'assistant.json'
21 | 
22 |   # If there is an assistant.json file already, then load that assistant
23 |   if os.path.exists(assistant_file_path):
24 |     with open(assistant_file_path, 'r') as file:
25 |       assistant_data = json.load(file)
26 |       assistant_id = assistant_data['assistant_id']
27 |       print("Loaded existing assistant ID.")
28 |   else:
29 |     # If no assistant.json is present, create a new assistant using the below specifications
30 | 
31 |     # To change the knowledge document, modify the file name below to match your document
32 |     # If you want to add multiple files, paste this function into ChatGPT and ask for it to add support for multiple files
33 |     file = client.files.create(file=open("my_cover.pdf", "rb"),
34 |                                purpose='assistants')
35 | 
36 |     assistant = client.beta.assistants.create(
37 |         # Getting assistant prompt from "prompts.py" file, edit on left panel if you want to change the prompt
38 |         instructions=assistant_instructions,
39 |         model="gpt-35-turbo-16k",
40 |         tools=[
41 |             {
42 |                 "type": "retrieval"  # This adds the knowledge base as a tool
43 |             },
44 |         ],
45 |         file_ids=[file.id])
46 |     print("created assistant\n")
47 |     # Create a new assistant.json file to load on future runs
48 |     with open(assistant_file_path, 'w') as file:
49 |       json.dump({'assistant_id': assistant.id}, file)
50 |       print("Created a new assistant and saved the ID.")
51 | 
52 |     assistant_id = assistant.id
53 | 
54 |   return assistant_id
55 | 


--------------------------------------------------------------------------------
/langchain_functions.py:
--------------------------------------------------------------------------------
  1 | from langchain.document_loaders import DirectoryLoader, PyPDFLoader
  2 | from langchain.text_splitter import CharacterTextSplitter
  3 | from langchain.embeddings import AzureOpenAIEmbeddings as OpenAIEmbeddings
  4 | from langchain.vectorstores import FAISS
  5 | from langchain.chains import RetrievalQA
  6 | from langchain.chat_models import AzureChatOpenAI as ChatOpenAI
  7 | from langchain.prompts import PromptTemplate
  8 | import os
  9 | from dotenv import load_dotenv
 10 | from config import *
 11 | 
 12 | 
 13 | os.environ["OPENAI_API_TYPE"] = "azure"
 14 | os.environ["OPENAI_API_VERSION"] = OPENAI_VERSION
 15 | os.environ["AZURE_OPENAI_API_KEY"] = OPENAI_API_KEY
 16 | os.environ["AZURE_OPENAI_ENDPOINT"] = OPENAI_BASE_URL
 17 | load_dotenv()
 18 | assistant_instructions = """
 19 |     本助手将扮演一位求职者的角色，根据上传的pdf简历以及应聘工作的描述，来直接给HR写一个礼貌专业的求职新消息，要求能够用专业的语言结合简历中的经历和技能，并结合应聘工作的描述，来阐述自己的优势，尽最大可能打动招聘者。并且请您始终使用中文来进行消息的编写,开头是招聘负责人，结尾是真诚的，付尧全。这是一封完整的求职信，不要包含求职信内容以外的东西，例如“根据您上传的求职要求和个人简历，我来帮您起草一封求职邮件：”这一类的内容，以便于我直接自动化复制粘贴发送
 20 | """
 21 | 
 22 | # 判断是否使用langchain。如果设置了自定义的api地址，则使用langchain
 23 | def should_use_langchain():
 24 |     should_use_langchain = OPENAI_BASE_URL is not None
 25 |     return should_use_langchain
 26 | 
 27 | # 读取简历数据
 28 | def read_resumes():
 29 |     # 读取resume文件夹中的所有文件
 30 |     d_loader = DirectoryLoader("./resume", glob="*.pdf",loader_cls=PyPDFLoader)
 31 | 
 32 |     # 获取 PDF 文本，返回一个列表，列表中的每个元素都是一个 PDF 文档的页
 33 |     pdf_pages = d_loader.load()
 34 | 
 35 |     resume_text = ""
 36 | 
 37 |     for page in pdf_pages:
 38 |         # 建立路径，用于区分是哪一份简历
 39 |         # print(page.metadata.get('source'))
 40 | 
 41 |         page_text = page.page_content
 42 |         resume_text += page_text
 43 | 
 44 |     return resume_text
 45 | 
 46 | # 文本分割
 47 | def get_text_chunks(text):
 48 |     text_splitter = CharacterTextSplitter(
 49 |         separator="\n",
 50 |         chunk_size=2000,
 51 |         chunk_overlap=200,
 52 |         length_function=len
 53 |     )
 54 |     chunks = text_splitter.split_text(text)
 55 |     return chunks
 56 | 
 57 | # 向量化，并且返回向量存储库
 58 | def get_vectorstore(text_chunks):
 59 |     embeddings = OpenAIEmbeddings()
 60 |     # embeddings = HuggingFaceInstructEmbeddings(model_name="hkunlp/instructor-xl")
 61 |     vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
 62 |     return vectorstore
 63 | 
 64 | # 生成求职信
 65 | def generate_letter(vectorstore, job_description):
 66 |     # 字数限制
 67 |     character_limit = 300
 68 |     letter=""
 69 |     try:
 70 |         langchain_prompt_template = f"""
 71 |             你将扮演一位求职者的角色,根据上下文里的简历内容以及应聘工作的描述,来直接给HR写一个礼貌专业, 且字数严格限制在{character_limit}以内的求职消息,要求能够用专业的语言结合简历中的经历和技能,并结合应聘工作的描述,来阐述自己的优势,尽最大可能打动招聘者。始终使用中文来进行消息的编写。开头是招聘负责人, 结尾附上求职者联系方式。这是一份求职消息，不要包含求职内容以外的东西,例如“根据您上传的求职要求和个人简历,我来帮您起草一封求职邮件：”这一类的内容，以便于我直接自动化复制粘贴发送。
 72 |             工作描述
 73 |             {job_description}"""+"""
 74 |             简历内容:
 75 |             {context}
 76 |             要求:
 77 |             {question} 
 78 |         """
 79 | 
 80 |         question = assistant_instructions
 81 |         PROMPT = PromptTemplate.from_template(langchain_prompt_template)
 82 |         llm = ChatOpenAI(temperature=1.0,
 83 |                         openai_api_version=OPENAI_VERSION,
 84 |                         openai_api_key=OPENAI_API_KEY,
 85 |                         openai_api_type="azure",
 86 |                         azure_deployment=OPENAI_DEPLOYMENT,)
 87 |         qa_chain = RetrievalQA.from_chain_type(
 88 |             llm, 
 89 |             retriever=vectorstore.as_retriever(),
 90 |             # return_source_documents=True,
 91 |             chain_type_kwargs={"prompt": PROMPT}
 92 |         )
 93 | 
 94 |         result = qa_chain({"query": question})
 95 |         letter = result['result']
 96 |         #去掉所有换行符，防止分成多段消息
 97 |         letter = letter.replace('\n', ' ')
 98 |     except Exception as e:
 99 |         print(f"An error occurred: {e}")
100 | 
101 |     return letter
102 | 


--------------------------------------------------------------------------------
/finding_jobs.py:
--------------------------------------------------------------------------------
  1 | import time
  2 | 
  3 | from selenium import webdriver
  4 | from selenium.common import NoSuchElementException
  5 | from selenium.webdriver.chrome.options import Options
  6 | from selenium.webdriver.common.by import By
  7 | from selenium.webdriver.support.ui import WebDriverWait
  8 | from selenium.webdriver.support import expected_conditions as EC
  9 | from config import BROSWER_TYPE
 10 | 
 11 | # 全局 WebDriver 实例
 12 | driver = None
 13 | 
 14 | 
 15 | def get_driver():
 16 |     global driver
 17 |     return driver
 18 | 
 19 | 
 20 | def open_browser_with_options(url, browser):
 21 |     global driver
 22 |     options = Options()
 23 |     options.add_experimental_option("detach", True)
 24 | 
 25 |     if browser == BROSWER_TYPE:
 26 |         driver = webdriver.Chrome(options=options)
 27 |         driver.maximize_window()
 28 |     else:
 29 |         raise ValueError("Browser type not supported")
 30 | 
 31 |     driver.get(url)
 32 | 
 33 |     # 等待直到页面包含特定的 XPath 元素
 34 |     xpath_locator = "//*[@id='header']/div[1]/div[3]/div/a"
 35 |     WebDriverWait(driver, 10).until(
 36 |         EC.presence_of_element_located((By.XPATH, xpath_locator))
 37 |     )
 38 | 
 39 | def log_in():
 40 |     global driver
 41 | 
 42 |     # 点击按钮
 43 |     login_button = driver.find_element(By.XPATH, "//*[@id='header']/div[1]/div[3]/div/a")
 44 |     login_button.click()
 45 | 
 46 |     # 等待微信登录按钮出现
 47 |     xpath_locator_wechat_login = "//*[@id='wrap']/div/div[2]/div[2]/div[2]/div[1]/div[4]/a"
 48 |     WebDriverWait(driver, 10).until(
 49 |         EC.presence_of_element_located((By.XPATH, xpath_locator_wechat_login))
 50 |     )
 51 | 
 52 |     wechat_button = driver.find_element(By.XPATH, "//*[@id='wrap']/div/div[2]/div[2]/div[2]/div[1]/div[4]/a")
 53 |     wechat_button.click()
 54 | 
 55 |     xpath_locator_wechat_logo = "//*[@id='wrap']/div/div[2]/div[2]/div[1]/div[2]/div[1]/img"
 56 |     WebDriverWait(driver, 10).until(
 57 |         EC.presence_of_element_located((By.XPATH, xpath_locator_wechat_logo))
 58 |     )
 59 | 
 60 |     xpath_locator_login_success = "//*[@id='header']/div[1]/div[3]/ul/li[2]/a"
 61 |     WebDriverWait(driver, 60).until(
 62 |         EC.presence_of_element_located((By.XPATH, xpath_locator_login_success))
 63 |     )
 64 | 
 65 | def get_job_description():
 66 | 
 67 |     global driver
 68 | 
 69 |     # 使用给定的 XPath 定位职位描述元素
 70 |     xpath_locator_job_description = "//*[@id='wrap']/div[2]/div[2]/div/div/div[2]/div/div[2]/p"
 71 | 
 72 |     # 确保元素已加载并且可以获取文本
 73 |     job_description_element = WebDriverWait(driver, 10).until(
 74 |         EC.presence_of_element_located((By.XPATH, xpath_locator_job_description))
 75 |     )
 76 | 
 77 |     # 获取职位描述文本
 78 |     job_description = job_description_element.text
 79 |     print(job_description)  # 打印出职位描述，或者你可以在这里做其他处理
 80 | 
 81 |     # 返回职位描述文本，如果函数需要
 82 |     return job_description
 83 | 
 84 | def select_dropdown_option(driver, label):
 85 |     # 尝试在具有特定类的元素中找到文本
 86 |     trigger_elements = driver.find_elements(By.XPATH, "//*[@class='recommend-job-btn has-tooltip']")
 87 | 
 88 |     # 标记是否找到元素
 89 |     found = False
 90 | 
 91 |     for element in trigger_elements:
 92 |         if label in element.text:
 93 |             # 确保元素可见并且可点击
 94 |             WebDriverWait(driver, 10).until(EC.element_to_be_clickable(element))
 95 |             element.click()  # 点击找到的元素
 96 |             found = True
 97 |             break
 98 |     print("found: ", found)
 99 |     # 如果在按钮中找到了文本，就不再继续下面的操作
100 |     if found:
101 |         return
102 |     try:
103 |         # 如果在按钮中没有找到文本，执行原来的下拉列表操作
104 |         trigger_selector = "//*[@id='wrap']/div[2]/div[1]/div/div[1]/div"
105 |         WebDriverWait(driver, 10).until(
106 |             EC.element_to_be_clickable((By.XPATH, trigger_selector))
107 |         ).click()  # 打开下拉菜单
108 | 
109 |         dropdown_selector = "ul.dropdown-expect-list"
110 |         WebDriverWait(driver, 10).until(
111 |             EC.visibility_of_element_located((By.CSS_SELECTOR, dropdown_selector))
112 |         )
113 | 
114 |         option_selector = f"//li[contains(text(), '{label}')]"
115 |         WebDriverWait(driver, 10).until(
116 |             EC.element_to_be_clickable((By.XPATH, option_selector))
117 |         ).click()  # 选择下拉菜单中的选项
118 |     except Exception as e:
119 |         print(f"An error occurred: {e}")
120 | 
121 | def get_job_description_by_index(index):
122 |     try:
123 |         job_selector = f"//*[@id='wrap']/div[2]/div[2]/div/div/div[1]/ul/li[{index}]"
124 |         job_element = driver.find_element(By.XPATH, job_selector)
125 |         job_element.click()
126 | 
127 |         description_selector = "//*[@id='wrap']/div[2]/div[2]/div/div/div[2]/div/div[2]/p"
128 |         WebDriverWait(driver, 10).until(
129 |             EC.presence_of_element_located((By.XPATH, description_selector))
130 |         )
131 |         job_description_element = driver.find_element(By.XPATH, description_selector)
132 |         return job_description_element.text
133 | 
134 |     except NoSuchElementException:
135 |         print(f"No job found at index {index}.")
136 |         return None
137 | 
138 | # Variables
139 | url = "https://www.zhipin.com/web/geek/job-recommend?ka=header-job-recommend"
140 | browser_type = BROSWER_TYPE
141 | 
142 | 
143 | 
144 | 


--------------------------------------------------------------------------------
/write_response.py:
--------------------------------------------------------------------------------
  1 | import json
  2 | import os
  3 | import time
  4 | from selenium.webdriver.support import expected_conditions as EC
  5 | 
  6 | import openai
  7 | from openai import AzureOpenAI as OpenAI
  8 | from selenium.webdriver import Keys
  9 | from selenium.webdriver.common.by import By
 10 | from selenium.webdriver.support.wait import WebDriverWait
 11 | from langchain_functions import get_text_chunks, get_vectorstore, read_resumes, should_use_langchain, generate_letter
 12 | 
 13 | import functions
 14 | import finding_jobs
 15 | from config import *
 16 | # Check OpenAI version compatibility
 17 | from packaging import version
 18 | from dotenv import load_dotenv
 19 | load_dotenv()
 20 | 
 21 | required_version = version.parse("1.1.1")
 22 | current_version = version.parse(openai.__version__)
 23 | 
 24 | 
 25 | os.environ["OPENAI_API_TYPE"] = "azure"
 26 | os.environ["OPENAI_API_VERSION"] = OPENAI_VERSION
 27 | os.environ["AZURE_OPENAI_ENDPOINT"] = OPENAI_BASE_URL
 28 | os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
 29 | 
 30 | if current_version < required_version:
 31 |   raise ValueError(
 32 |       f"Error: OpenAI version {openai.__version__} is less than the required version 1.1.1"
 33 |   )
 34 | else:
 35 |   print("OpenAI version is compatible.")
 36 | 
 37 | # Initialize OpenAI client
 38 | client = OpenAI(azure_deployment=OPENAI_DEPLOYMENT,api_key=OPENAI_API_KEY, api_version=OPENAI_VERSION, azure_endpoint=OPENAI_BASE_URL)
 39 | 
 40 | if not should_use_langchain():
 41 |     # Create or load assistant
 42 |     assistant_id = functions.create_assistant(
 43 |         client)  # this function comes from "functions.py"
 44 | 
 45 | def create_thread(client):
 46 |     # Function to create a new thread and return its ID
 47 |     try:
 48 |         response = client.beta.threads.create()  # No assistant_id needed
 49 |         thread_id = response.id
 50 |         return thread_id
 51 |     except Exception as e:
 52 |         print(f"Error creating thread: {e}")
 53 |         return None
 54 | 
 55 | 
 56 | def chat(user_input, assistant_id, thread_id=None):
 57 |     if thread_id is None:
 58 |         thread_id = create_thread(client)
 59 |         if thread_id is None:
 60 |             return json.dumps({"error": "Failed to create a new thread"})
 61 | 
 62 |     print(f"Received message: {user_input} in thread {thread_id}")
 63 | 
 64 |     # Run the Assistant
 65 |     try:
 66 |         # Add the user's message to the thread
 67 |         client.beta.threads.messages.create(
 68 |             thread_id=thread_id,
 69 |             role="user",
 70 |             content=user_input
 71 |         )
 72 | 
 73 |         # Start the Assistant Run
 74 |         run = client.beta.threads.runs.create(
 75 |             thread_id=thread_id,
 76 |             assistant_id=assistant_id
 77 |         )
 78 | 
 79 |         # Check if the Run requires action (function call)
 80 |         while True:
 81 |             run_status = client.beta.threads.runs.retrieve(
 82 |                 thread_id=thread_id,
 83 |                 run_id=run.id
 84 |             )
 85 | 
 86 |             if run_status.status == 'completed':
 87 |                 break
 88 |             elif run_status.status == 'requires_action':
 89 |                 # Here you can handle specific actions if your assistant requires them
 90 |                 # ...
 91 |                 time.sleep(1)  # Wait for a second before checking again
 92 | 
 93 |         # Retrieve and return the latest message from the assistant
 94 |         messages = client.beta.threads.messages.list(thread_id=thread_id)
 95 |         assistant_message = messages.data[0].content[0].text.value
 96 | 
 97 |         # 将换行符替换为一个空格
 98 |         formatted_message = assistant_message.replace("\n", " ")
 99 | 
100 |         # response_data = json.dumps({"response": assistant_message, "thread_id": thread_id})
101 |         return formatted_message
102 | 
103 |     except Exception as e:
104 |         print(f"An error occurred: {e}")
105 |         error_response = json.dumps({"error": str(e)})
106 |         return error_response
107 | 
108 | 
109 | def send_response_to_chat_box(driver, response):
110 |     # 定位聊天输入框
111 |     chat_box = driver.find_element(By.XPATH, "//*[@id='chat-input']")
112 | 
113 |     # 清除输入框中可能存在的任何文本
114 |     chat_box.clear()
115 | 
116 |     # 将响应粘贴到输入框
117 |     chat_box.send_keys(response)
118 |     time.sleep(3)
119 | 
120 |     # 模拟按下回车键来发送消息
121 |     chat_box.send_keys(Keys.ENTER)
122 |     time.sleep(1)
123 | 
124 | 
125 | 
126 | def send_response_and_go_back(driver, response):
127 |     # 调用函数发送响应
128 |     send_response_to_chat_box(driver, response)
129 | 
130 |     time.sleep(10)
131 |     # 返回到上一个页面
132 |     driver.back()
133 |     time.sleep(3)
134 | 
135 | def send_job_descriptions_to_chat(url, browser_type, label, assistant_id=None, vectorstore=None):
136 |     # 开始浏览并获取工作描述
137 |     finding_jobs.open_browser_with_options(url, browser_type)
138 |     finding_jobs.log_in()
139 |     print("Logged in successfully.")
140 |     job_index = 1  # 开始的索引
141 |     while True:
142 |         try:
143 |             # 获取 driver 实例
144 |             driver = finding_jobs.get_driver()
145 |             print("get driver success\n")
146 |             # 更改下拉列表选项
147 |             finding_jobs.select_dropdown_option(driver, label)
148 |             # 调用 finding_jobs.py 中的函数来获取描述
149 |             job_description = finding_jobs.get_job_description_by_index(job_index)
150 |             print("get job description success\n")
151 | 
152 |             if job_description:
153 |                 # 发送描述到聊天并打印响应
154 |                 if should_use_langchain():
155 |                     response = generate_letter(vectorstore, job_description)
156 |                 else:
157 |                     response = chat(job_description, assistant_id)
158 |                 print(response)
159 |                 time.sleep(1)
160 |                 # 点击沟通按钮
161 |                 contact_button = driver.find_element(By.XPATH, "//*[@id='wrap']/div[2]/div[2]/div/div/div[2]/div/div[1]/div[2]/a[2]")
162 |                 contact_button.click()
163 | 
164 |                 # 等待回复框出现
165 |                 xpath_locator_chat_box = "//*[@id='chat-input']"
166 |                 chat_box = WebDriverWait(driver, 10).until(
167 |                     EC.presence_of_element_located((By.XPATH, xpath_locator_chat_box))
168 |                 )
169 | 
170 |                 # 调用函数发送响应
171 |                 send_response_and_go_back(driver, response)
172 |                 print("send response success\n")
173 | 
174 | 
175 |             # 等待一定时间后处理下一个工作描述
176 |             time.sleep(3)
177 |             # job_index += 1
178 | 
179 |         except Exception as e:
180 |             print(f"An error occurred: {e}")
181 |             break
182 | 
183 | 
184 | if __name__ == '__main__':
185 |     url = "https://www.zhipin.com/web/geek/job-recommend?ka=header-job-recommend"
186 |     browser_type = BROSWER_TYPE
187 |     label = LABEL  # 想要选择的下拉菜单项
188 |     if should_use_langchain():
189 |         text = read_resumes()
190 |         print("read_resume success\n")
191 |         chunks = get_text_chunks(text)
192 |         print("get chunk success\n")
193 |         vectorstore = get_vectorstore(chunks)
194 |         print("get vectorstore success\n")
195 |         send_job_descriptions_to_chat(url, browser_type,label, vectorstore=vectorstore)
196 |     else:
197 |         assistant_id = functions.create_assistant(client)
198 |         send_job_descriptions_to_chat(url, browser_type,label, assistant_id=assistant_id)
199 | 
200 | 


--------------------------------------------------------------------------------