inspected console

[castironpi]

Presents a console permitting inspection. Input as well as output
saved in Python-readable form.
Python 2.5.1 memoryconsole4. py logging to My Documents\conso le.log

>>class A:

.... def f( self ):
.... print 2
....

>>a=A()
import inspect
inspect.getso urce( a.f )

'\tdef f( self ):\n\t\tprint 2\n'

This enabled by a log file, optionally set to console.log. Contents
are:

#Mon May 07 2007 06:33:42 PM Python win32 2.5.1 in memoryconsole4. py
class A:
def f( self ):
print 2

a=A()
import inspect
inspect.getsour ce( a.f )
#fb: '\tdef f( self ):\n\t\tprint 2\n'

Line 10 Microsoft Win32 convenience binding; line 49 a little
confusing. Give it a shot.

from code import InteractiveCons ole
import sys
from os import environ
from datetime import datetime
from StringIO import StringIO
from re import sub
from os.path import join,split,absp ath

class LoggedStdOut(St ringIO):
deflog= environ['USERPROFILE']+\
'\\My Documents\\cons ole.log'
def __init__( self, log=None ):
StringIO.__init __( self )
self.stdout= None
self.trip,self. head= True,''
self.logname= log or LoggedStdOut.de flog
self.prettyname =join(split(spl it(abspath(
self.logname))[0])[1],split(abspath( self.logname))[1])
for x,_ in enumerate( open( self.logname,'r ' ) ): continue
self._lineno= x #can use linecache
self._log= open( self.logname,'a ' )
def catch( self,head='#fb: ' ):
self.stdout= sys.stdout
sys.stdout= self
self.head= head
self.trip= True
def throw( self ):
sys.stdout= self.stdout
self.stdout= None
def getlineno( self ):
return self._lineno
def logwrite( self, data ):
self._log.write ( data )
self._lineno+= data.count('\n' )
def logflush( self ):
self._log.flush ()
def write( self, data ):
datal= sub( '\n([^$])','\n%s\\1'%se lf.head,data )
if self.trip: self.logwrite( self.head )
self.logwrite( datal )
self.trip= data.endswith(' \n')
return self.stdout.wri te( data )
def writelines( self, data ):
raise 'Branch uncoded'

class LoggedInteracti veConsole(Inter activeConsole):
def __init__( self,log=None,l ocals=None,file name=None ):
self.out= LoggedStdOut( log )
if filename is None: filename= split(self.out. logname)[1]
InteractiveCons ole.__init__( self,locals,fil ename )
self.locals.upd ate( __logname__= abspath(
self.out.lognam e ) )
def push( self,line ):
self.out.logwri te( '%s\n'%line )
self.out.logflu sh()
self.out.catch( )
more= InteractiveCons ole.push( self,line )
self.out.throw( )
return more
def write( self,data ):
return sys.stdout.writ e( data )
def interact( self,banner=Non e,*args ):
self.out.logwri te( '\n#%s Python %s %s in %s\n'%\
( datetime.now(). strftime(
'%a %b %d %Y %I:%M:%S %p' ),
sys.platform,sy s.version.split ()[0],
split(sys.argv[0])[1] ) )
if banner is None: banner=\
"Python %s %s logging to %s"%\
( sys.version.spl it()[0],split(sys.argv[0])[1],
self.out.pretty name )
return InteractiveCons ole.interact( self,banner,*ar gs )
import compiler
import linecache
class NotatedConsole( LoggedInteracti veConsole):
"""-Code object- intercepted in runsource, and rerun with
stored source before runsource. Built-in runsource
does not modify source between call and runcode."""
def runsource( self,sc,filenam e='<input>',*ar gs ):
self._runsource args= sc,filename
return LoggedInteracti veConsole.runso urce( self,sc,
filename,*args )
def runcode( self,*args ):
sc,filename= self._runsource args
linecache.check cache( filename )
#custom second compile (fourth actually)
t= compiler.parse( sc )
compiler.misc.s et_filename( filename,t )
def set_lineno( tree, initlineno ):
worklist= [ tree ]
while worklist:
node= worklist.pop( 0 )
if node.lineno is not None:
node.lineno+= initlineno
worklist.extend ( node.getChildNo des() )
set_lineno( t,self.out.getl ineno()-len( self.buffer )+1 )
code= compiler.pycode gen.\
InteractiveCode Generator( t ).getCode()
LoggedInteracti veConsole.runco de( self,code )
linecache.check cache( filename )

