Ich benutze MYSQL. Dieses Mal wird Mr.Children im Voraus als Künstlerinformation registriert.

create database sakurai;

create table artist
  (artist_id smallint auto_increment not null primary key,
  artist_name varchar(100));

insert into artist (artist_name) values('Mr.Children');

create table title
  (title_id smallint auto_increment not null primary key,
  title varchar(100),
  artist_id smallint);
 
create table lyric
 (title_id smallint,
  phrase_id int auto_increment not null primary key,
  phrase varchar(1000),
  score float,
  sentiment tinyint);

sakuraisan.py

# -*- coding: utf-8 -*-

import random, requests, json, sys, time
import urllib.request
import mysql.connector as mydb
import pandas as pd

from bs4 import BeautifulSoup

ARTIST_ID = 1 #Künstlerausweis im Voraus in der DB registriert
AGENT_NAME = 'Sakurai' #Der Name des Agenten, der antwortet

#COTOHA API-Klasse
class CotohaApi():
    def __init__(self):
        self.COTOHA_ACCESS_INFO = {
            "grantType": "client_credentials",
            "clientId": "<Ihre Kunden-ID>",
            "clientSecret": "<Ihr eigenes Kundengeheimnis>"
        }
        self.ACCESS_TOKEN_PUBLISH_URL = '<Ihre Zugriffstoken-Veröffentlichungs-URL>'
        self.BASE_URL = '<Ihre API-Basis-URL'

        self.ACCESS_TOKEN = self.get_access_token()

    #Zugriffstoken erhalten
    def get_access_token(self):
        headers = {
            "Content-Type": "application/json;charset=UTF-8"
        }
        access_data = json.dumps(self.COTOHA_ACCESS_INFO).encode()
        request_data = urllib.request.Request(self.ACCESS_TOKEN_PUBLISH_URL, access_data, headers)
        token_body = urllib.request.urlopen(request_data)
        token_body = json.loads(token_body.read())
        self.access_token = token_body["access_token"]
        self.headers = {
            'Content-Type': 'application/json;charset=UTF-8',
            'Authorization': 'Bearer {}'.format(self.access_token)
        }

    #Implementierte Emotionsanalyse-API und zurückgegebene Analyseergebnisse
    def sentiment_analysis(self, text):
        request_body = {
            'sentence': text
        }
        url = self.BASE_URL + 'nlp/v1/sentiment'
        text_data = json.dumps(request_body).encode()
        request_data = urllib.request.Request(url, text_data, headers=self.headers, method='POST')
        sentiment_result = urllib.request.urlopen(request_data)
        sentiment_result = json.loads(sentiment_result.read())
        return sentiment_result

    # Positive:1, Negative:-1, Neutral:In 0 konvertieren
    def convert_sentiment(self, sentiment_in_word):
        if sentiment_in_word == 'Positive':
            return 1
        elif sentiment_in_word == 'Neutral':
            return 0
        elif sentiment_in_word == 'Negative':
            return -1

#DB-Operationsklasse
class DBHandler():
    def __init__(self):
        self.conn = mydb.connect(
            host = '<DB-Hostname>',
            port = '<DB-Portnummer>',
            user = '<DB-Benutzername>',
            password = '<DB-Passwort>',
            database = '<DB-Name>',
            charset='utf8'
        )

        self.conn.ping(reconnect=True)
        self.cur = self.conn.cursor()

