home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 January / Gamestar_80_2006-01_dvd.iso / Dema / Civilization4 / data1.cab / Civ4DemoComponent / Assets / Python / System / pipes.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-11-09  |  9.6 KB  |  329 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """Conversion pipeline templates.
  5.  
  6. The problem:
  7. ------------
  8.  
  9. Suppose you have some data that you want to convert to another format,
  10. such as from GIF image format to PPM image format.  Maybe the
  11. conversion involves several steps (e.g. piping it through compress or
  12. uuencode).  Some of the conversion steps may require that their input
  13. is a disk file, others may be able to read standard input; similar for
  14. their output.  The input to the entire conversion may also be read
  15. from a disk file or from an open file, and similar for its output.
  16.  
  17. The module lets you construct a pipeline template by sticking one or
  18. more conversion steps together.  It will take care of creating and
  19. removing temporary files if they are necessary to hold intermediate
  20. data.  You can then use the template to do conversions from many
  21. different sources to many different destinations.  The temporary
  22. file names used are different each time the template is used.
  23.  
  24. The templates are objects so you can create templates for many
  25. different conversion steps and store them in a dictionary, for
  26. instance.
  27.  
  28.  
  29. Directions:
  30. -----------
  31.  
  32. To create a template:
  33.     t = Template()
  34.  
  35. To add a conversion step to a template:
  36.    t.append(command, kind)
  37. where kind is a string of two characters: the first is '-' if the
  38. command reads its standard input or 'f' if it requires a file; the
  39. second likewise for the output. The command must be valid /bin/sh
  40. syntax.  If input or output files are required, they are passed as
  41. $IN and $OUT; otherwise, it must be  possible to use the command in
  42. a pipeline.
  43.  
  44. To add a conversion step at the beginning:
  45.    t.prepend(command, kind)
  46.  
  47. To convert a file to another file using a template:
  48.   sts = t.copy(infile, outfile)
  49. If infile or outfile are the empty string, standard input is read or
  50. standard output is written, respectively.  The return value is the
  51. exit status of the conversion pipeline.
  52.  
  53. To open a file for reading or writing through a conversion pipeline:
  54.    fp = t.open(file, mode)
  55. where mode is 'r' to read the file, or 'w' to write it -- just like
  56. for the built-in function open() or for os.popen().
  57.  
  58. To create a new template object initialized to a given one:
  59.    t2 = t.clone()
  60.  
  61. For an example, see the function test() at the end of the file.
  62. """
  63. import re
  64. import os
  65. import tempfile
  66. import string
  67. __all__ = [
  68.     'Template']
  69. FILEIN_FILEOUT = 'ff'
  70. STDIN_FILEOUT = '-f'
  71. FILEIN_STDOUT = 'f-'
  72. STDIN_STDOUT = '--'
  73. SOURCE = '.-'
  74. SINK = '-.'
  75. stepkinds = [
  76.     FILEIN_FILEOUT,
  77.     STDIN_FILEOUT,
  78.     FILEIN_STDOUT,
  79.     STDIN_STDOUT,
  80.     SOURCE,
  81.     SINK]
  82.  
  83. class Template:
  84.     '''Class representing a pipeline template.'''
  85.     
  86.     def __init__(self):
  87.         '''Template() returns a fresh pipeline template.'''
  88.         self.debugging = 0
  89.         self.reset()
  90.  
  91.     
  92.     def __repr__(self):
  93.         '''t.__repr__() implements repr(t).'''
  94.         return '<Template instance, steps=%r>' % (self.steps,)
  95.  
  96.     
  97.     def reset(self):
  98.         '''t.reset() restores a pipeline template to its initial state.'''
  99.         self.steps = []
  100.  
  101.     
  102.     def clone(self):
  103.         '''t.clone() returns a new pipeline template with identical
  104.         initial state as the current one.'''
  105.         t = Template()
  106.         t.steps = self.steps[:]
  107.         t.debugging = self.debugging
  108.         return t
  109.  
  110.     
  111.     def debug(self, flag):
  112.         '''t.debug(flag) turns debugging on or off.'''
  113.         self.debugging = flag
  114.  
  115.     
  116.     def append(self, cmd, kind):
  117.         '''t.append(cmd, kind) adds a new step at the end.'''
  118.         if type(cmd) is not type(''):
  119.             raise TypeError, 'Template.append: cmd must be a string'
  120.         
  121.         if kind not in stepkinds:
  122.             raise ValueError, 'Template.append: bad kind %r' % (kind,)
  123.         
  124.         if kind == SOURCE:
  125.             raise ValueError, 'Template.append: SOURCE can only be prepended'
  126.         
  127.         if self.steps and self.steps[-1][1] == SINK:
  128.             raise ValueError, 'Template.append: already ends with SINK'
  129.         
  130.         if kind[0] == 'f' and not re.search('\\$IN\\b', cmd):
  131.             raise ValueError, 'Template.append: missing $IN in cmd'
  132.         
  133.         if kind[1] == 'f' and not re.search('\\$OUT\\b', cmd):
  134.             raise ValueError, 'Template.append: missing $OUT in cmd'
  135.         
  136.         self.steps.append((cmd, kind))
  137.  
  138.     
  139.     def prepend(self, cmd, kind):
  140.         '''t.prepend(cmd, kind) adds a new step at the front.'''
  141.         if type(cmd) is not type(''):
  142.             raise TypeError, 'Template.prepend: cmd must be a string'
  143.         
  144.         if kind not in stepkinds:
  145.             raise ValueError, 'Template.prepend: bad kind %r' % (kind,)
  146.         
  147.         if kind == SINK:
  148.             raise ValueError, 'Template.prepend: SINK can only be appended'
  149.         
  150.         if self.steps and self.steps[0][1] == SOURCE:
  151.             raise ValueError, 'Template.prepend: already begins with SOURCE'
  152.         
  153.         if kind[0] == 'f' and not re.search('\\$IN\\b', cmd):
  154.             raise ValueError, 'Template.prepend: missing $IN in cmd'
  155.         
  156.         if kind[1] == 'f' and not re.search('\\$OUT\\b', cmd):
  157.             raise ValueError, 'Template.prepend: missing $OUT in cmd'
  158.         
  159.         self.steps.insert(0, (cmd, kind))
  160.  
  161.     
  162.     def open(self, file, rw):
  163.         '''t.open(file, rw) returns a pipe or file object open for
  164.         reading or writing; the file is the other end of the pipeline.'''
  165.         if rw == 'r':
  166.             return self.open_r(file)
  167.         
  168.         if rw == 'w':
  169.             return self.open_w(file)
  170.         
  171.         raise ValueError, "Template.open: rw must be 'r' or 'w', not %r" % (rw,)
  172.  
  173.     
  174.     def open_r(self, file):
  175.         """t.open_r(file) and t.open_w(file) implement
  176.         t.open(file, 'r') and t.open(file, 'w') respectively."""
  177.         if not self.steps:
  178.             return open(file, 'r')
  179.         
  180.         if self.steps[-1][1] == SINK:
  181.             raise ValueError, 'Template.open_r: pipeline ends width SINK'
  182.         
  183.         cmd = self.makepipeline(file, '')
  184.         return os.popen(cmd, 'r')
  185.  
  186.     
  187.     def open_w(self, file):
  188.         if not self.steps:
  189.             return open(file, 'w')
  190.         
  191.         if self.steps[0][1] == SOURCE:
  192.             raise ValueError, 'Template.open_w: pipeline begins with SOURCE'
  193.         
  194.         cmd = self.makepipeline('', file)
  195.         return os.popen(cmd, 'w')
  196.  
  197.     
  198.     def copy(self, infile, outfile):
  199.         return os.system(self.makepipeline(infile, outfile))
  200.  
  201.     
  202.     def makepipeline(self, infile, outfile):
  203.         cmd = makepipeline(infile, self.steps, outfile)
  204.         if self.debugging:
  205.             print cmd
  206.             cmd = 'set -x; ' + cmd
  207.         
  208.         return cmd
  209.  
  210.  
  211.  
  212. def makepipeline(infile, steps, outfile):
  213.     list = []
  214.     for cmd, kind in steps:
  215.         list.append([
  216.             '',
  217.             cmd,
  218.             kind,
  219.             ''])
  220.     
  221.     if not list:
  222.         list.append([
  223.             '',
  224.             'cat',
  225.             '--',
  226.             ''])
  227.     
  228.     (cmd, kind) = list[0][1:3]
  229.     if kind[0] == 'f' and not infile:
  230.         list.insert(0, [
  231.             '',
  232.             'cat',
  233.             '--',
  234.             ''])
  235.     
  236.     list[0][0] = infile
  237.     (cmd, kind) = list[-1][1:3]
  238.     if kind[1] == 'f' and not outfile:
  239.         list.append([
  240.             '',
  241.             'cat',
  242.             '--',
  243.             ''])
  244.     
  245.     list[-1][-1] = outfile
  246.     garbage = []
  247.     for i in range(1, len(list)):
  248.         lkind = list[i - 1][2]
  249.         rkind = list[i][2]
  250.         if lkind[1] == 'f' or rkind[0] == 'f':
  251.             (fd, temp) = tempfile.mkstemp()
  252.             os.close(fd)
  253.             garbage.append(temp)
  254.             list[i - 1][-1] = list[i][0] = temp
  255.             continue
  256.     
  257.     for item in list:
  258.         (inf, cmd, kind, outf) = item
  259.         if kind[1] == 'f':
  260.             cmd = 'OUT=' + quote(outf) + '; ' + cmd
  261.         
  262.         if kind[0] == 'f':
  263.             cmd = 'IN=' + quote(inf) + '; ' + cmd
  264.         
  265.         if kind[0] == '-' and inf:
  266.             cmd = cmd + ' <' + quote(inf)
  267.         
  268.         if kind[1] == '-' and outf:
  269.             cmd = cmd + ' >' + quote(outf)
  270.         
  271.         item[1] = cmd
  272.     
  273.     cmdlist = list[0][1]
  274.     for item in list[1:]:
  275.         (cmd, kind) = item[1:3]
  276.         if item[0] == '':
  277.             if 'f' in kind:
  278.                 cmd = '{ ' + cmd + '; }'
  279.             
  280.             cmdlist = cmdlist + ' |\n' + cmd
  281.             continue
  282.         cmdlist = cmdlist + '\n' + cmd
  283.     
  284.     if garbage:
  285.         rmcmd = 'rm -f'
  286.         for file in garbage:
  287.             rmcmd = rmcmd + ' ' + quote(file)
  288.         
  289.         trapcmd = 'trap ' + quote(rmcmd + '; exit') + ' 1 2 3 13 14 15'
  290.         cmdlist = trapcmd + '\n' + cmdlist + '\n' + rmcmd
  291.     
  292.     return cmdlist
  293.  
  294. _safechars = string.ascii_letters + string.digits + '!@%_-+=:,./'
  295. _funnychars = '"`$\\'
  296.  
  297. def quote(file):
  298.     for c in file:
  299.         if c not in _safechars:
  300.             break
  301.             continue
  302.     else:
  303.         return file
  304.     if "'" not in file:
  305.         return "'" + file + "'"
  306.     
  307.     res = ''
  308.     for c in file:
  309.         if c in _funnychars:
  310.             c = '\\' + c
  311.         
  312.         res = res + c
  313.     
  314.     return '"' + res + '"'
  315.  
  316.  
  317. def test():
  318.     print 'Testing...'
  319.     t = Template()
  320.     t.append('togif $IN $OUT', 'ff')
  321.     t.append('giftoppm', '--')
  322.     t.append('ppmtogif >$OUT', '-f')
  323.     t.append('fromgif $IN $OUT', 'ff')
  324.     t.debug(1)
  325.     FILE = '/usr/local/images/rgb/rogues/guido.rgb'
  326.     t.copy(FILE, '@temp')
  327.     print 'Done.'
  328.  
  329.