mendunr_project/functions/solve_graph.py

from bs4 import BeautifulSoup
from configs.connections import create_or_get_node, relationship_exists, connect_graph, get_node
from openai import OpenAI
from py2neo import Relationship
import ast
import logging
logger = logging.getLogger(__name__)
from flask import current_app


api_key = "sk-86d4622141d74e9a8d7c38ee873c4d91"
base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
model_name = "qwen-turbo"


# 提取共有标签
def llm_client(content):
    try:
        if content is None or content == []:
            return []
        client = OpenAI(api_key=api_key, base_url=base_url, )
        response = client.chat.completions.create(
            model=model_name,
            messages=[
                {"role": "system", "content": "你是一个专业的人力资源经理，根据用户的提示提取标签"},
                {"role": "user",
                 "content": f"请提取以下内容的特征，精简概要，能够对所有求职者的特征进行概括的词语，并按顺序返回结果。输出是列表格式，最多返回5个标签。"
                            f"例如，如果输入是 '英语过了六级,两年以上iOS开发经验,沟通协商能力强,熟练使用Python,有项目管理经验'，"
                            f"输出应该是 ['英语六级', '2年iOS开发经验', '熟练使用Python', '项目管理经验']。"
                            f"不要使用宽泛的词语，如 '为企业着想'、'肯干'等类似的词语，只提取具体的、关键的特征能够描述大部分人的特征。"
                            f"根据不同的行业特点，提取最相关的特征。例如，对于技术岗位，关注技术技能；对于销售岗位，关注销售业绩和客户关系管理等。"
                            f"不要使用宽泛的词语，只提取具体的、关键的特征。内容如下：{content}"},
            ],
            max_tokens=1024,
            temperature=0.1,
            stream=False
        )
        result = response.choices[0].message.content
        temp = result.replace("'", '"')
        result = ast.literal_eval(temp)
        return result
    except Exception as e:
        current_app.logger.error(f'llm_client error: {e}')
        return []

def bs_data(data):
    try:
        soup = BeautifulSoup(data,'html.parser')
        text = soup.get_text()
        return text
    except Exception as e:
        current_app.logger.error(f'bs_data error: {e}')
        return ""


def create_job_dataList(dataList):
    try:
        '''
        拼接招聘要求文本，送给LLM，给出标签，建立关系
        :param dataList:
        :return:
        '''
        for item in dataList:
            value_list = [
                             item['type'],
                             item['expType'],
                             item['eduType'],
                             f"{item['payFrom']}到{item['payTo']}每{item['payUnit']}",
                         ] + item["tagList"]+llm_client(bs_data(item['content']+item['requirement']))

            # 招聘职位
            job = create_or_get_node('job', uniqueId=item['id'], name=item['name'])
            # 标签
            for label in value_list:
                all_label = create_or_get_node('jobLabel', name=label)

                if not relationship_exists(job, 'connection', all_label):
                    connection = Relationship(job, 'connection', all_label)
                    connect_graph.create(connection)
    except Exception as e:
        current_app.logger.error(f'create_job_dataList error: {e}')
        return str(e)


def create_enterprise_dataList(dataList):
    try:
        '''
        拼接招聘要求文本，送给LLM，给出标签，建立关系
        :param dataList:
        :return:
        '''
        for item in dataList:
            if item['businessResp'] is None:
                business_scope = []
            else:
                business_scope = item['businessResp']['businessScope'] \
                    if item['businessResp']['businessScope'] is not None else []
            value_list = [
                             item['financingStatus'],
                             item['scale'],
                             item['workTime'],
                         ] + item["welfareList"] if item['welfareList'] is not None else []\
                         + item["tagList"] if item['tagList'] is not None else [] \
                         +llm_client(item['introduce'] if item['introduce'] is not None else [])\
                         +llm_client(business_scope)

            # 招聘职位
            enterprise = create_or_get_node('enterprise', uniqueId=item['id'],
                                            name=item['name'],alias = item['anotherName'])
            # 标签
            for label in value_list:
                all_label = create_or_get_node('enterpriseLabel', name=label)

                if not relationship_exists(enterprise, 'connection', all_label):
                    connection = Relationship(enterprise, 'connection', all_label)
                    connect_graph.create(connection)
    except Exception as e:
        current_app.logger.error(f'create_enterprise_dataList error: {e}')
        return str(e)


