[python] StriingIO module

StringIO is usually used for buffer of string. which can have stdin,stdout,stderr redirected to a buffer.

this moudle contains all of below methods.

f = StringIO()      # ready for writing
f = StringIO(buf)   # ready for reading
f.close()           # explicitly release resources held
flag = f.isatty()   # always false
pos = f.tell()      # get current position
f.seek(pos)         # set current position
f.seek(pos, mode)   # mode 0: absolute; 1: relative; 2: relative to EOF
buf = f.read()      # read until EOF
buf = f.read(n)     # read up to n bytes
buf = f.readline()  # read until end of line ('\n') or EOF
list = f.readlines()# list of f.readline() results until EOF
f.truncate([size])  # truncate file at to at most size (default: current pos)
f.write(buf)        # write at current position
f.writelines(list)  # for line in list: f.write(line)
f.getvalue()        # return whole file's contents as a string

1.write into buffer

from StringIO import StringIO
file = StringIO()
file.write('do something')
file.write('do anything')
print file.getvalue()
file.close()

#do somethingdo anything    

2.re-direct

'''Write into buff, not file'''
from StringIO import StringIO 
import sys
#save the original status so that restore once re-direct behavior is complete.
stdout = sys.stdout
buff = StringIO()
#re-direct sys.stdout to buff object.
sys.stdout = buff #two of them have write() method.
#anything doing will re-direct into buffer, instead of sys.stdout.
print 'do something, do anything'
#copy stdout into variable contents
contents = buff.getvalue()
#re-assign the default value to sys.stdout
sys.stdout = stdout
print contents


# an simple and concise method
print >> buff,'code analysis'
print buff.getvalue()

##with output being
##do something, do anything
##
##do something, do anything
##code analysis

 3.customize buff object

import sys
from StringIO import StringIO
''' this class customized by user need to have write() method'''
class Buffer():
     def __init__(self):
             self.out = sys.stdout
             self.log = StringIO()
     def write(self, text):
             self.log.write(text)
             #self.out.write(text)
             
#store the original status so that restore once re-direct behavior is complete
stdout = sys.stdout
# Create an instance of the user-defined output buffer to capture the output
buffout = Buffer()
# copy the buffer obj into sys.stdout
sys.stdout = buffout
print 'do something, do anything'
# Copy stdout into variable(contents)
contents = buffout.log.getvalue()
#restore the original status
sys.stdout = stdout
print contents

#### do something, do anything 

4. customize buff object (con't)

import sys

#Define an I/O object 
class StdoutToStr: 
    def __init__(self): 
        self.buffer = '' 
    def write(self, buf): 
        self.buffer += buf

#Re-direct standard output
temp = sys.stdout 
output = StdoutToStr()

sys.stdout = output 
print "do something" 
print "do anything" 
print "do everything"

sys.stdout = temp
print output.buffer


##do something
##do anything
##do everything

 5. Customize buff object appending clear method(con't) captureoutput.py

#!/usr/bin/env python

"""
This module is used to capture output sent to sys.stdout and make the output
available programmatically.

Usage:
  import captureoutput
  
  message = "Hello!"
  try:
      captureoutput.captureStdOut()
      print(message)
  finally:
      captureoutput.uncaptureStdOut()
  capturedText = captureoutput.getCapturedStdOut().rstrip()
  print("Captured message is: %s"%captureText)
"""
#output Hello!
import sys

#////////////////////////////////////////////////////////////////////////////
#////////////////////////////////////////////////////////////////////////////
# Private attributes
#////////////////////////////////////////////////////////////////////////////
#////////////////////////////////////////////////////////////////////////////

# This class acts like an output file stream.  Once assigned to sys.stdout,
# this class captures all output in a local attribute that can later be
# read back using the getvalue() method.
class _MyStringIO(object):
    def __init__(self):
        self.output = ""
    
    def write(self, text):
        self.output += text
    
    def clear(self):
        self.output = ""
    
    def getvalue(self):
        return self.output

_oldstdout = None
_localstdout = _MyStringIO()

#////////////////////////////////////////////////////////////////////////////
#////////////////////////////////////////////////////////////////////////////
# Public functions.
#////////////////////////////////////////////////////////////////////////////
#////////////////////////////////////////////////////////////////////////////

def captureStdOut():
    """Enables the capturing of standard output by hooking into sys.stdout.
    Once hooked, all output sent to standard out is captured in a variable
    that can be read using getCapturedStdOut().
    
    This function can be called more than once, the hook only occurs once
    and subsequent calls are ignored.  Call uncaptureStdOut() to restore
    the old sys.stdout.
    
    Note: The internal buffer is cleared when the sys.stdout is actually
    hooked.
    
    Note: Calls to this function cannot be nested.  First call to this
    function hooks sys.stdout.  First call to uncaptureStdOut() unhooks
    sys.stdout.
    
    Arguments:
      None.

    Returns:
      None.
    """

    global _oldstdout
    
    if _oldstdout is None:
        _oldstdout = sys.stdout
        sys.stdout = _localstdout
        _localstdout.clear()

def uncaptureStdOut():
    """Disables the capturing of standard output.  Any output that was
    captured since getCaptureStdOut() was called is still available through
    getCapturedStdOut().
    
    This function can be called more than once but only the first call
    actually undoes the sys.stdout hook, subsequent calls are ignored.
    
    Note: Calls to this function cannot be nested.  First call to this
    function unhooks sys.stdout.
    
    Arguments:
      None.

    Returns:
      None.
    """

    global _oldstdout

    if _oldstdout is not None:
        sys.stdout = _oldstdout
        _oldstdout = None

def getCapturedStdOut():
    """Retrieves whatever has been captured so far since getCaptureStdOut()
    or clearCaptureStdOut() was called.
    
    The captured data is cummulative.  To reset the capture buffer, call
    clearCapturedStdOut().
    
    Arguments:
      None.

    Returns:
      A string containing all output sent to sys.stdout.
    """

    return _localstdout.getvalue()

def clearCapturedStdOut():
    """Clears the internal buffer containing the captured output.
    
    Arguments:
      None.

    Returns:
      None.
    """

    _localstdout.clear()

__all__ = ["captureStdOut", "uncaptureStdOut", "getCapturedStdOut" ]

6. Usage for captureoutput.py

import captureoutput as _captureoutput
_captureoutput.captureStdOut()
lines = None
try:
    print ' hello\neveryone\n'
    output = _captureoutput.getCapturedStdOut().rstrip()
    lines = output.split('\r\n')
finally:
    _captureoutput.uncaptureStdOut()
 
if lines:
    for line in lines:
    print line