Уничтожить поток, в котором запущено приложение Flask

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import itertools
import json
 
from flask import Flask, request, Response, g, _app_ctx_stack
import requests
from flask_jsonrpc import proxy
 
app = Flask(__name__)
app.config['PROPAGATE_EXCEPTIONS'] = True
 
def byte_gen():
    for i in itertools.cycle(range(256)):
        yield i
 
number = byte_gen()
 
def get_number():
    return next(number)
 
HEADER = {'ContentType': 'application/json'}
 
@app.route('/get-data', methods=['POST'])
def get():
    data = request.get_json()
 
    session = get_session()
    proxy = get_proxy()
 
    payload = {
         'jsonrpc': '2.0',
         'method': 'get',
         'params': {},
         'id': str(get_number())
     }
 
    # r = session.post('http://localhost:5001/api',
    #                  data=json.dumps(payload),
    #                  headers=HEADER)
 
    r = proxy.get(data['signals'])
 
    print r['result'][0]
 
    return Response(json.dumps(r['result'][0]), 200, HEADER)
 
@app.route('/set-data', methods=['POST'])
def set_():
    data = request.get_json()  # {"signal": "signal_name", "value": value}
 
    proxy = get_proxy()
 
    r = proxy.set(data['signal'], data['value'])
 
    print r
 
    return Response(json.dumps({'success': True}, 200, HEADER))
 
def get_session():
    """
    :rtype: requests.Session
    """
    if 'session' not in g:
        g.session = requests.Session()
    return g.session
 
@app.teardown_appcontext
def close_session(exception):
    session = g.pop('session', None)
    if session is not None:
        session.close()
 
def get_proxy():
    """
    :rtype: proxy.ServiceProxy
    """
    if 'proxy' not in g:
        g.proxy = proxy.ServiceProxy('http://localhost:5001/api')
    return g.proxy
 
@app.teardown_appcontext
def close_proxy(exception):
    g.pop('proxy', None)
 
if __name__ == '__main__':
    app.run()

import threading
import socket
import pickle
from datetime import datetime
from flask import Flask
# import jsonrpc
import flask_jsonrpc
from Tkinter import *
 
class Window(Tk):
    # GUI для имитации действий пользователя
 
    def __init__(self):
        Tk.__init__(self)
        self.status = 'stop'
        self.btntext = StringVar(value='Start')
        btn = Button(textvariable=self.btntext,
                     width=30, height=10, command=self.on_btn)
        btn.pack()
        self.protocol("WM_DELETE_WINDOW", self.on_closing)
 
    def on_closing(self):
        if self.status == 'start':
            _stop()
        self.destroy()
 
    def on_btn(self):
        if self.status == 'stop':
            _start()
            self.status = 'start'
            self.btntext.set('Stop')
        else:
            _stop()
            self.status = 'stop'
            self.btntext.set('Start')
 
 
def _start():
    print('Starting')
 
    class Thread(threading.Thread):
        # НЕ ИСПОЛЬЗУЕТСЯ
 
        def __init__(self, group=None, target=None, name=None,
                     args=(), kwargs=None, verbose=None):
            threading.Thread.__init__(self, group, target, name,
                                      args, kwargs, verbose)
 
        def set_app(self, value):
            self.app = value
 
        def set_jsonrpc(self, value):
            self.jsonrpc = value
 
    app = Flask(__name__)
    jsonrpc = flask_jsonrpc.JSONRPC(app, '/api')
 
    SocketThread = threading.Thread(target=threadProc,
                                    args=(app, jsonrpc),
                                    name='MyServer')
    SocketThread.start()
 
def _stop():
    print('Stopping')
 
    thread = None
    for th in threading.enumerate():
        if th.name == 'MyServer':
            thread = th
            break
 
    if thread is not None:
        thread.join()
 
RuntimeValues = {
    'z1_sw1': False,
    'z1_sw2': False,
    'z1_led': False
}
 
HEADER = {'ContentType': 'application/json'}
 
def threadProc(app, jsonrpc):
    """
    :param Flask app:
    :param flask_jsonrpc.JSONRPC jsonrpc:
    """
    @jsonrpc.method('get')
    def get(signals):
        dct = {}
        for signal in signals:
            value = RuntimeValues.get(signal, None)
            if value is not None:
                dct[signal] = value
 
        return (dct, 200, HEADER)
 
    @jsonrpc.method('set')
    def set_(signal, value):
        global RuntimeValues  # for test
        if signal in RuntimeValues:
            RuntimeValues[signal] = value
 
    # thread = threading.current_thread()
 
    app.run(port=5001)
 
if __name__ == '__main__':
    w = Window()
    w.mainloop()