if __name__=='__ma in__':
console= NotatedConsole( )
console.interac t()

[castironpi]

On May 7, 6:52 pm, castiro...@gmai l.com wrote:

Presents a console permitting inspection. Input as well as output
saved in Python-readable form.
Python 2.5.1 memoryconsole4. py logging to My Documents\conso le.log>>class A:

... def f( self ):
... print 2
...>>a=A()

>import inspect
inspect.getsou rce( a.f )

'\tdef f( self ):\n\t\tprint 2\n'

This enabled by a log file, optionally set to console.log. Contents
are:

#Mon May 07 2007 06:33:42 PM Python win32 2.5.1 in memoryconsole4. py
class A:
def f( self ):
print 2

a=A()
import inspect
inspect.getsour ce( a.f )
#fb: '\tdef f( self ):\n\t\tprint 2\n'

Line 10 Microsoft Win32 convenience binding; line 49 a little
confusing. Give it a shot.

from code import InteractiveCons ole
import sys
from os import environ
from datetime import datetime
from StringIO import StringIO
from re import sub
from os.path import join,split,absp ath

class LoggedStdOut(St ringIO):
deflog= environ['USERPROFILE']+\
'\\My Documents\\cons ole.log'
def __init__( self, log=None ):
StringIO.__init __( self )
self.stdout= None
self.trip,self. head= True,''
self.logname= log or LoggedStdOut.de flog
self.prettyname =join(split(spl it(abspath(
self.logname))[0])[1],split(abspath( self.logname))[1])
for x,_ in enumerate( open( self.logname,'r ' ) ): continue
self._lineno= x #can use linecache
self._log= open( self.logname,'a ' )
def catch( self,head='#fb: ' ):
self.stdout= sys.stdout
sys.stdout= self
self.head= head
self.trip= True
def throw( self ):
sys.stdout= self.stdout
self.stdout= None
def getlineno( self ):
return self._lineno
def logwrite( self, data ):
self._log.write ( data )
self._lineno+= data.count('\n' )
def logflush( self ):
self._log.flush ()
def write( self, data ):
datal= sub( '\n([^$])','\n%s\\1'%se lf.head,data )
if self.trip: self.logwrite( self.head )
self.logwrite( datal )
self.trip= data.endswith(' \n')
return self.stdout.wri te( data )
def writelines( self, data ):
raise 'Branch uncoded'

class LoggedInteracti veConsole(Inter activeConsole):
def __init__( self,log=None,l ocals=None,file name=None ):
self.out= LoggedStdOut( log )
if filename is None: filename= split(self.out. logname)[1]
InteractiveCons ole.__init__( self,locals,fil ename )
self.locals.upd ate( __logname__= abspath(
self.out.lognam e ) )
def push( self,line ):
self.out.logwri te( '%s\n'%line )
self.out.logflu sh()
self.out.catch( )
more= InteractiveCons ole.push( self,line )
self.out.throw( )
return more
def write( self,data ):
return sys.stdout.writ e( data )
def interact( self,banner=Non e,*args ):
self.out.logwri te( '\n#%s Python %s %s in %s\n'%\
( datetime.now(). strftime(
'%a %b %d %Y %I:%M:%S %p' ),
sys.platform,sy s.version.split ()[0],
split(sys.argv[0])[1] ) )
if banner is None: banner=\
"Python %s %s logging to %s"%\
( sys.version.spl it()[0],split(sys.argv[0])[1],
self.out.pretty name )
return InteractiveCons ole.interact( self,banner,*ar gs )

import compiler
import linecache
class NotatedConsole( LoggedInteracti veConsole):
"""-Code object- intercepted in runsource, and rerun with
stored source before runsource. Built-in runsource
does not modify source between call and runcode."""
def runsource( self,sc,filenam e='<input>',*ar gs ):
self._runsource args= sc,filename
return LoggedInteracti veConsole.runso urce( self,sc,
filename,*args )
def runcode( self,*args ):
sc,filename= self._runsource args
linecache.check cache( filename )
#custom second compile (fourth actually)
t= compiler.parse( sc )
compiler.misc.s et_filename( filename,t )
def set_lineno( tree, initlineno ):
worklist= [ tree ]
while worklist:
node= worklist.pop( 0 )
if node.lineno is not None:
node.lineno+= initlineno
worklist.extend ( node.getChildNo des() )
set_lineno( t,self.out.getl ineno()-len( self.buffer )+1 )
code= compiler.pycode gen.\
InteractiveCode Generator( t ).getCode()
LoggedInteracti veConsole.runco de( self,code )
linecache.check cache( filename )

