Веб-сервис (flask)

import Pyro4
import Pyro4.core
import Pyro4.socketutil
import serpent
 
datafiles = {}  # temporary files
datablobs = {}  # in-memory
 
@Pyro4.expose
class FileServer(object):
 
    def open_file(self, fname):
        self.file = open(os.path.join(PROJECT_DIR, fname), 'wb')
        print('File "{0}" open for writing. Receiving data ...'.format(self.file.name))
        # self.write_to_log('File "{0}" open for writing. Receiving data ...'.format(self.file.name))
 
    def close_file(self):
        self.file.close()
        print('File "{0}" closed for writing.'.format(self.file.name))
        # self.write_to_log('File "{0}" closed for writing.'.format(self.file.name))
 
    def recv_data(self, data):
        data = serpent.tobytes(data)
        print('{0} data bytes received.'.format(len(data)))
        self.file.write(data)
        # self.write_to_log('{0} data bytes received.'.format(len(data)))
 
# из примеров в документации
class FileServerDaemon(Pyro4.core.Daemon):
    def __init__(self, host=None, port=0):
        super(FileServerDaemon, self).__init__(host, port)
        host, _ = self.transportServer.sock.getsockname()
        self.blobsocket = Pyro4.socketutil.createSocket(bind=(host, 0), timeout=Pyro4.config.COMMTIMEOUT, nodelay=False)
        print("Blob socket available on:", self.blobsocket.getsockname())
 
    def close(self):
        self.blobsocket.close()
        super(FileServerDaemon, self).close()
 
    def requestLoop(self, loopCondition=lambda: True):
        while loopCondition:
            rs = [self.blobsocket]
            rs.extend(self.sockets)
            rs, _, _ = select.select(rs, [], [], 3)
            daemon_events = []
            for sock in rs:
                if sock in self.sockets:
                    daemon_events.append(sock)
                elif sock is self.blobsocket:
                    self.handle_blob_connect(sock)
            if daemon_events:
                self.events(daemon_events)
 
    def handle_blob_connect(self, sock):
        csock, caddr = sock.accept()
        thread = threading.Thread(target=self.blob_client, args=(csock,))
        thread.daemon = True
        thread.start()
 
    def blob_client(self, csock):
        file_id = Pyro4.socketutil.receiveData(csock, 36).decode()
        print("{0} requesting file id {1}".format(csock.getpeername(), file_id))
        is_file, data = self.find_blob_data(file_id)
        if is_file:
            if hasattr(os, "sendfile"):
                print("...from file using sendfile()")
                out_fn = csock.fileno()
                in_fn = data.fileno()
                sent = 1
                offset = 0
                while sent:
                    sent = os.sendfile(out_fn, in_fn, offset, 512000)
                    offset += sent
            else:
                print("...from file using plain old read(); your os doesn't have sendfile()")
                while True:
                    chunk = data.read(512000)
                    if not chunk:
                        break
                    csock.sendall(chunk)
        else:
            print("...from memory")
            csock.sendall(data)
        csock.close()
 
    def find_blob_data(self, file_id):
        if file_id in datablobs:
            return False, datablobs.pop(file_id)
        elif file_id in datafiles:
            return True, datafiles.pop(file_id)
        else:
            raise KeyError("no data for given id")
 
with FileServerDaemon(host=given_ip, port=9090) as daemon:
    uri = daemon.register(FileServer, "server")
    print("Filetransfer server URI:", uri)
    daemon.requestLoop()

import os
import Pyro4
import Pyro4.errors
 
 
class FileClient:
 
    def __init__(self, ip):
        uri = "PYRO:server@{0}:9090".format(ip)
        self.pyro = Pyro4.core.Proxy(uri)
        self.connect = False
        self.status_send_data = False
 
    def set_pyro(self, ip):
        """
        Обновить uri и, соответственно, Proxy, если пользователь изменил ip
        """
        uri = "PYRO:server@{0}:9090".format(ip)
        self.pyro = Pyro4.core.Proxy(uri)
 
    def check_connect(self):
        """
        Проверка соединения с сервером.
        """
        with self.pyro as p:
            try:
                p._pyroBind()
                self.connect = True
            except Pyro4.errors.CommunicationError:
                self.connect = False
 
    def send_data(self, files):
        """
        Отправить файлы из списка files.
        """
        with self.pyro as p:
            try:
                for file in files:
                    p.open_file(os.path.basename(file))
                    with open(file, 'rb') as f:
                        data = f.read(1024)
                        while data:
                            p.recv_data(data)
                            data = f.read(1024)
                    p.close_file()
                self.status_send_data = True
            except:
                self.status_send_data = False

fc = FileClient(ip)
 
wait = wx.BusyInfo("Идет проверка соединения. Пожалуйста, подождите...")
fc.check_connect()
del wait
 
if not fc.connect:
    # обработка   
    pass
else:
    wait = wx.BusyInfo("Идет отправка данных. Пожалуйста, подождите...")
    fc.send_data(files)
    del wait
    if fc.status_send_data:
        print('ok')
    else:
        print('ne ok')