[PYTHON] Aux personnes qui «recrutent mais ne recrutent pas»

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_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#Le code de cette partie est tiré d'ici.
# https://qiita.com/gossy5454/items/83072418fb0c5f3e269f

class CotohaApi:
    #Initialisation
    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()

    #Obtenez un jeton d'accès
    def getAccessToken(self):
        #Spécification d'URL d'acquisition de jeton d'accès
        url = self.access_token_publish_url

        #Spécification d'en-tête
        headers={
            "Content-Type": "application/json;charset=UTF-8"
        }

        #Demander les spécifications du corps
        data = {
            "grantType": "client_credentials",
            "clientId": self.client_id,
            "clientSecret": self.client_secret
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()

        #Demande de génération
        req = urllib.request.Request(url, data, headers)

        #Envoyez une demande et recevez une réponse
        res = urllib.request.urlopen(req)

        #Obtenir le corps de la réponse
        res_body = res.read()

        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)

        #Obtenir un jeton d'accès à partir du corps de la réponse
        self.access_token = res_body["access_token"]


    #API d'analyse syntaxique
    def parse(self, sentence):
        #Spécification de l'URL de l'API d'analyse syntaxique
        url = self.developer_api_base_url + "v1/parse"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "sentence": sentence
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            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)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body


    #API de calcul de similarité
    def similarity(self, s1, s2):
        #Spécification de l'URL de l'API de calcul de similarité
        url = self.developer_api_base_url + "v1/similarity"
        #Spécification d'en-tête
        headers={
            "Authorization": "Bearer " + self.access_token,
            "Content-Type": "application/json;charset=UTF-8",
        }
        #Demander les spécifications du corps
        data = {
            "s1": s1,
            "s2": s2
        }
        #Encoder la spécification du corps de la requête en JSON
        data = json.dumps(data).encode()
        #Demande de génération
        req = urllib.request.Request(url, data, headers)
        #Envoyez une demande et recevez une réponse
        try:
            res = urllib.request.urlopen(req)
        #Que faire si une erreur se produit dans la demande
        except urllib.request.HTTPError as e:
            #Si le code d'état est 401 Non autorisé, réacquérir le jeton d'accès et demander à nouveau
            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)
            #Si l'erreur est différente de 401, la cause est affichée.
            else:
                print ("<Error> " + e.reason)

        #Obtenir le corps de la réponse
        res_body = res.read()
        #Décoder le corps de la réponse à partir de JSON
        res_body = json.loads(res_body)
        #Obtenir le résultat de l'analyse à partir du corps de la réponse
        return res_body

Convertir en connexion continue

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]: #Découverte des paroles de la partie
                if "Connexion continue" in row[9]: #Découverte de l'utilisation
                    return row[0]
    return None

Synonymes

abe.py

#/_/_/_/_/_/_/_/_/_/_/_/_/SYNONYM_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#Le code de cette partie est tiré d'ici.
# 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__':
    #Obtenez l'emplacement du fichier source
    APP_ROOT = os.path.dirname(os.path.abspath( __file__)) + "/"

    #Obtenir la valeur définie
    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")

    #Instanciation de l'API COTOHA
    cotoha_api = CotohaApi(CLIENT_ID, CLIENT_SECRET, DEVELOPER_API_BASE_URL, ACCESS_TOKEN_PUBLISH_URL)

    #Déclaration à analyser
    if len(sys.argv) >= 2:
        sentence = sys.argv[1]
    else:
        raise TypeError

    #Prenez un verbe de la phrase originale et convertissez-le en une connexion de forme continue
    result = cotoha_api.parse(sentence)
    ret = ""
    verb = ""
    for chunk in result["result"]:
        for token in chunk["tokens"]:
            if token["pos"] == "Tronc de verbe":
                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 += "Mais"
                else:
                    ret += "Oui mais"
                break
            else:
                ret += token["form"]

    #Prendre des synonymes pour les verbes
    synonym = getSynonym(verb)
    noun = ""
    sim = 0.

    #Extraire les synonymes de la nomenclature la plus similaire
    for syns in synonym.values():
        for syn in syns:
            result = cotoha_api.parse(syn)['result'][0]['tokens'][0]
            if result['pos'] == 'nom':
                cand = result['form']
                cand_sim = cotoha_api.similarity(sentence, cand+'Faire')['result']['score']
                if cand_sim > sim:
                    noun = result['form']
                    sim = cand_sim
    ret += noun
    ret += "Pas fini"

    #Sortie finale
    print(ret)

config.ini

config.ini

#Pour utiliser l'API COTOHA, inscrivez-vous auprès de l'API COTOHA pour obtenir un ID et SECRET,
# config.Vous devez créer un fichier ini.
# 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 "boire de l'alcool"
Je bois, mais je ne le suis pas

$ python abe.py "Rentrer à la maison"
Je suis à la maison, mais je ne suis pas à la maison

$ python abe.py "Voir les fleurs de cerisier"
Je vois les fleurs de cerisier, mais je ne les ai pas vues

$ python abe.py "Manger des sushis"
Je mange des sushis, mais je ne mange pas

$ python abe.py "Invitez à la veille"
J'ai été invité à la veille, mais je ne l'ai pas fait.

$ python abe.py "Reste à l'hotel"
Je reste à l'hôtel, mais je ne reste pas

$ python abe.py "répondez aux questions"
A répondu à la question mais pas de réponse

$ python abe.py "Dormir la nuit"
Je dors la nuit, mais je ne dors pas

$ python abe.py "Faire un tour dehors"
Je marche dehors, mais je ne marche pas

$ python abe.py "Voir le net"
Je regarde le net, mais je n'ai pas vérifié

$ python abe.py "Acheter de la viande"
J'achète de la viande, mais pas

$ python abe.py "Brûle le feu"
Feu brûlant, mais pas brûlant

$ python sexy.py 'Je tiens une promesse'
J'ai dit que je tenais ma promesse, mais je la tenais.

$ python sexy.py 'Hospitalité aux étrangers'
J'ai dit que je recevais des étrangers, mais je leur souhaite la bienvenue.

$ python sexy.py 'Faites une pause dans l'entreprise'
J'ai dit que j'étais absent du travail, mais je me reposais.

$ python sexy.py 'Résoudre les problèmes environnementaux'
J'ai dit que je travaillais sur les questions environnementales, mais j'y suis confronté.

$ python sexy.py 'Détruire NHK'
J'ai dit que vous détruisez nhk, mais vous le détruisez.

Recommended Posts