if __name__=='__ma in__':
console= NotatedConsole( )
console.interac t()

Console-defined objects can be pickled as well. ">>>edit()" opens
console.log. Editor objects are pickled between statements.

Python 2.5.1 furtherconsoles-display.py logging to My Documents
\console.log

>>class A:

.... b=0
....

>>from pickle import loads,dumps
loads(dumps(A ))

<class workmodule.A at 0x00B28030>

>>loads(dumps(A )).b

0

>>edit()

Loaded ok

and the few lines from console.log:
#Mon May 07 2007 07:55:30 PM Python win32 2.5.1 in furtherconsoles-
display.py
class A:
b=0

from pickle import loads,dumps
loads(dumps(A))
#fb: <class workmodule.A at 0x00B28030>
loads(dumps(A)) .b
#fb: 0
edit()

Hard coded paths on lines 24 and 67. Hope that's copy-and-pasteable

import memoryconsole4 as memoryconsole
from os.path import join,exists,spl it,abspath
from os import environ
from sys import argv
import sys
import cPickle as pickle
from subprocess import Popen
from datetime import datetime,timede lta

class Editors:
"""Pickled after every statement."""
def edit( self,filename=N one ):
assert hasattr( self,'_cmdlines tr' ) and hasattr( self,'console' )
if filename is None: filename= abspath( self.console.ou t.logname )
parms= { 'filename': filename, 'loglen': self.console.ou t.getlineno()
+len(self.conso le.buffer)+1 }
Popen( self._cmdlinest r % parms )
print >>sys.stderr, "Loaded ok"
def __repr__( self ):
return '<%s at %i: %s>'%(self.__cl ass__,id(self), repr( [ x for x in
dir(self) if not x.startswith('_ _') ] ))
def __call__( self,*args ):
self.edit( *args )#what find default?

