Python: Vernetzte IDLE/Redo IDLE-Front-End bei Verwendung der gleichen Back-End?

Question

Gibt es eine vorhandene Webanwendung, mit der mehrere Benutzer gleichzeitig mit einer interaktiven IDLE-Sitzung arbeiten können?

Etwas wie:

IDLE 2.6.4 
Morgan: >>> letters = list("abcdefg") 
Morgan: >>> # now, how would you iterate over letters? 
Jack: >>> for char in letters: 
    print "char %s" % char 


char a 
char b 
char c 
char d 
char e 
char f 
char g 
Morgan: >>> # nice nice 

Wenn nicht, würde Ich mag zu erstellen. Kann ich ein Modul verwenden, das eine interaktive Sitzung simuliert? Ich würde eine Schnittstelle wie diese wollen:

def class InteractiveSession(): 
    ''' An interactive Python session ''' 

    def putLine(line): 
     ''' Evaluates line ''' 
     pass 

    def outputLines(): 
     ''' A list of all lines that have been output by the session ''' 
     pass 

    def currentVars(): 
     ''' A dictionary of currently defined variables and their values ''' 
     pass 

(Obwohl diese letzte Funktion würde eher ein Extra-Feature sein.)

Zu meinem Problem eine andere Art und Weise zu formulieren: Ich möchte eine neue Front schaffen Ende für IDLE. Wie kann ich das machen?

UPDATE: Oder kann ich IDLE über eval() simulieren?

UPDATE 2: Was passiert, wenn ich tat etwas wie folgt aus:

• Ich habe bereits eine einfache GAE Python Chat-Anwendung einrichten, die Benutzer sich anmelden, stellen Chaträume erlaubt, und chatten Sie mit gegenseitig.

---

def putLine(line, user, chat_room): 
''' Evaluates line for the session used by chat_room ''' 

# get the interactive session for this chat room 
curr_vars = InteractiveSession.objects.where("chatRoom = %s" % chat_room).get() 

result = eval(prepared_line, curr_vars.state, {}) 

curr_vars.state = curr_globals 

curr_vars.lines.append((user, line)) 
if result: 
    curr_vars.lines.append(('SELF', result.__str__())) 

curr_vars.put() 

Das InteractiveSession Modell:

def class InteractiveSession(db.Model): 


# a dictionary mapping variables to values 
    # it looks like GAE doesn't actually have a dictionary field, so what would be best to use here? 
    state = db.DictionaryProperty() 

    # a transcript of the session 
    # 
    # a list of tuples of the form (user, line_entered) 
    # 
    # looks something like: 
    # 
    # [('Morgan', '# hello'), 
    # ('Jack', 'x = []'), 
    # ('Morgan', 'x.append(1)'), 
    # ('Jack', 'x'), 
    # ('SELF', '[1]')] 
    lines = db.ListProperty() 

Könnte diese Arbeit,

Statt nur eingehende Nachrichten an den Datenspeicher zu speichern, ich etwas tun könnte oder bin ich weit weg/dieser Ansatz ist undurchführbar/Ich kopiere Arbeit, wenn ich etwas verwenden sollte, das bereits gebaut wurde?

UPDATE 3: Wenn ich alles andere funktioniere, würde ich gerne Syntax-Highlighting machen. Idealerweise hätte ich eine API oder einen Dienst, mit dem ich den Code analysieren und entsprechend formatieren könnte.

for c in "characters": 

würde:

<span class="keyword">for</span> <span class="var">c</span> <span class="keyword">in</span> <span class="string>"characters"</span><span class="punctuation">:</span> 

Gibt es ein gutes vorhandenes Python-Tool, dies zu tun?

Answer 1

Dies ist wahrscheinlich mit der bevorstehenden Implementierung von IPython mit einem 0MQ-Backend möglich.

Answer 2

Als Beweis des Konzepts können Sie möglicherweise etwas zusammenstellen, indem Sie Sockets und eine Befehlszeilensitzung verwenden.

Answer 3

Ich könnte etwas so schnell in Nevow implementieren. Offensichtlich muss der Zugriff ziemlich eingeschränkt sein, da das Ausführen von etwas wie das Zulassen des Zugriffs auf eine Python-Konsole für jemanden über HTTP bedeutet.

Was ich tun würde, ist ein Athena-Widget für die Konsole erstellen, die eine Instanz einer benutzerdefinierten Unterklasse von code.InteractiveInterpreter verwendet, die gemeinsam für alle Benutzer angemeldet

UPDATE. Okay, so haben Sie etwas Chat-wie in GAE. Wenn Sie nur Zeilen an eine code.InteractiveInterpreter-Unterklasse senden, die so aussieht, sollte es für Sie funktionieren. Beachten Sie, dass die Schnittstelle zum InteractiveSession Klasse ziemlich ähnlich ist, die Sie beschreiben:

class SharedConsole(code.InteractiveInterpreter): 
    def __init__(self): 
     self.users = [] 

    def write(self, data): 
     # broadcast output to connected clients here 
     for user in self.users: 
      user.addOutput(data) 

class ConnectedUser(object): 
    def __init__(self, sharedConsole): 
     self.sharedConsole = sharedConsole 
     sharedConsole.users.append(self) # reference look, should use weak refs 

    def addOutput(self, data): 
     pass # do GAE magic to send data to connected client 

    # this is a hook for submitted code lines; call it from GAE when a user submits code 
    def gotCommand(self, command): 
     needsMore = self.sharedConsole.runsource(command) 
     if needsMore: 
      pass # tell the client to change the command line to a textarea 
       # or otherwise add more lines of code to complete the statement 

Answer 4

Der nächste Python-Interpreter ich kenne, was Sie suchen, in Bezug auf die Schnittstelle, DreamPie ist. Es hat separate Eingabe- und Ausgabebereiche, ähnlich wie eine Chat-Schnittstelle. Außerdem führt DreamPie den gesamten Code in einem Subprozess aus. DreamPie macht auch die Vervollständigung und Syntax-Färbung, ähnlich wie IDLE, was bedeutet, dass es nicht nur Eingabe und Ausgabe zum/vom Subprozess pipe - es hat die Abstraktionen, die Sie suchen, implementiert.

Wenn Sie eine Desktop-Anwendung (keine Web-App) entwickeln möchten, empfehle ich, Ihre Arbeit auf DreamPie zu gründen und nur die Multiple-Frontend-Funktionalität hinzuzufügen.

Update: Für Syntaxhervorhebung (einschließlich HTML) siehe Pygments Projekt. Aber das ist eine ganz andere Frage. Bitte stelle eine Frage auf einmal hier.

Answer 5

Ich würde ipython und screen verwenden. Bei dieser Methode müssten Sie eine gemeinsame Anmeldung erstellen, aber Sie könnten sich beide mit der freigegebenen Bildschirmsitzung verbinden. Ein Nachteil wäre, dass Sie beide als derselbe Benutzer erscheinen würden.