#Datenkonstruktionsklasse
class Learn():
    def __init__(self):
        self.FILE_NAME = 'list.csv'
        self.ARTIST_NUMBER = '684' #Uta Net Artist No..（Mr.Kinder 684)
        self.MAX_PAGE = 2 #Anzahl der Seiten der Songliste der Songnetzkünstler (Mr..Kinder haben 2 Seiten)

    #Sammle Texte aus dem Songnetz
    def gather_lyric(self):
        #Erstellen Sie eine Tabelle mit den Scraped-Daten
        list_df = pd.DataFrame(columns=['Song Titel', 'Text'])

        for page in range(1, self.MAX_PAGE + 1):
            #Top-Adresse der Song-Seite
            base_url = 'https://www.uta-net.com'

            #Textliste Seite
            url = 'https://www.uta-net.com/artist/' + self.ARTIST_NUMBER + '/0/' + str(page) + '/'
            response = requests.get(url)
            soup = BeautifulSoup(response.text, 'lxml')
            links = soup.find_all('td', class_='side td1')

            for link in links:
                a = base_url + (link.a.get('href'))

                #Lyrics Detail Seite
                response = requests.get(a)
                soup = BeautifulSoup(response.text, 'lxml')
                title = soup.find('h2').text
                print(title)
                song_lyrics = soup.find('div', itemprop='text')
                
                for lyric in song_lyrics.find_all("br"):
                    lyric.replace_with('\n')
                song_lyric = song_lyrics.text

                #Warten Sie 1 Sekunde, bis der Server nicht geladen ist
                time.sleep(1)

                #Fügen Sie die erworbenen Texte zur Tabelle hinzu
                tmp_se = pd.DataFrame([title, song_lyric], index=list_df.columns).T
                list_df = list_df.append(tmp_se)

        #CSV speichern
        list_df.to_csv(self.FILE_NAME, mode = 'a', encoding='utf8')

    #Teilen Sie die Texte in Phrasen und registrieren Sie die Daten einschließlich der Ergebnisse der Emotionsanalyse in der DB
    def add_lyric(self):
        db = DBHandler()
        df_file = pd.read_csv(self.FILE_NAME, encoding='utf8')
        song_titles = df_file['Song Titel'].tolist()
        song_lyrics = df_file['Text'].tolist()
        
        #Hinweis: Wenn viele Songs vorhanden sind, wird die Obergrenze der API erreicht, die in COTOHA pro Tag ausgeführt werden kann (ca. 100 Songs pro Tag sind Richtwerte).
        for i in range(len(song_titles)):

            #Titel hinzufügen
            title = song_titles[i]

            print("Info: Saving {}...".format(title), end="")
            db.cur.execute(
                """
                insert into title (title, artist_id)
                values (%s, %s);
                """,
                (title, ARTIST_ID)
            )
            db.conn.commit()
            db.cur.execute(
                """
                select title_id from title
                where title= %s
                and artist_id = %s;
                """,
                (title, ARTIST_ID)
            )
            title_id = db.cur.fetchall()[-1][0]

            #Registrieren Sie das Ergebnis der Emotionsanalyse der Textphrase
            #Phrasenbegrenzer, wenn zwei Zeilenumbrüche angezeigt werden
            lyric = song_lyrics[i]
            lyric_phrases = lyric.split('\n\n')
            lyric_phrases = [lyric.replace('\u3000', ' ').replace('\n', ' ') for lyric in lyric_phrases]
            
            #Verwenden Sie die Emotionsanalyse-API für jede Phrase und registrieren Sie die Ergebnisse der Emotionsanalyse in der Datenbank
            cotoha_api= CotohaApi()
            for phrase in lyric_phrases:
                sentiment_result = cotoha_api.sentiment_analysis(phrase)['result']
                sentiment = cotoha_api.convert_sentiment(sentiment_result['sentiment'])
                score = sentiment_result['score']
                
                db.cur.execute(
                    """
                    insert into lyric (title_id, score, sentiment, phrase)
                    values (%s, %s, %s, %s);
                    """,
                    (title_id, score, sentiment, phrase)
                )
                db.conn.commit()

            print("Done")
                
        db.conn.close()
        if db.conn.is_connected() == False:
            print("Info: DB Disonnected")

    def execute(self):
        print("Info:Texte sammeln...")
        self.gather_lyric()
        print("Info:Hinzufügen von Texten zur DB...")
        self.add_lyric()

#Phrasensuchklasse
class Search():
    def __init__(self):
        self.SEARCH_SCOPE = [0.01, 0.1, 0.3] #Breite der zu suchenden Punktzahl SCORE ± SEARCH_Suchen Sie in der Reihenfolge der Liste im Bereich von SCOPE

    def execute(self):
        print("Sie:", end="")
        input_data = input()
        print("{}：".format(AGENT_NAME), end="")
        
        cotoha_api= CotohaApi()
        sentiment_result = cotoha_api.sentiment_analysis(input_data)['result']
        sentiment = cotoha_api.convert_sentiment(sentiment_result['sentiment'])
        score = sentiment_result['score']
        
        db = DBHandler()

        find_flag = 0
        #Suchen Sie nach Phrasen mit ähnlichen Ergebnissen, während Sie den Suchbereich schrittweise erweitern
        for scope in self.SEARCH_SCOPE:

            #Bestätigen Sie, dass mindestens einer vorhanden ist
            db.cur.execute(
                """
                select count(phrase_id) from lyric
                join title on lyric.title_id = title.title_id
                where sentiment = %s
                and score between %s and %s
                and artist_id = %s;
                """,
                (sentiment, score-scope, score+scope, ARTIST_ID)
            )
            hit_num = db.cur.fetchall()[-1][0]
            if hit_num > 0:
                find_flag = 1
                break
        
        #Wenn es nur ein Suchergebnis gibt, rufen Sie das Suchergebnis ab und antworten Sie dem Kunden
        if find_flag == 1:
            db.cur.execute(
                """
                select phrase,title from lyric
                join title on lyric.title_id = title.title_id
                where sentiment = %s
                and score between %s and %s
                and artist_id = %s;
                """,
                (sentiment, score-scope, score+scope, ARTIST_ID)
            )
            search_result = db.cur.fetchall()
            phrase_chosen = random.choice(search_result)
            print("{} [{}]".format(phrase_chosen[0], phrase_chosen[1]))
        else:
            print("Ich konnte keine guten Texte finden.")
        
        db.conn.close()
        

if __name__ == "__main__":
    args = sys.argv
    if len(args) == 2:
        process = args[1] #Befehlszeilenargument lernen:Songtexte in DB registrieren, suchen:Extrahieren Sie ähnliche emotionale Sätze aus der DB
        if process == 'search':
            searcher = Search()
            searcher.execute()
        elif process == 'learn':
            learner = Learn()
            learner.execute()
        else:
            print("Error:Geben Sie ein Befehlszeilenargument an[learn/search]")
    else:
        print("Error:Geben Sie ein Befehlszeilenargument an[learn/search]")

Es gibt zwei Möglichkeiten, es auszuführen.

• Beim Erstellen von Daten

python sakuraisan.py learn

• Bei der Suche nach Phrasen

python sakuraisan.py search