[PYTHON] An Menschen, die "rekrutieren, aber nicht rekrutieren"

Import

abe.py

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

import os
import urllib.request
import json
import configparser
import codecs
import csv
import sys
import sqlite3
from collections import namedtuple
import types

COTOHA

abe.py

#/_/_/_/_/_/_/_/_/_/_/_/_/COTOHA_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#Der Code für diesen Teil stammt von hier.
# https://qiita.com/gossy5454/items/83072418fb0c5f3e269f

class CotohaApi:
    #Initialisieren
    def __init__(self, client_id, client_secret, developer_api_base_url, access_token_publish_url):
        self.client_id = client_id
        self.client_secret = client_secret
        self.developer_api_base_url = developer_api_base_url
        self.access_token_publish_url = access_token_publish_url
        self.getAccessToken()

    #Zugriffstoken erhalten
    def getAccessToken(self):
        #Zugriff auf die URL-Angabe für die Token-Erfassung
        url = self.access_token_publish_url

        #Header-Spezifikation
        headers={
            "Content-Type": "application/json;charset=UTF-8"
        }

        #Körperspezifikation anfordern
        data = {
            "grantType": "client_credentials",
            "clientId": self.client_id,
            "clientSecret": self.client_secret
        }
        #Codieren Sie die Anforderungshauptteilspezifikation in JSON
        data = json.dumps(data).encode()

        #Anforderungsgenerierung
        req = urllib.request.Request(url, data, headers)

        #Senden Sie eine Anfrage und erhalten Sie eine Antwort
        res = urllib.request.urlopen(req)

        #Antwortkörper erhalten
        res_body = res.read()

        #Dekodieren Sie den Antworttext von JSON
        res_body = json.loads(res_body)

        #Holen Sie sich das Zugriffstoken vom Antworttext
        self.access_token = res_body["access_token"]


    #Syntax-Parsing-API
    def parse(self, sentence):
        #Syntax-Parsing-API-URL-Spezifikation
        url = self.developer_api_base_url + "v1/parse"
        #Header-Spezifikation
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Körperspezifikation anfordern
        data = {
            "sentence": sentence
        }
        #Codieren Sie die Anforderungshauptteilspezifikation in JSON
        data = json.dumps(data).encode()
        #Anforderungsgenerierung
        req = urllib.request.Request(url, data, headers)
        #Senden Sie eine Anfrage und erhalten Sie eine Antwort
        try:
            res = urllib.request.urlopen(req)
        #Was tun, wenn in der Anforderung ein Fehler auftritt?
        except urllib.request.HTTPError as e:
            #Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
            else:
                print ("<Error> " + e.reason)

        #Antwortkörper erhalten
        res_body = res.read()
        #Dekodieren Sie den Antworttext von JSON
        res_body = json.loads(res_body)
        #Holen Sie sich das Analyseergebnis vom Antworttext
        return res_body


    #API zur Ähnlichkeitsberechnung
    def similarity(self, s1, s2):
        #API-URL-Spezifikation für die Ähnlichkeitsberechnung
        url = self.developer_api_base_url + "v1/similarity"
        #Header-Spezifikation
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Körperspezifikation anfordern
        data = {
            "s1": s1,
            "s2": s2
        }
        #Codieren Sie die Anforderungshauptteilspezifikation in JSON
        data = json.dumps(data).encode()
        #Anforderungsgenerierung
        req = urllib.request.Request(url, data, headers)
        #Senden Sie eine Anfrage und erhalten Sie eine Antwort
        try:
            res = urllib.request.urlopen(req)
        #Was tun, wenn in der Anforderung ein Fehler auftritt?
        except urllib.request.HTTPError as e:
            #Wenn der Statuscode 401 Unauthorized lautet, fordern Sie das Zugriffstoken erneut an und fordern Sie es erneut an
            if e.code == 401:
                print ("get access token")
                self.access_token = getAccessToken(self.client_id, self.client_secret)
                headers["Authorization"] = "Bearer " + self.access_token
                req = urllib.request.Request(url, data, headers)
                res = urllib.request.urlopen(req)
            #Wenn der Fehler nicht 401 ist, wird die Ursache angezeigt.
            else:
                print ("<Error> " + e.reason)

        #Antwortkörper erhalten
        res_body = res.read()
        #Dekodieren Sie den Antworttext von JSON
        res_body = json.loads(res_body)
        #Holen Sie sich das Analyseergebnis vom Antworttext
        return res_body

In Dauerverbindung umwandeln

abe.py

#/_/_/_/_/_/_/_/_/_/_/_/_/CONVERSION_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

def convert(word):
    file_name = "./data/Verb.csv"
    with open(file_name,"r") as f:
        handler = csv.reader(f)
        for row in handler:
            if word == row[10]: #Teiltexte Entdeckung
                if "Kontinuierliche Verbindung" in row[9]: #Nutzungsermittlung
                    return row[0]
    return None

Synonyme

abe.py

#/_/_/_/_/_/_/_/_/_/_/_/_/SYNONYM_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#Der Code für diesen Teil stammt von hier.
# https://www.yoheim.net/blog.php?q=20160201

conn = sqlite3.connect("./data/wnjpn.db")

Word = namedtuple('Word', 'wordid lang lemma pron pos')

