home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / tempfile.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  13.1 KB  |  508 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. __all__ = [
  5.     'NamedTemporaryFile',
  6.     'TemporaryFile',
  7.     'SpooledTemporaryFile',
  8.     'mkstemp',
  9.     'mkdtemp',
  10.     'mktemp',
  11.     'TMP_MAX',
  12.     'gettempprefix',
  13.     'tempdir',
  14.     'gettempdir']
  15. import os as _os
  16. import errno as _errno
  17. from random import Random as _Random
  18.  
  19. try:
  20.     from cStringIO import StringIO as _StringIO
  21. except ImportError:
  22.     from StringIO import StringIO as _StringIO
  23.  
  24.  
  25. try:
  26.     import fcntl as _fcntl
  27. except ImportError:
  28.     
  29.     def _set_cloexec(fd):
  30.         pass
  31.  
  32.  
  33.  
  34. def _set_cloexec(fd):
  35.     
  36.     try:
  37.         flags = _fcntl.fcntl(fd, _fcntl.F_GETFD, 0)
  38.     except IOError:
  39.         pass
  40.  
  41.     flags |= _fcntl.FD_CLOEXEC
  42.     _fcntl.fcntl(fd, _fcntl.F_SETFD, flags)
  43.  
  44.  
  45. try:
  46.     import thread as _thread
  47. except ImportError:
  48.     import dummy_thread as _thread
  49.  
  50. _allocate_lock = _thread.allocate_lock
  51. _text_openflags = _os.O_RDWR | _os.O_CREAT | _os.O_EXCL
  52. if hasattr(_os, 'O_NOINHERIT'):
  53.     _text_openflags |= _os.O_NOINHERIT
  54. if hasattr(_os, 'O_NOFOLLOW'):
  55.     _text_openflags |= _os.O_NOFOLLOW
  56. _bin_openflags = _text_openflags
  57. if hasattr(_os, 'O_BINARY'):
  58.     _bin_openflags |= _os.O_BINARY
  59. if hasattr(_os, 'TMP_MAX'):
  60.     TMP_MAX = _os.TMP_MAX
  61. else:
  62.     TMP_MAX = 10000
  63. template = 'tmp'
  64. _once_lock = _allocate_lock()
  65. if hasattr(_os, 'lstat'):
  66.     _stat = _os.lstat
  67. elif hasattr(_os, 'stat'):
  68.     _stat = _os.stat
  69. else:
  70.     
  71.     def _stat(fn):
  72.         
  73.         try:
  74.             f = open(fn)
  75.         except IOError:
  76.             raise _os.error
  77.  
  78.         f.close()
  79.  
  80.  
  81. def _exists(fn):
  82.     
  83.     try:
  84.         _stat(fn)
  85.     except _os.error:
  86.         return False
  87.  
  88.     return True
  89.  
  90.  
  91. class _RandomNameSequence:
  92.     characters = 'abcdefghijklmnopqrstuvwxyz' + 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + '0123456789_'
  93.     
  94.     def __init__(self):
  95.         self.mutex = _allocate_lock()
  96.         self.rng = _Random()
  97.         self.normcase = _os.path.normcase
  98.  
  99.     
  100.     def __iter__(self):
  101.         return self
  102.  
  103.     
  104.     def next(self):
  105.         m = self.mutex
  106.         c = self.characters
  107.         choose = self.rng.choice
  108.         m.acquire()
  109.         
  110.         try:
  111.             letters = [ choose(c) for dummy in '123456' ]
  112.         finally:
  113.             m.release()
  114.  
  115.         return self.normcase(''.join(letters))
  116.  
  117.  
  118.  
  119. def _candidate_tempdir_list():
  120.     dirlist = []
  121.     for envname in ('TMPDIR', 'TEMP', 'TMP'):
  122.         dirname = _os.getenv(envname)
  123.         if dirname:
  124.             dirlist.append(dirname)
  125.             continue
  126.     if _os.name == 'riscos':
  127.         dirname = _os.getenv('Wimp$ScrapDir')
  128.         if dirname:
  129.             dirlist.append(dirname)
  130.         
  131.     elif _os.name == 'nt':
  132.         dirlist.extend([
  133.             'c:\\temp',
  134.             'c:\\tmp',
  135.             '\\temp',
  136.             '\\tmp'])
  137.     else:
  138.         dirlist.extend([
  139.             '/tmp',
  140.             '/var/tmp',
  141.             '/usr/tmp'])
  142.     
  143.     try:
  144.         dirlist.append(_os.getcwd())
  145.     except (AttributeError, _os.error):
  146.         dirlist.append(_os.curdir)
  147.  
  148.     return dirlist
  149.  
  150.  
  151. def _get_default_tempdir():
  152.     namer = _RandomNameSequence()
  153.     dirlist = _candidate_tempdir_list()
  154.     flags = _text_openflags
  155.     for dir in dirlist:
  156.         if dir != _os.curdir:
  157.             dir = _os.path.normcase(_os.path.abspath(dir))
  158.         for seq in xrange(100):
  159.             name = namer.next()
  160.             filename = _os.path.join(dir, name)
  161.             
  162.             try:
  163.                 fd = _os.open(filename, flags, 384)
  164.                 fp = _os.fdopen(fd, 'w')
  165.                 fp.write('blat')
  166.                 fp.close()
  167.                 _os.unlink(filename)
  168.                 del fp
  169.                 del fd
  170.                 return dir
  171.             continue
  172.             except (OSError, IOError):
  173.                 e = None
  174.                 if e[0] != _errno.EEXIST:
  175.                     break
  176.                 
  177.             
  178.  
  179.         
  180.     
  181.     raise IOError, (_errno.ENOENT, 'No usable temporary directory found in %s' % dirlist)
  182.  
  183. _name_sequence = None
  184.  
  185. def _get_candidate_names():
  186.     global _name_sequence
  187.     if _name_sequence is None:
  188.         _once_lock.acquire()
  189.         
  190.         try:
  191.             if _name_sequence is None:
  192.                 _name_sequence = _RandomNameSequence()
  193.         finally:
  194.             _once_lock.release()
  195.  
  196.     return _name_sequence
  197.  
  198.  
  199. def _mkstemp_inner(dir, pre, suf, flags):
  200.     names = _get_candidate_names()
  201.     for seq in xrange(TMP_MAX):
  202.         name = names.next()
  203.         file = _os.path.join(dir, pre + name + suf)
  204.         
  205.         try:
  206.             fd = _os.open(file, flags, 384)
  207.             _set_cloexec(fd)
  208.             return (fd, _os.path.abspath(file))
  209.         continue
  210.         except OSError:
  211.             e = None
  212.             if e.errno == _errno.EEXIST:
  213.                 continue
  214.             raise 
  215.             continue
  216.         
  217.  
  218.     
  219.     raise IOError, (_errno.EEXIST, 'No usable temporary file name found')
  220.  
  221.  
  222. def gettempprefix():
  223.     return template
  224.  
  225. tempdir = None
  226.  
  227. def gettempdir():
  228.     global tempdir
  229.     if tempdir is None:
  230.         _once_lock.acquire()
  231.         
  232.         try:
  233.             if tempdir is None:
  234.                 tempdir = _get_default_tempdir()
  235.         finally:
  236.             _once_lock.release()
  237.  
  238.     return tempdir
  239.  
  240.  
  241. def mkstemp(suffix = '', prefix = template, dir = None, text = False):
  242.     if dir is None:
  243.         dir = gettempdir()
  244.     if text:
  245.         flags = _text_openflags
  246.     else:
  247.         flags = _bin_openflags
  248.     return _mkstemp_inner(dir, prefix, suffix, flags)
  249.  
  250.  
  251. def mkdtemp(suffix = '', prefix = template, dir = None):
  252.     if dir is None:
  253.         dir = gettempdir()
  254.     names = _get_candidate_names()
  255.     for seq in xrange(TMP_MAX):
  256.         name = names.next()
  257.         file = _os.path.join(dir, prefix + name + suffix)
  258.         
  259.         try:
  260.             _os.mkdir(file, 448)
  261.             return file
  262.         continue
  263.         except OSError:
  264.             e = None
  265.             if e.errno == _errno.EEXIST:
  266.                 continue
  267.             raise 
  268.             continue
  269.         
  270.  
  271.     
  272.     raise IOError, (_errno.EEXIST, 'No usable temporary directory name found')
  273.  
  274.  
  275. def mktemp(suffix = '', prefix = template, dir = None):
  276.     if dir is None:
  277.         dir = gettempdir()
  278.     names = _get_candidate_names()
  279.     for seq in xrange(TMP_MAX):
  280.         name = names.next()
  281.         file = _os.path.join(dir, prefix + name + suffix)
  282.         if not _exists(file):
  283.             return file
  284.     
  285.     raise IOError, (_errno.EEXIST, 'No usable temporary filename found')
  286.  
  287.  
  288. class _TemporaryFileWrapper:
  289.     
  290.     def __init__(self, file, name, delete = True):
  291.         self.file = file
  292.         self.name = name
  293.         self.close_called = False
  294.         self.delete = delete
  295.  
  296.     
  297.     def __getattr__(self, name):
  298.         file = self.__dict__['file']
  299.         a = getattr(file, name)
  300.         if not issubclass(type(a), type(0)):
  301.             setattr(self, name, a)
  302.         return a
  303.  
  304.     
  305.     def __enter__(self):
  306.         self.file.__enter__()
  307.         return self
  308.  
  309.     if _os.name != 'nt':
  310.         unlink = _os.unlink
  311.         
  312.         def close(self):
  313.             if not self.close_called:
  314.                 self.close_called = True
  315.                 self.file.close()
  316.                 if self.delete:
  317.                     self.unlink(self.name)
  318.                 
  319.  
  320.         
  321.         def __del__(self):
  322.             self.close()
  323.  
  324.         
  325.         def __exit__(self, exc, value, tb):
  326.             result = self.file.__exit__(exc, value, tb)
  327.             self.close()
  328.             return result
  329.  
  330.     else:
  331.         
  332.         def __exit__(self, exc, value, tb):
  333.             self.file.__exit__(exc, value, tb)
  334.  
  335.  
  336.  
  337. def NamedTemporaryFile(mode = 'w+b', bufsize = -1, suffix = '', prefix = template, dir = None, delete = True):
  338.     if dir is None:
  339.         dir = gettempdir()
  340.     if 'b' in mode:
  341.         flags = _bin_openflags
  342.     else:
  343.         flags = _text_openflags
  344.     if _os.name == 'nt' and delete:
  345.         flags |= _os.O_TEMPORARY
  346.     (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags)
  347.     file = _os.fdopen(fd, mode, bufsize)
  348.     return _TemporaryFileWrapper(file, name, delete)
  349.  
  350. if _os.name != 'posix' or _os.sys.platform == 'cygwin':
  351.     TemporaryFile = NamedTemporaryFile
  352. else:
  353.     
  354.     def TemporaryFile(mode = 'w+b', bufsize = -1, suffix = '', prefix = template, dir = None):
  355.         if dir is None:
  356.             dir = gettempdir()
  357.         if 'b' in mode:
  358.             flags = _bin_openflags
  359.         else:
  360.             flags = _text_openflags
  361.         (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags)
  362.         
  363.         try:
  364.             _os.unlink(name)
  365.             return _os.fdopen(fd, mode, bufsize)
  366.         except:
  367.             _os.close(fd)
  368.             raise 
  369.  
  370.  
  371.  
  372. class SpooledTemporaryFile:
  373.     _rolled = False
  374.     
  375.     def __init__(self, max_size = 0, mode = 'w+b', bufsize = -1, suffix = '', prefix = template, dir = None):
  376.         self._file = _StringIO()
  377.         self._max_size = max_size
  378.         self._rolled = False
  379.         self._TemporaryFileArgs = (mode, bufsize, suffix, prefix, dir)
  380.  
  381.     
  382.     def _check(self, file):
  383.         if self._rolled:
  384.             return None
  385.         max_size = None._max_size
  386.         if max_size and file.tell() > max_size:
  387.             self.rollover()
  388.  
  389.     
  390.     def rollover(self):
  391.         if self._rolled:
  392.             return None
  393.         file = None._file
  394.         newfile = self._file = TemporaryFile(*self._TemporaryFileArgs)
  395.         del self._TemporaryFileArgs
  396.         newfile.write(file.getvalue())
  397.         newfile.seek(file.tell(), 0)
  398.         self._rolled = True
  399.  
  400.     
  401.     def __enter__(self):
  402.         if self._file.closed:
  403.             raise ValueError('Cannot enter context with closed file')
  404.         return self
  405.  
  406.     
  407.     def __exit__(self, exc, value, tb):
  408.         self._file.close()
  409.  
  410.     
  411.     def __iter__(self):
  412.         return self._file.__iter__()
  413.  
  414.     
  415.     def close(self):
  416.         self._file.close()
  417.  
  418.     
  419.     def closed(self):
  420.         return self._file.closed
  421.  
  422.     closed = property(closed)
  423.     
  424.     def encoding(self):
  425.         return self._file.encoding
  426.  
  427.     encoding = property(encoding)
  428.     
  429.     def fileno(self):
  430.         self.rollover()
  431.         return self._file.fileno()
  432.  
  433.     
  434.     def flush(self):
  435.         self._file.flush()
  436.  
  437.     
  438.     def isatty(self):
  439.         return self._file.isatty()
  440.  
  441.     
  442.     def mode(self):
  443.         return self._file.mode
  444.  
  445.     mode = property(mode)
  446.     
  447.     def name(self):
  448.         return self._file.name
  449.  
  450.     name = property(name)
  451.     
  452.     def newlines(self):
  453.         return self._file.newlines
  454.  
  455.     newlines = property(newlines)
  456.     
  457.     def next(self):
  458.         return self._file.next
  459.  
  460.     
  461.     def read(self, *args):
  462.         return self._file.read(*args)
  463.  
  464.     
  465.     def readline(self, *args):
  466.         return self._file.readline(*args)
  467.  
  468.     
  469.     def readlines(self, *args):
  470.         return self._file.readlines(*args)
  471.  
  472.     
  473.     def seek(self, *args):
  474.         self._file.seek(*args)
  475.  
  476.     
  477.     def softspace(self):
  478.         return self._file.softspace
  479.  
  480.     softspace = property(softspace)
  481.     
  482.     def tell(self):
  483.         return self._file.tell()
  484.  
  485.     
  486.     def truncate(self):
  487.         self._file.truncate()
  488.  
  489.     
  490.     def write(self, s):
  491.         file = self._file
  492.         rv = file.write(s)
  493.         self._check(file)
  494.         return rv
  495.  
  496.     
  497.     def writelines(self, iterable):
  498.         file = self._file
  499.         rv = file.writelines(iterable)
  500.         self._check(file)
  501.         return rv
  502.  
  503.     
  504.     def xreadlines(self, *args):
  505.         return self._file.xreadlines(*args)
  506.  
  507.  
  508.