class EditorsConsole( memoryconsole.N otatedConsole):
defdat= join( environ['USERPROFILE'],'My Documents\
\consoleeditor. pickle' )
def __init__( self,cmdlinestr ,datname=None,* args,**kwargs ):
memoryconsole.N otatedConsole._ _init__( self,*args,**kw args )
self._datname= datname or self.defdat
if exists( self._datname ): self.edit=
pickle.load( open( self._datname,' rb' ) )
else: self.edit= Editors()
self.edit._cmdl inestr= cmdlinestr
self.locals.upd ate( edit=self.edit )
self.edit.conso le= self
self.lasttimest amp= datetime.now()
def push( self,*args ):
more= memoryconsole.N otatedConsole.p ush( self,*args )
if not more and datetime.now()- self.lasttimest amp >
timedelta( minutes= 25 ):
self.lasttimest amp= datetime.now()
self.out.logwri te( '#%s in %s\n'%\
( self.lasttimest amp.strftime( '%a %b %d %Y %I:%M:%S
%p' ),split(argv[0])[1] ) )
del self.edit.conso le
pickle.dump( self.edit,open( self._datname,' wb' ) ) #don't pickle me
self.edit.conso le= self
return more
def __repr__( self ):
return '<%s at %i: %s>'%(self.__cl ass__,id(self), repr( [ x for x in
dir(self) if not x.startswith('_ _') ] ))

import compiler as c
from memory import Memory
import imp
from sys import modules

class ModuleConsole(E ditorsConsole):
def __init__( self,log=None,l ocals=None,file name=None ):
EditorsConsole. __init__( self,log,locals ,filename )
self.workmodule = imp.new_module( 'workmodule' )
self.workmodule .__file__= self.out.lognam e
modules[self.workmodule .__name__]= self.workmodule
self.locals.upd ate( workmodule=self .workmodule,
__name__=self.w orkmodule.__nam e__ )
self.locals.upd ate( __file__=self.w orkmodule.__fil e__ )#may omit
__logname__
del self.locals['__logname__']
def runcode( self,*args ):
EditorsConsole. runcode( self,*args )
for k,v in self.locals.ite ritems():
setattr( self.workmodule ,k,v )

if __name__=='__ma in__':
editorscmdlines tr= '"%s" "%%(filenam e)s" -cursor %%(loglen)i:
1'%join(environ['PROGRAMFILES'],'editplus 2\\editplus.exe ')
console= ModuleConsole(e ditorscmdlinest r)
console.interac t()

[castironpi]

On May 7, 7:59 pm, castiro...@gmai l.com wrote:

On May 7, 6:52 pm, castiro...@gmai l.com wrote:

Presents a console permitting inspection. Input as well as output
saved in Python-readable form.
Python 2.5.1 memoryconsole4. py logging to My Documents\conso le.log>>class A:

... def f( self ):
... print 2
...>>a=A()

>>import inspect
>>inspect.getso urce( a.f )

'\tdef f( self ):\n\t\tprint 2\n'

This enabled by a log file, optionally set to console.log. Contents
are:

#Mon May 07 2007 06:33:42 PM Python win32 2.5.1 in memoryconsole4. py
class A:
def f( self ):
print 2

a=A()
import inspect
inspect.getsour ce( a.f )
#fb: '\tdef f( self ):\n\t\tprint 2\n'

Line 10 Microsoft Win32 convenience binding; line 49 a little
confusing. Give it a shot.

from code import InteractiveCons ole
import sys
from os import environ
from datetime import datetime
from StringIO import StringIO
from re import sub
from os.path import join,split,absp ath

class LoggedStdOut(St ringIO):
deflog= environ['USERPROFILE']+\
'\\My Documents\\cons ole.log'
def __init__( self, log=None ):
StringIO.__init __( self )
self.stdout= None
self.trip,self. head= True,''
self.logname= log or LoggedStdOut.de flog
self.prettyname =join(split(spl it(abspath(
self.logname))[0])[1],split(abspath( self.logname))[1])
for x,_ in enumerate( open( self.logname,'r ' ) ): continue
self._lineno= x #can use linecache
self._log= open( self.logname,'a ' )
def catch( self,head='#fb: ' ):
self.stdout= sys.stdout
sys.stdout= self
self.head= head
self.trip= True
def throw( self ):
sys.stdout= self.stdout
self.stdout= None
def getlineno( self ):
return self._lineno
def logwrite( self, data ):
self._log.write ( data )
self._lineno+= data.count('\n' )
def logflush( self ):
self._log.flush ()
def write( self, data ):
datal= sub( '\n([^$])','\n%s\\1'%se lf.head,data )
if self.trip: self.logwrite( self.head )
self.logwrite( datal )
self.trip= data.endswith(' \n')
return self.stdout.wri te( data )
def writelines( self, data ):
raise 'Branch uncoded'

class LoggedInteracti veConsole(Inter activeConsole):
def __init__( self,log=None,l ocals=None,file name=None ):
self.out= LoggedStdOut( log )
if filename is None: filename= split(self.out. logname)[1]
InteractiveCons ole.__init__( self,locals,fil ename )
self.locals.upd ate( __logname__= abspath(
self.out.lognam e ) )
def push( self,line ):
self.out.logwri te( '%s\n'%line )
self.out.logflu sh()
self.out.catch( )
more= InteractiveCons ole.push( self,line )
self.out.throw( )
return more
def write( self,data ):
return sys.stdout.writ e( data )
def interact( self,banner=Non e,*args ):
self.out.logwri te( '\n#%s Python %s %s in %s\n'%\
( datetime.now(). strftime(
'%a %b %d %Y %I:%M:%S %p' ),
sys.platform,sy s.version.split ()[0],
split(sys.argv[0])[1] ) )
if banner is None: banner=\
"Python %s %s logging to %s"%\
( sys.version.spl it()[0],split(sys.argv[0])[1],
self.out.pretty name )
return InteractiveCons ole.interact( self,banner,*ar gs )

import compiler
import linecache
class NotatedConsole( LoggedInteracti veConsole):
"""-Code object- intercepted in runsource, and rerun with
stored source before runsource. Built-in runsource
does not modify source between call and runcode."""
def runsource( self,sc,filenam e='<input>',*ar gs ):
self._runsource args= sc,filename
return LoggedInteracti veConsole.runso urce( self,sc,
filename,*args )
def runcode( self,*args ):
sc,filename= self._runsource args
linecache.check cache( filename )
#custom second compile (fourth actually)
t= compiler.parse( sc )
compiler.misc.s et_filename( filename,t )
def set_lineno( tree, initlineno ):
worklist= [ tree ]
while worklist:
node= worklist.pop( 0 )
if node.lineno is not None:
node.lineno+= initlineno
worklist.extend ( node.getChildNo des() )
set_lineno( t,self.out.getl ineno()-len( self.buffer )+1 )
code= compiler.pycode gen.\
InteractiveCode Generator( t ).getCode()
LoggedInteracti veConsole.runco de( self,code )
linecache.check cache( filename )

if __name__=='__ma in__':
console= NotatedConsole( )
console.interac t()

Console-defined objects can be pickled as well. ">>>edit()" opens
console.log. Editor objects are pickled between statements.

Python 2.5.1 furtherconsoles-display.py logging to My Documents
\console.log>>c lass A:

... b=0
...>>from pickle import loads,dumps

>loads(dumps(A) )

<class workmodule.A at 0x00B28030>>>lo ads(dumps(A)).b
0

>edit()

Loaded ok

and the few lines from console.log:
#Mon May 07 2007 07:55:30 PM Python win32 2.5.1 in furtherconsoles-
display.py
class A:
b=0

from pickle import loads,dumps
loads(dumps(A))
#fb: <class workmodule.A at 0x00B28030>
loads(dumps(A)) .b
#fb: 0
edit()

Hard coded paths on lines 24 and 67. Hope that's copy-and-pasteable

import memoryconsole4 as memoryconsole
from os.path import join,exists,spl it,abspath
from os import environ
from sys import argv
import sys
import cPickle as pickle
from subprocess import Popen
from datetime import datetime,timede lta

class Editors:
"""Pickled after every statement."""
def edit( self,filename=N one ):
assert hasattr( self,'_cmdlines tr' ) and hasattr( self,'console' )
if filename is None: filename= abspath( self.console.ou t.logname )
parms= { 'filename': filename, 'loglen': self.console.ou t.getlineno()
+len(self.conso le.buffer)+1 }
Popen( self._cmdlinest r % parms )
print >>sys.stderr, "Loaded ok"
def __repr__( self ):
return '<%s at %i: %s>'%(self.__cl ass__,id(self), repr( [ x for x in
dir(self) if not x.startswith('_ _') ] ))
def __call__( self,*args ):
self.edit( *args )#what find default?

class EditorsConsole( memoryconsole.N otatedConsole):
defdat= join( environ['USERPROFILE'],'My Documents\
\consoleeditor. pickle' )
def __init__( self,cmdlinestr ,datname=None,* args,**kwargs ):
memoryconsole.N otatedConsole._ _init__( self,*args,**kw args )
self._datname= datname or self.defdat
if exists( self._datname ): self.edit=
pickle.load( open( self._datname,' rb' ) )
else: self.edit= Editors()
self.edit._cmdl inestr= cmdlinestr
self.locals.upd ate( edit=self.edit )
self.edit.conso le= self
self.lasttimest amp= datetime.now()
def push( self,*args ):
more= memoryconsole.N otatedConsole.p ush( self,*args )
if not more and datetime.now()- self.lasttimest amp >
timedelta( minutes= 25 ):
self.lasttimest amp= datetime.now()
self.out.logwri te( '#%s in %s\n'%\
( self.lasttimest amp.strftime( '%a %b %d %Y %I:%M:%S
%p' ),split(argv[0])[1] ) )
del self.edit.conso le
pickle.dump( self.edit,open( self._datname,' wb' ) ) #don't pickle me
self.edit.conso le= self
return more
def __repr__( self ):
return '<%s at %i: %s>'%(self.__cl ass__,id(self), repr( [ x for x in
dir(self) if not x.startswith('_ _') ] ))

import compiler as c
from memory import Memory
import imp
from sys import modules

class ModuleConsole(E ditorsConsole):
def __init__( self,log=None,l ocals=None,file name=None ):
EditorsConsole. __init__( self,log,locals ,filename )
self.workmodule = imp.new_module( 'workmodule' )
self.workmodule .__file__= self.out.lognam e
modules[self.workmodule .__name__]= self.workmodule
self.locals.upd ate( workmodule=self .workmodule,
__name__=self.w orkmodule.__nam e__ )
self.locals.upd ate( __file__=self.w orkmodule.__fil e__ )#may omit
__logname__
del self.locals['__logname__']
def runcode( self,*args ):
EditorsConsole. runcode( self,*args )
for k,v in self.locals.ite ritems():
setattr( self.workmodule ,k,v )

if __name__=='__ma in__':
editorscmdlines tr= '"%s" "%%(filenam e)s" -cursor %%(loglen)i:
1'%join(environ['PROGRAMFILES'],'editplus 2\\editplus.exe ')
console= ModuleConsole(e ditorscmdlinest r)
console.interac t()

whoops, that line 48 is extraneous.