from multiprocessing import Process, Queue, freeze_support

import threading

import time

import os

import webbrowser

import random

import flask

import json

from newtkinter import DragWindow, center_windows

app = flask.Flask(__name__, static_url_path='')

pic_list = os.listdir(f'{os.getcwd()}{os.sep}static{os.sep}Pic')

del pic_list[pic_list.index('favicon.ico')]

pic_list = random.sample(pic_list, 10)

queue_box = []

var_box = []

new_queue_box = True

new_var_box = True

@app.route('/img', methods=['get'])

def get_img():

pic = pic_list[int(str(time.time())[-1])]

print(pic)

return pic

@app.route('/sent', methods=['get'])

def sent():

value = flask.request.args.get("message", '')

index = queue_box.index(flask.request.args.get("index", queue_box[0]))

queue_controller.put(value, index)

return 'success'

@app.route('/update')

def update():

global new_queue_box, new_var_box

must = flask.request.args.get("must", 'NO')

if must == 'must':

new_queue_box = True

new_var_box = True

repo = {'queue': queue_box, 'var': var_box}

if new_queue_box or new_var_box:

repo['status'] = 'YES'

else:

repo['status'] = "NO"

new_queue_box = False

new_var_box = False

return repo

def update_queue_box(queue_list):

global queue_box, new_queue_box

queue_box = queue_list

new_queue_box = True

def update_var_box(var_dict, var_from):

global var_box, new_var_box

var = []

for name in var_dict:

var.append(f'{name}[{var_from[name]}] : {var_dict[name]}')

var_box = var

new_var_box = True

class QueueController:

def __init__(self):

self.in_dict = {}

self.out_dict = {}

self.var_dict = {}

self.queue_list = []

self.var_from = {}

self.update_var = lambda x, y: None

self.update_queue = lambda x: None

self.run = False

self.stop_str = "__--$$stop_process$$--__"

def can_stop(self):

return len(self.out_dict) == 0

def __call__(self, *args, **kwargs):

self.run = True

def done():

while self.run:

stop_pid = []

old_var = list(self.var_dict.keys())

for out in self.out_dict:

output: Queue = self.out_dict[out]

if output.empty():

continue

dict_index = f'var_{len(self.var_dict)}'

get_out = output.get()

if get_out == self.stop_str:

stop_pid.append(out)

else:

self.var_dict[dict_index] = get_out

self.var_from[dict_index] = out

if old_var != list(self.var_dict.keys()):

self.update_var(self.var_dict, self.var_from)

if stop_pid:

for i in stop_pid:

del self.in_dict[i]

del self.out_dict[i]

self.queue_list = list(self.in_dict.keys())

self.update_queue(self.queue_list.copy())

t = threading.Thread(target=done)

t.setDaemon(True)

t.start()

return self

def stop(self):

self.run = False

def add_queue(self, inqueue, outqueue, name):

self.stop()

time.sleep(0.5)

self.in_dict[name] = inqueue

self.out_dict[name] = outqueue

self.queue_list = list(self.in_dict.keys())

self.update_queue(self.queue_list.copy())

self.update_var(self.var_dict, self.var_from)

def init(self, update_var, update_queue):

self.update_var = update_var

self.update_queue = update_queue

self.update_queue(list(self.in_dict.keys()))

self.update_var(self.var_dict, self.var_from)

def put(self, value: str, index):

name_space = self.var_dict.copy()

name_space.update(globals())

in_queue = self.in_dict[self.queue_list[index]]

if value.startswith('put_var '):

var_name = value[7:]

in_queue.put(self.var_dict.get(var_name))

elif value.startswith('put_eval '):

in_queue.put(eval(value[8:]), name_space)

elif value.startswith('put_file ') and value.startswith('.py'):

try:

with open(value[4:], 'r') as f:

code_file = f.read()

new_name_space = name_space

exec(code_file, new_name_space)

dict_index = f'var_{len(self.var_dict)}'

in_queue.put(list(new_name_space.keys()))

self.var_dict[dict_index] = new_name_space.copy()

self.var_from[dict_index] = 'self'

except BaseException as e:

in_queue.put(str(e))

else:

in_queue.put(value)

queue_controller = QueueController()

queue_controller.init(update_var_box, update_queue_box)

def progress_bar(func):

def run(*agrs, **kwargs):

in_queue, out_queue = func(*agrs, **kwargs)

pid = out_queue.get()

name = func.__name__

queue_controller.add_queue(in_queue, out_queue, f'{name}_{pid}')

queue_controller()

time.sleep(1)

return 'run success'

return run

def draftboard_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from draftboard import draw_main

out_queue.put('start')

# 不需要等待

draw_main(in_queue, out_queue)

@app.route('/communication')

def communication():

return app.send_static_file(r'Communication.html')

@app.route('/')

def hello():

return app.send_static_file('Hello.html')

@app.route('/draftboard')

def draftboard():

return draftboard_run()

@progress_bar

def draftboard_run():

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=draftboard_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def datascience_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from datascience import machine_learning

out_queue.put('start')

time.sleep(0.5)

machine_learning(in_queue, out_queue)

@app.route('/datascience')

def datascience():

return datascience_run()

@progress_bar

def datascience_run():

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=datascience_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def functionmapping_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from funcsystem.map import function_mapping

out_queue.put('start')

time.sleep(0.5)

function_mapping(in_queue, out_queue)

@app.route('/functionmapping')

def functionmapping():

return functionmapping_run()

@progress_bar

def functionmapping_run():

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=functionmapping_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def functionfactory_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from funcsystem.factory import function_factory_main

out_queue.put('start')

time.sleep(0.5)

function_factory_main(in_queue, out_queue)

@app.route('/functionfactory')

def functionfactory():

return functionfactory_run()

@progress_bar

def functionfactory_run():

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=functionfactory_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def algebraicfactory_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from algebraicfactory import algebraic_factory_main

out_queue.put('start')

time.sleep(0.5)

algebraic_factory_main(in_queue, out_queue)

@app.route('/algebraicfactory')

def algebraicfactory():

return algebraicfactory_run()

@progress_bar

def algebraicfactory_run():

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=algebraicfactory_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def machinelearner_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from machinelearning import machine_learning

out_queue.put('start')

time.sleep(0.5)

machine_learning(in_queue, out_queue)

@app.route('/machinelearner')

def machinelearner():

return machinelearner_run()

@progress_bar

def machinelearner_run():

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=machinelearner_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def git_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from gitrepo import git_main

out_queue.put('start')

time.sleep(0.5)

git_main(in_queue, out_queue)

@app.route('/git')

def git():

return git_run()

@progress_bar

def git_run():

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=git_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def crawler_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from crawler import crawler_main

out_queue.put('start')

time.sleep(0.5)

crawler_main(in_queue, out_queue)

@app.route('/crawler')

def crawler():

return crawler_run()

@progress_bar

def crawler_run():

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=crawler_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def system_main(in_queue, out_queue):

out_queue.put(str(os.getpid()))

from system.gui import system_main

out_queue.put('start')

time.sleep(0.5)

system_main(in_queue, out_queue)

@app.route('/system')

def system():

return system_run()

@progress_bar

def system_run(): # 不需要进度条

in_queue = Queue(10)

out_queue = Queue(10)

Process(target=system_main, args=(in_queue, out_queue)).start()

return in_queue, out_queue

def to_website():

t = threading.Thread(target=webbrowser.open, args=('https://cotan.songzh.website/',))

t.start()

if __name__ == "__main__":

freeze_support()

app.run()

一键复制

编辑

Web IDE

原始数据

按行查看

历史