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