def getWords(lemma):
  cur = conn.execute("select * from word where lemma=?", (lemma,))
  return [Word(*row) for row in cur]


Sense = namedtuple('Sense', 'synset wordid lang rank lexid freq src')

def getSenses(word):
  cur = conn.execute("select * from sense where wordid=?", (word.wordid,))
  return [Sense(*row) for row in cur]

Synset = namedtuple('Synset', 'synset pos name src')

def getSynset(synset):
  cur = conn.execute("select * from synset where synset=?", (synset,))
  return Synset(*cur.fetchone())

def getWordsFromSynset(synset, lang):
  cur = conn.execute("select word.* from sense, word where synset=? and word.lang=? and sense.wordid = word.wordid;", (synset,lang))
  return [Word(*row) for row in cur]

def getWordsFromSenses(sense, lang="jpn"):
  synonym = {}
  for s in sense:
    lemmas = []
    syns = getWordsFromSynset(s.synset, lang)
    for sy in syns:
      lemmas.append(sy.lemma)
    synonym[getSynset(s.synset).name] = lemmas
  return synonym

def getSynonym (word):
    synonym = {}
    words = getWords(word)
    if words:
        for w in words:
            sense = getSenses(w)
            s = getWordsFromSenses(sense)
            synonym = dict(list(synonym.items()) + list(s.items()))
    return synonym

Main

abe.py

#/_/_/_/_/_/_/_/_/_/_/_/_/MAIN_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
if __name__ == '__main__':
    #Rufen Sie den Speicherort der Quelldatei ab
    APP_ROOT = os.path.dirname(os.path.abspath( __file__)) + "/"

    #Stellen Sie den eingestellten Wert ein
    config = configparser.ConfigParser()
    config.read(APP_ROOT + "config.ini")
    CLIENT_ID = config.get("COTOHA API", "Developer Client id")
    CLIENT_SECRET = config.get("COTOHA API", "Developer Client secret")
    DEVELOPER_API_BASE_URL = config.get("COTOHA API", "Developer API Base URL")
    ACCESS_TOKEN_PUBLISH_URL = config.get("COTOHA API", "Access Token Publish URL")

    #COTOHA API-Instanziierung
    cotoha_api = CotohaApi(CLIENT_ID, CLIENT_SECRET, DEVELOPER_API_BASE_URL, ACCESS_TOKEN_PUBLISH_URL)

    #Analysezielsatz
    if len(sys.argv) >= 2:
        sentence = sys.argv[1]
    else:
        raise TypeError

    #Nehmen Sie ein Verb aus dem ursprünglichen Satz und konvertieren Sie es in eine kontinuierliche Formverbindung
    result = cotoha_api.parse(sentence)
    ret = ""
    verb = ""
    for chunk in result["result"]:
        for token in chunk["tokens"]:
            if token["pos"] == "Verbstamm":
                verb = token["lemma"]
                form = token["form"]
                conv_verb = convert(verb)
                if conv_verb==None:
                    ret += form
                else:
                    ret += conv_verb

                if ret[-1] == "Hmm":
                    ret += "Aber"
                else:
                    ret += "Ja aber"
                break
            else:
                ret += token["form"]

    #Nehmen Sie Synonyme für Verben
    synonym = getSynonym(verb)
    noun = ""
    sim = 0.

    #Extrahieren Sie Synonyme für die ähnlichste Nomenklatur
    for syns in synonym.values():
        for syn in syns:
            result = cotoha_api.parse(syn)['result'][0]['tokens'][0]
            if result['pos'] == 'Substantiv':
                cand = result['form']
                cand_sim = cotoha_api.similarity(sentence, cand+'Machen')['result']['score']
                if cand_sim > sim:
                    noun = result['form']
                    sim = cand_sim
    ret += noun
    ret += "Nicht durchgeführt"

    #Endgültige Ausgabe
    print(ret)

config.ini

config.ini

#Um die COTOHA-API zu verwenden, registrieren Sie sich bei der COTOHA-API, um ID und SECRET zu erhalten.
# config.Sie müssen eine INI-Datei erstellen.
# https://api.ce-cotoha.com/contents/index.html

[COTOHA API]
Developer API Base URL: https://api.ce-cotoha.com/api/dev/nlp/
Developer Client id: IDIDIDIDIDIDIDIDIDIDIDIDIDIDIDI
Developer Client secret: SECRETSECRETSECRETSECRET
Access Token Publish URL: https://api.ce-cotoha.com/v1/oauth/accesstokens

$ python abe.py "Übernachten Sie im Hotel"
Ich wohne im Hotel, aber ich bleibe nicht

$ python abe.py "beantworte die Fragen"
Beantwortete die Frage, aber nicht beantwortet

$ python abe.py "Nachts schlafen"
Ich schlafe nachts, aber ich schlafe nicht

$ python abe.py "Draußen laufen"
Ich gehe nach draußen, aber ich gehe nicht

$ python abe.py "Sehen Sie sich das Netz an"
Ich schaue ins Netz, habe es aber nicht überprüft

$ python abe.py "Fleisch kaufen"
Ich kaufe Fleisch, aber nicht

$ python abe.py "Verbrenne das Feuer"
Brennendes Feuer, aber nicht brennendes