# 全部新增
def create_seeker_dataList(dataList):
    try:
        '''
            拼接招聘要求文本，送给LLM，给出标签，建立关系
            :param dataList:
            :return:
        '''

        for item in dataList:
            if item['person'] is None:
                person_jobType = ''
                jobStatus = ''
                expType = ''
                eduType = ''
                advantage = ''
                sex = ''
            else:
                person_jobType = item['person'].get('jobType', '')
                jobStatus = item['person'].get('jobStatus',  '')
                expType = item['person'].get('expType',  '')
                eduType = item['person'].get('eduType', '')
                advantage = item['person'].get('advantage', '')
                sex = item['person'].get('sex', '')
            # 确保 advantage 是一个字符串
            advantage_str = advantage if isinstance(advantage, str) else (', '.join(advantage) if isinstance(advantage, list) else '')

            interestedList = item.get('interestedList', [])
            edu_list = item.get('eduList', [])
            workList = item.get('workList', [])
            projectList = item.get('projectList', [])
            trainList = item.get('trainList', [])

            data = []
            content_list = []
            for record in edu_list:
                content_list.append(record.get('content', ''))
                data.append(record.get('schoolName', ''))
                data.append(record.get('educationType', ''))
                data.append(record.get('educationSystemType', ''))
            for record in interestedList:
                data.append(record['jobType'])

            for record in workList:
                data.append(record.get('positionName', ''))
                content_list.append(record.get('content', ''))

            for record in projectList:
                data.append(record.get('name', ''))
                content_list.append(record.get('content', ''))

            for record in trainList:
                data.append(record.get('orgName', ''))
                data.append(record.get('course', ''))
                content_list.append(record.get('content', ''))
            content_list = [str(content) for content in content_list if content is not None]

            data.extend([str(label) for label in llm_client("\n".join(content_list)) if label is not None])

            advantage_labels = [str(label) for label in llm_client(advantage_str) if
                                label is not None] if advantage_str else []

            value_list = [
                             person_jobType,
                             jobStatus,
                             expType,
                             eduType,
                             sex
                         ]+ advantage_labels + data
            # 剔除value_list为空的值
            value_list = [x for x in value_list if x is not None and x != ""]

            # 求职者
            seeker = create_or_get_node('seeker', uniqueId=item['person']['userId'],
                                            name=item['person']['name'])

            # 标签
            for label in value_list:
                all_label = create_or_get_node('seekerLabel', name=label)

                if not relationship_exists(seeker, 'connection', all_label):
                    connection = Relationship(seeker, 'connection', all_label)
                    connect_graph.create(connection)

    except Exception as e:
        current_app.logger.error(f'create_seeker_dataList error: {e}')
        return str(e)

# 单个新增
def add_seeker_dataList(dataList):
    try:
         for record in dataList:
             seeker = create_or_get_node('seeker', uniqueId=record['userId'],
                                         name=record['name'])
             value_list = [
                 record['jobType'],
                 record['jobStatus'],
                 record['expType'],
                 record['eduType'],
                 record['sex']
             ] + llm_client( record['advantage'])

             # 标签
             for label in value_list:
                 all_label = create_or_get_node('seekerLabel', name=label)

                 if not relationship_exists(seeker, 'connection', all_label):
                     connection = Relationship(seeker, 'connection', all_label)

                     connect_graph.create(connection)
    except Exception as e:
        current_app.logger.error(f'add_seeker_dataList error: {e}')
        return str(e)


# 临时新增
def part_seeker_dataList(dataList):
    try:
         for record in dataList:
             seeker = create_or_get_node('seeker', uniqueId=record['person']['id'],
                                         name=record['person']['name'])
             value_list = [
                 record['person']['jobType'],
                 record['person']['jobStatus'],
                 record['person']['expType'],
                 record['person']['eduType'],
                 record['person']['sex']
             ] + llm_client(record['person']['advantage'])

             # 标签
             for label in value_list:
                 if label and label.strip():  # 检查标签是否非空且非空白字符串

                     all_label = create_or_get_node('seekerLabel', name=label)

                     if not relationship_exists(seeker, 'connection', all_label):
                         connection = Relationship(seeker, 'connection', all_label)
                         connect_graph.create(connection)
    except Exception as e:
        current_app.logger.error(f'add_seeker_dataList error: {e}')
        return str(e)

# 单个修改
def update_seeker_dataList(dataList):
    pass