home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / fileinput.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  8.0 KB  |  331 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. import sys
  5. import os
  6. __all__ = [
  7.     'input',
  8.     'close',
  9.     'nextfile',
  10.     'filename',
  11.     'lineno',
  12.     'filelineno',
  13.     'isfirstline',
  14.     'isstdin',
  15.     'FileInput']
  16. _state = None
  17. DEFAULT_BUFSIZE = 8192
  18.  
  19. def input(files = None, inplace = 0, backup = '', bufsize = 0, mode = 'r', openhook = None):
  20.     global _state
  21.     if _state and _state._file:
  22.         raise RuntimeError, 'input() already active'
  23.     _state = FileInput(files, inplace, backup, bufsize, mode, openhook)
  24.     return _state
  25.  
  26.  
  27. def close():
  28.     global _state
  29.     state = _state
  30.     _state = None
  31.     if state:
  32.         state.close()
  33.  
  34.  
  35. def nextfile():
  36.     if not _state:
  37.         raise RuntimeError, 'no active input()'
  38.     return _state.nextfile()
  39.  
  40.  
  41. def filename():
  42.     if not _state:
  43.         raise RuntimeError, 'no active input()'
  44.     return _state.filename()
  45.  
  46.  
  47. def lineno():
  48.     if not _state:
  49.         raise RuntimeError, 'no active input()'
  50.     return _state.lineno()
  51.  
  52.  
  53. def filelineno():
  54.     if not _state:
  55.         raise RuntimeError, 'no active input()'
  56.     return _state.filelineno()
  57.  
  58.  
  59. def fileno():
  60.     if not _state:
  61.         raise RuntimeError, 'no active input()'
  62.     return _state.fileno()
  63.  
  64.  
  65. def isfirstline():
  66.     if not _state:
  67.         raise RuntimeError, 'no active input()'
  68.     return _state.isfirstline()
  69.  
  70.  
  71. def isstdin():
  72.     if not _state:
  73.         raise RuntimeError, 'no active input()'
  74.     return _state.isstdin()
  75.  
  76.  
  77. class FileInput:
  78.     
  79.     def __init__(self, files = None, inplace = 0, backup = '', bufsize = 0, mode = 'r', openhook = None):
  80.         if isinstance(files, basestring):
  81.             files = (files,)
  82.         elif files is None:
  83.             files = sys.argv[1:]
  84.         if not files:
  85.             files = ('-',)
  86.         else:
  87.             files = tuple(files)
  88.         self._files = files
  89.         self._inplace = inplace
  90.         self._backup = backup
  91.         if not bufsize:
  92.             pass
  93.         self._bufsize = DEFAULT_BUFSIZE
  94.         self._savestdout = None
  95.         self._output = None
  96.         self._filename = None
  97.         self._lineno = 0
  98.         self._filelineno = 0
  99.         self._file = None
  100.         self._isstdin = False
  101.         self._backupfilename = None
  102.         self._buffer = []
  103.         self._bufindex = 0
  104.         if mode not in ('r', 'rU', 'U', 'rb'):
  105.             raise ValueError("FileInput opening mode must be one of 'r', 'rU', 'U' and 'rb'")
  106.         self._mode = mode
  107.         if inplace and openhook:
  108.             raise ValueError('FileInput cannot use an opening hook in inplace mode')
  109.         if openhook and not hasattr(openhook, '__call__'):
  110.             raise ValueError('FileInput openhook must be callable')
  111.         self._openhook = openhook
  112.  
  113.     
  114.     def __del__(self):
  115.         self.close()
  116.  
  117.     
  118.     def close(self):
  119.         self.nextfile()
  120.         self._files = ()
  121.  
  122.     
  123.     def __iter__(self):
  124.         return self
  125.  
  126.     
  127.     def next(self):
  128.         
  129.         try:
  130.             line = self._buffer[self._bufindex]
  131.         except IndexError:
  132.             pass
  133.  
  134.         self._bufindex += 1
  135.         self._lineno += 1
  136.         self._filelineno += 1
  137.         return line
  138.         line = self.readline()
  139.         if not line:
  140.             raise StopIteration
  141.         return line
  142.  
  143.     
  144.     def __getitem__(self, i):
  145.         if i != self._lineno:
  146.             raise RuntimeError, 'accessing lines out of order'
  147.         
  148.         try:
  149.             return self.next()
  150.         except StopIteration:
  151.             raise IndexError, 'end of input reached'
  152.  
  153.  
  154.     
  155.     def nextfile(self):
  156.         savestdout = self._savestdout
  157.         self._savestdout = 0
  158.         if savestdout:
  159.             sys.stdout = savestdout
  160.         output = self._output
  161.         self._output = 0
  162.         if output:
  163.             output.close()
  164.         file = self._file
  165.         self._file = 0
  166.         if file and not (self._isstdin):
  167.             file.close()
  168.         backupfilename = self._backupfilename
  169.         self._backupfilename = 0
  170.         if backupfilename and not (self._backup):
  171.             
  172.             try:
  173.                 os.unlink(backupfilename)
  174.             except OSError:
  175.                 pass
  176.             
  177.  
  178.         self._isstdin = False
  179.         self._buffer = []
  180.         self._bufindex = 0
  181.  
  182.     
  183.     def readline(self):
  184.         
  185.         try:
  186.             line = self._buffer[self._bufindex]
  187.         except IndexError:
  188.             pass
  189.  
  190.         self._bufindex += 1
  191.         self._lineno += 1
  192.         self._filelineno += 1
  193.         return line
  194.         if not self._file:
  195.             if not self._files:
  196.                 return ''
  197.             self._filename = self._files[0]
  198.             self._files = self._files[1:]
  199.             self._filelineno = 0
  200.             self._file = None
  201.             self._isstdin = False
  202.             self._backupfilename = 0
  203.             if self._filename == '-':
  204.                 self._filename = '<stdin>'
  205.                 self._file = sys.stdin
  206.                 self._isstdin = True
  207.             elif self._inplace:
  208.                 if not self._backup:
  209.                     pass
  210.                 self._backupfilename = self._filename + os.extsep + 'bak'
  211.                 
  212.                 try:
  213.                     os.unlink(self._backupfilename)
  214.                 except os.error:
  215.                     self
  216.                     self
  217.                     self
  218.  
  219.                 os.rename(self._filename, self._backupfilename)
  220.                 self._file = open(self._backupfilename, self._mode)
  221.                 
  222.                 try:
  223.                     perm = os.fstat(self._file.fileno()).st_mode
  224.                 except OSError:
  225.                     self
  226.                     self
  227.                     self
  228.                     self._output = open(self._filename, 'w')
  229.  
  230.                 fd = os.open(self._filename, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, perm)
  231.                 self._output = os.fdopen(fd, 'w')
  232.                 
  233.                 try:
  234.                     if hasattr(os, 'chmod'):
  235.                         os.chmod(self._filename, perm)
  236.                 except OSError:
  237.                     self
  238.                     self
  239.                     self
  240.  
  241.                 self._savestdout = sys.stdout
  242.                 sys.stdout = self._output
  243.             elif self._openhook:
  244.                 self._file = self._openhook(self._filename, self._mode)
  245.             else:
  246.                 self._file = open(self._filename, self._mode)
  247.         self._buffer = self._file.readlines(self._bufsize)
  248.         self._bufindex = 0
  249.         if not self._buffer:
  250.             self.nextfile()
  251.         return self.readline()
  252.  
  253.     
  254.     def filename(self):
  255.         return self._filename
  256.  
  257.     
  258.     def lineno(self):
  259.         return self._lineno
  260.  
  261.     
  262.     def filelineno(self):
  263.         return self._filelineno
  264.  
  265.     
  266.     def fileno(self):
  267.         if self._file:
  268.             
  269.             try:
  270.                 return self._file.fileno()
  271.             except ValueError:
  272.                 return -1
  273.             
  274.  
  275.         return -1
  276.  
  277.     
  278.     def isfirstline(self):
  279.         return self._filelineno == 1
  280.  
  281.     
  282.     def isstdin(self):
  283.         return self._isstdin
  284.  
  285.  
  286.  
  287. def hook_compressed(filename, mode):
  288.     ext = os.path.splitext(filename)[1]
  289.     if ext == '.gz':
  290.         import gzip
  291.         return gzip.open(filename, mode)
  292.     if None == '.bz2':
  293.         import bz2
  294.         return bz2.BZ2File(filename, mode)
  295.     return None(filename, mode)
  296.  
  297.  
  298. def hook_encoded(encoding):
  299.     import codecs
  300.     
  301.     def openhook(filename, mode):
  302.         return codecs.open(filename, mode, encoding)
  303.  
  304.     return openhook
  305.  
  306.  
  307. def _test():
  308.     import getopt
  309.     inplace = 0
  310.     backup = 0
  311.     (opts, args) = getopt.getopt(sys.argv[1:], 'ib:')
  312.     for o, a in opts:
  313.         if o == '-i':
  314.             inplace = 1
  315.         if o == '-b':
  316.             backup = a
  317.             continue
  318.     for line in input(args, inplace = inplace, backup = backup):
  319.         if line[-1:] == '\n':
  320.             line = line[:-1]
  321.         if line[-1:] == '\r':
  322.             line = line[:-1]
  323.         if not isfirstline() or '*':
  324.             pass
  325.         print '%d: %s[%d]%s %s' % (lineno(), filename(), filelineno(), '', line)
  326.     
  327.     print '%d: %s[%d]' % (lineno(), filename(), filelineno())
  328.  
  329. if __name__ == '__main__':
  330.     _test()
  331.