Python: en red IDLE/Redo IDLE front-end al usar el mismo back-end?

Question

¿Existe alguna aplicación web que permita que varios usuarios trabajen con una sesión interactiva de tipo IDLE a la vez?

Algo así como:

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 

Si no es así, me gustaría crear una. ¿Hay algún módulo que pueda usar que simule una sesión interactiva? Me gustaría añadir una interfaz de la siguiente manera:

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 

(A pesar de que la última función sería más de una función extra.)

Formular mi problema de otra manera: Me gustaría crear un nuevo frente final para IDLE. ¿Cómo puedo hacer esto?

ACTUALIZACIÓN: O tal vez puedo simular IDLE a través de eval()?

ACTUALIZACIÓN 2: ¿Qué pasa si he hecho algo como esto:

• ya he establecido una sencilla aplicación de chat de GAE Python arriba, que permite a los usuarios iniciar sesión en, hacen que las salas de chat y chatear con El uno al otro.

• En lugar de simplemente guardar mensajes entrantes al almacén de datos, lo que podía hacer algo como esto:

---

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() 

El modelo InteractiveSession:

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() 

Podría este trabajo

, o estoy muy lejos/este enfoque es inviable/estoy duplicando el trabajo cuando debería usar algo ya construido?

ACTUALIZACIÓN 3: Además, supongo que consigo que todo lo demás funcione, me gustaría destacar la sintaxis. Idealmente, tendría una API o un servicio que podría utilizar para analizar el código y darle el estilo adecuado.

for c in "characters": 

se convertiría en:

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

¿Hay una buena herramienta de Python existente para hacer esto?

Answer 1

esto es posible con la próxima implementación de IPython usando un backend de 0MQ.

Answer 2

Como una prueba de concepto, es posible que pueda armar algo utilizando sockets y una sesión de línea de comandos.

Answer 3

Podría implementar algo así rápidamente en Nevow. Obviamente, el acceso debería ser bastante restringido, ya que hacer algo como esto implica permitir el acceso a una consola de Python a alguien a través de HTTP.

lo que he hecho es crear un widget de Athena para la consola, que utiliza una instancia de una subclase personalizada de code.InteractiveInterpreter que es común a todos los usuarios conectados

ACTUALIZACIÓN:. De acuerdo, por lo que tiene algo como chat en GAE. Si solo envía líneas a un código. Subclase interactiva interactiva que se ve así, debería funcionar para usted. Tenga en cuenta que la interfaz es muy similar a la clase InteractiveSession describes:

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

El intérprete de Python más cercano que conozco para lo que está buscando, en cuanto a la interfaz, es DreamPie. Tiene áreas de entrada y salida separadas, muy similar a una interfaz de chat. Además, DreamPie ejecuta todo el código en un subproceso. DreamPie también realiza la terminación y la coloración de sintaxis, al igual que IDLE, lo que significa que no solo canaliza la entrada y la salida hacia/desde el subproceso; ha implementado las abstracciones que está buscando.

Si desea desarrollar una aplicación de escritorio (no una aplicación web), le recomiendo basar su trabajo en DreamPie y simplemente agregar la funcionalidad de múltiples frontend.

Actualización: Para resaltar la sintaxis (incluido HTML) vea el proyecto Pygments. Pero esa es una pregunta completamente diferente; por favor haga una pregunta a la vez aquí.

Answer 5

Yo usaría ipython y screen. Con este método, debería crear un inicio de sesión compartido, pero ambos podrían conectarse a la sesión de pantalla compartida. Un inconveniente sería que ambos aparecerían como el mismo usuario.