voice_macro/server.py at master · mattbui/voice_macro · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
from flask import render_template, Flask, redirect, request, jsonify
import sqlite3
import os
import sys
import argparse
from db import Database
from recorders import SoundRecorder, KeyboardRecorder
import training_service
from listener import Listener

app = Flask(__name__)
sound_recorder = SoundRecorder()
keyboard_recorder = KeyboardRecorder()
database = Database()

@app.route('/')
def index():
    global database
    sound_recorder.end()
    macros = database.get_all()
    return render_template('index.html', macros=macros)

@app.route('/new_macro_form')
def new_macro_form():
    global sound_recorder
    sound_recorder.start()
    return render_template('new_macro.html')

@app.route('/delete/<id>')
def delete(id=None):
    global listenter, database, args
    _, _, _, _, _, _, _, ke_path, model_path = database.get_macro(id)
    os.remove(ke_path)
    os.remove(model_path)
    database.delete_macro(id)
    try:
        listenter.stop()
    except Exception as e:
        pass
    if(len(database.get_all()) > 0):
        listenter = Listener(sensitivity=args.sensitivity, speed_factor=args.speed_factor)
        listenter.start()
    return redirect('/')

@app.route('/switch_sound_record')
def switch_sound_record():
    global sound_recorder
    return jsonify(sound_recorder.switch())

@app.route('/clear_cache', methods=["POST"])
def clear_cache():
    sound_1 = request.form.get("sound_1")
    sound_2 = request.form.get("sound_2")
    sound_3 = request.form.get("sound_3")
    keyboard_events_path = request.form.get("key_file")
    if(sound_1 != None and sound_1 != ""):
        try:
            os.remove(sound_1)
        except:
            pass
    if(sound_2 != None and sound_2 != ""):
        try:
            os.remove(sound_2)
        except:
            pass
    if(sound_3 != None and sound_3 != ""):
        try:
            os.remove(sound_3)
        except:
            pass
    if(keyboard_events_path != None and keyboard_events_path != ""):
        try:
            os.remove(keyboard_events_path)
        except:
            pass

    return jsonify({"message": "ok"})


@app.route('/keyboard_record', methods=["POST"])
def keyboard_record():
    global keyboard_recorder
    file = request.form.get("file")
    if(file != "" and file != None):
        os.remove(file)
    output_file, events_string = keyboard_recorder.start_record()
    return jsonify({"output_file": output_file, "events_string": events_string})

@app.route('/<id>')
def detail(id=None):
    global database
    macro = database.get_macro(id)
    return render_template("detail.html", macro=macro)

@app.route('/add_macro', methods=["POST"])
def add_macro():
    global database, listenter
    name = request.form.get("name")
    language = request.form.get("language")
    age_group = request.form.get("age")
    gender = request.form.get("gender")
    description = request.form.get("description")
    keyboard_events_path = request.form.get("key_file")
    event_strings = request.form.get("events_string")
    sound_1 = request.form.get("sound_1")
    sound_2 = request.form.get("sound_2")
    sound_3 = request.form.get("sound_3")

    ok, message = training_service.get_model(name, (sound_1, sound_2, sound_3), language, age_group, gender)
    if(not ok):
        return jsonify({"message": message})
    else:
        try:
            database.insert((name, language, age_group, gender, description, event_strings, keyboard_events_path, message))
            try:
                listenter.stop()
            except Exception as e:
                pass
            if(len(database.get_all()) > 0):
                listenter = Listener(sensitivity=args.sensitivity, speed_factor=args.speed_factor)
                listenter.start()
            return jsonify({"message": "ok"})
        except sqlite3.Error as e:
            return jsonify({"message": e.args[0]})

def parse_argument(argv):
    parser = argparse.ArgumentParser()

    parser.add_argument("--port", type=int, help="The port for the server run locally", default=8000)
    parser.add_argument("--sensitivity", type=float, help="Model sensitivity", default=0.35)
    parser.add_argument("--speed_factor", type=float, help="Keyboard speed factor playback", default=0)

    return parser.parse_args(argv)

args = parse_argument(sys.argv[1:])
if(len(database.get_all()) > 0):
    listenter = Listener(sensitivity=args.sensitivity, speed_factor=args.speed_factor)
    listenter.start()
app.run('0.0.0.0', args.port)
sound_recorder.end()
try:
    listenter.stop()
except:
    pass
database.close()