Was | Python Fiddle

#!python3
# Copyright (c) Matthew Tolbert 2015.
# This program is free software; you may freely distrubute & modify this softare according to the terms of the GNU GPLv3

#NOTE!!! This program not to be run.
#In progress

class WebSocket (object):
    def __init__ (self, name):
        self.name = name
        self.ws = Ws()
class WS (WebSocket):
    pass
class Response (WebSocket):
    pass
class Res (Response):
    pass
class Ws (object):
    def __init__ (self):
        self.__toSend = []
        self.__toRecieve = []
        self.socket = None
    def send (self, what):
        self.__toSend.append(what)
    def recieve (self):
        recieved = list(self.__toRecieve)
        self.__toRecieve = []
        return recieved
    def doSocket (self, ordered, from_was=False):
        if not from_was is True:
            raise WasNotAllowedError(0, "You're not allowed to do the socket.  Please wait for the event loop to come around.", True)
        else:
            if ordered:
                self.__doRecieve()
                self.__doRecieve(True)
            else:
                from multiprocessing import Process
                Process(target=Ws.__doRecieve, args=(self,)).start()
                Process(target=Ws.__doSend, args=(self, False)).start()
    def __doRecieve (self):
        data = self.socket.recv()
        if data:
            self.__toRecieve.append(data)
    def __doSend (self, ordered):
        sent = list(self.__toSend)
        self.__toSend = []
        if sent:
            if ordered:
                for i in sent:
                    self.socket.send(sent[i])
            else:
                from multiprocessing import Process
                for i in sent:
                    Process(target=lambda self what: self.socket.send(what), args=(self, sent[i]))
class WebSocketException (Exception):
    def __init__ (self, errno, desc=None, from_was=False):
        if !from_was is False:
            self.__doNotAllowed()
            self = None
        else:
            self.errno = errno
            self.__is_desc = None
            if desc is None:
                self.__is_desc = False
            else:
                self.__is_desc = True
                self.__desc = desc
    def __str__ (self):
        out = "Was Error No. {errno}".format(errno=self.errno)
        if self.__is_desc:
            out += self.__desc
        else:
            out += "."
        return out
    def __int__ (self):
        return self.errno
    @property
    def desc (self):
        if self.__is_desc:
            return self.__desc
        else:
            raise ImpossibleWasException("There's no description for this exception.", True)
    def __doNotAllowed (self):
        raise WasNotAllowedException(1, "You're not allowed to create an instance of the WebSocketException class.", True)
class WasNotAllowedException (WebSocketException):
    def __doNotAllowed (self):
        raise WasNotAllowedException(2, "You're not allowed to create an instance of the WasNotAllowedException class.", True)
class SocketStore (object):
    def __init__ (self, from_was=False):
        if from_was is True:
            self.__id_Ws = []
            self.__name_id = {}
        else:
            raise WasNotAllowedException(3, "You're not allowed to make a socket store.", True)
    def recievebyName(self, name):
        return self.__id_Ws[self.__name_id[name]].recieve()
    def deleteByName (self, name):
        self.__id_Ws[self.__name_id[name]].socket.close()
        self.__id_Ws.remove(self.__name_id[name])
        self.__name_id.remove(name)
    def sendInfoByName (self, name, what):
        self.__id_Ws[self.__name_id[name]].send(what)
    def addWsObjectToStore (self, name, obj):
        self.__id_Ws.append(obj)
        for item in self.__id_Ws.items():
            if item[1] is obj:
                self.__name_id[name] = item[0]
                return item[0]
    def addSocketToWsObjectById (sef, id, socket, from_was=False):
        if from_was is True:
            self.__id_Ws[id].socket = socket
        else:
            raise WasNotAllowedException(4, "You're not allowed to add a socket to a Ws object.", True)
    def doSocket (self, ordered, from_was=False):
        if from_was is True:
            if ordered is False:
                from multiprocessing import Process
                for item in self.__id_Ws:
                    Process(target=Ws.doSocket, args=(item, ordered, True)).start()
            else:
                item.doSocket(ordered, True)
        else:
            raise WasNotAllowedException(0, "You're not allowed to do the socket.", True)
class Was (object):
    def __init__ (self, ordered=False):
        self.__socket_store = SocketStore()
        self.__routes = []
        self.__deafault = None
        self.ordered = ordered
        self.running = False
    def deleteWebSocket (self, name):
        self.__socket_store.deleteByName(name)
    def sendInfoThroughWebSocket (self, name, what):
        self.__socket_store.sendInfoByName(name, what)
    def recieveInfoFromWebSocket (self, name):
        info = self.__socket_store.recievebyName(name)
        def generator ():
            while len(info) != 0:
                yield info.pop(-1)
        return generator
    def route (self, path):
        def doRoute (func):
            self.__routes[path] = func
            return lambda: None
        return doRoute
    def run (self, address='0.0.0.0', port=9999, blocking=False, tcp=True, queue_size=5):
        if blocking:
            self.__doRun((str(address), int(port)), tcp, queue_size)
        else:
            from multiprocessing import Process
            Process(target=Was.__doRun, args=(self, (str(address), int(port)), tcp, queue_size)).start()
    def __doRun (self, address, tcp, queue_size):
        #Coming soon!

Python Fiddle

Python Cloud IDE