home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / fileutil.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  11.8 KB  |  400 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from __future__ import with_statement
  5. import os
  6. import codecs
  7. pathjoin = os.path.join
  8. from threading import RLock
  9. from time import time
  10. from path import path
  11. from logging import getLogger
  12. log = getLogger('fileutil')
  13. import Queue as Q
  14. import traceback
  15. if os.name == 'nt':
  16.     import ctypes
  17.     GetDiskFreeSpaceEx = ctypes.windll.kernel32.GetDiskFreeSpaceExW
  18.     bytes_free = ctypes.c_ulonglong()
  19.     
  20.     def free_disk_space():
  21.         if not GetDiskFreeSpaceEx(None, ctypes.byref(bytes_free), None, None):
  22.             
  23.             try:
  24.                 raise ctypes.WinError()
  25.             except Exception:
  26.                 traceback.print_exc()
  27.                 return 0
  28.             
  29.  
  30.         None<EXCEPTION MATCH>Exception
  31.         return bytes_free.value
  32.  
  33. else:
  34.     
  35.     def free_disk_space():
  36.         log.warning('free_disk_space not implemented for this platform')
  37.         return 0
  38.  
  39.  
  40. class cd(object):
  41.     
  42.     def __init__(self, *path):
  43.         self.path = path
  44.  
  45.     
  46.     def __enter__(self):
  47.         self.original_cwd = os.getcwd()
  48.         new_cwd = pathjoin(*self.path)
  49.         os.chdir(new_cwd)
  50.  
  51.     
  52.     def __exit__(self, exc_type, exc_val, exc_tb):
  53.         os.chdir(self.original_cwd)
  54.  
  55.  
  56.  
  57. def tail(filename, maxbytes, encoding = None):
  58.     if maxbytes <= 0:
  59.         raise ValueError('maxbytes must be more than 0')
  60.     maxbytes <= 0
  61.     seekargs = (-maxbytes, os.SEEK_END)
  62.     if hasattr(filename, 'read'):
  63.         f = filename
  64.         will_close = False
  65.     else:
  66.         filesize = os.stat(filename).st_size
  67.         if encoding is not None:
  68.             f = codecs.open(filename, 'rb', encoding)
  69.         else:
  70.             f = open(filename, 'rb')
  71.         if maxbytes > filesize:
  72.             seek = 0
  73.         else:
  74.             seek = filesize - maxbytes
  75.         seekargs = (seek,)
  76.         will_close = True
  77.     f.seek(*seekargs)
  78.     s = f.read()
  79.     if will_close:
  80.         f.close()
  81.     
  82.     return s
  83.  
  84.  
  85. def streamcopy(fobjin, fobjouts, limit = None, chunk = 4096):
  86.     if hasattr(fobjouts, 'write'):
  87.         fobjouts = [
  88.             fobjouts]
  89.     
  90.     
  91.     def writer(data):
  92.         for fobjout in fobjouts:
  93.             fobjout.write(data)
  94.         
  95.  
  96.     return functioncopy(fobjin.read, writer, limit, chunk)
  97.  
  98.  
  99. def functioncopy(reader, writer, limit = None, chunk = 4096):
  100.     if not callable(reader) or not callable(writer):
  101.         raise TypeError("Both 'reader' and 'writer' must be callable. Got (%r, %r) instead.", reader, writer)
  102.     not callable(writer)
  103.     written = 0
  104.     if limit is not None:
  105.         sz_to_read = min(limit, chunk)
  106.     else:
  107.         limit = -1
  108.         sz_to_read = chunk
  109.     bytes = reader(sz_to_read)
  110.     while bytes:
  111.         writer(bytes)
  112.         limit -= len(bytes)
  113.         written += len(bytes)
  114.         if limit > 0:
  115.             sz_to_read = min(limit, chunk)
  116.         elif limit == 0:
  117.             break
  118.         else:
  119.             sz_to_read = chunk
  120.         bytes = reader(sz_to_read)
  121.     return written
  122.  
  123. CHUNKSIZE = 32768
  124.  
  125. def trim_file(fname, cap, newsize):
  126.     fobjin = None
  127.     fobjout = None
  128.     fname = path(fname)
  129.     if fname.size > cap:
  130.         
  131.         try:
  132.             fobjin = open(fname, 'rb')
  133.             fobjout = open(fname + '.new', 'wb')
  134.             fobjin.seek(-newsize, os.SEEK_END)
  135.             streamcopy(fobjin, fobjout, CHUNKSIZE)
  136.         finally:
  137.             for f in (fobjin, fobjout):
  138.                 if f is not None:
  139.                     f.close()
  140.                     continue
  141.             
  142.  
  143.         os.remove(fname)
  144.         os.rename(fobjout.name, fname)
  145.     
  146.  
  147.  
  148. class PausableStream(object):
  149.     
  150.     def __init__(self, stream):
  151.         self._lock = RLock()
  152.         self.paused = False
  153.         self.stream = stream
  154.         self._queue = Q.Queue()
  155.  
  156.     
  157.     def pause(self):
  158.         self.paused = True
  159.  
  160.     
  161.     def unpause(self):
  162.         if self._lock.acquire():
  163.             
  164.             try:
  165.                 while True:
  166.                     
  167.                     try:
  168.                         self.stream.write(self._queue.get_nowait())
  169.                     continue
  170.                     except Q.Empty:
  171.                         break
  172.                         continue
  173.                     
  174.  
  175.                     None<EXCEPTION MATCH>Q.Empty
  176.             finally:
  177.                 self._lock.release()
  178.  
  179.             self.paused = False
  180.         
  181.  
  182.     
  183.     def write(self, data):
  184.         if self.paused:
  185.             self._queue.put(data)
  186.         elif self._lock.acquire(0):
  187.             
  188.             try:
  189.                 self.stream.write(data)
  190.             finally:
  191.                 self._lock.release()
  192.  
  193.         else:
  194.             self._queue.put(data)
  195.         return len(data)
  196.  
  197.     
  198.     def flush(self):
  199.         if not self.paused:
  200.             self.unpause()
  201.         
  202.         return self.stream.flush()
  203.  
  204.     
  205.     def close(self):
  206.         return self.stream.close()
  207.  
  208.     
  209.     def tell(self):
  210.         return self.stream.tell()
  211.  
  212.  
  213.  
  214. class SwappableStream(PausableStream):
  215.     
  216.     def start_swap(self):
  217.         self.pause()
  218.         self.stream.flush()
  219.         self.stream.close()
  220.  
  221.     
  222.     def finish_swap(self, newstream):
  223.         self.stream = newstream
  224.         self.unpause()
  225.  
  226.  
  227.  
  228. class LimitedFileSize(SwappableStream):
  229.     
  230.     def __init__(self, fname, filesize_limit, resize, initmode = 'wb'):
  231.         fobj = open(fname, initmode)
  232.         if resize > filesize_limit:
  233.             raise ValueError('resize must be smaller than filesize_limit. (resize=%r, filesize_limit=%r)', resize, filesize_limit)
  234.         resize > filesize_limit
  235.         SwappableStream.__init__(self, fobj)
  236.         self._szlimit = filesize_limit
  237.         self._fname = fname
  238.         self._resize = resize
  239.         self._known_size = None
  240.  
  241.     
  242.     def write(self, data):
  243.         SwappableStream.write(self, data)
  244.         if self._known_size > self._szlimit:
  245.             self.start_swap()
  246.             
  247.             try:
  248.                 trim_file(self._fname, self._szlimit, self._resize)
  249.             finally:
  250.                 self.finish_swap(open(self._fname, 'ab'))
  251.  
  252.         
  253.  
  254.  
  255. from ratelimited import RateLimiter
  256.  
  257. class StreamLimiter(RateLimiter):
  258.     
  259.     def __init__(self, stream, limit = 4096, window = 5):
  260.         self.stream = stream
  261.         RateLimiter.__init__(self, self.stream.write, limit, window)
  262.  
  263.     
  264.     def write(self, data):
  265.         self.handle_data(data)
  266.  
  267.     
  268.     def flush(self):
  269.         return self.stream.flush()
  270.  
  271.     
  272.     def close(self):
  273.         return self.stream.close()
  274.  
  275.     
  276.     def tell(self):
  277.         return self.stream.tell()
  278.  
  279.     
  280.     def too_fast(self, data):
  281.         s = self.stream
  282.         s.write('Writing too fast: %r\n' % self.bps)
  283.         s.flush()
  284.  
  285.  
  286.  
  287. class DelayedStreamLimiter(StreamLimiter):
  288.     DELAY = 0.25
  289.     
  290.     def __init__(self, *a, **k):
  291.         StreamLimiter.__init__(self, *a, **k)
  292.         self._process_stop_time = 0
  293.  
  294.     
  295.     def handle_data(self, data):
  296.         should_write = None
  297.         if not StreamLimiter.handle_data(self, data):
  298.             now = time()
  299.             if self._process_stop_time == 0:
  300.                 if now - self._process_stop_time < self.DELAY:
  301.                     should_write = True
  302.                 else:
  303.                     self._process_stop_time = now
  304.                     should_write = False
  305.             elif now - self._process_stop_time < self.DELAY:
  306.                 should_write = True
  307.             else:
  308.                 should_write = False
  309.         else:
  310.             should_write = False
  311.             self._process_stop_time = 0
  312.         if should_write:
  313.             self.f_process(data)
  314.         
  315.         if should_write:
  316.             return True
  317.         if self._process_stop_time == 0:
  318.             return True
  319.         return False
  320.  
  321.  
  322.  
  323. class DisablingStream(object):
  324.     
  325.     def __init__(self, target):
  326.         self.target = target
  327.         self.write = self.write_enabled
  328.         self.flush = self.flush_enabled
  329.  
  330.     
  331.     def write_enabled(self, s):
  332.         
  333.         try:
  334.             self.target.write(s)
  335.         except:
  336.             self.disable()
  337.  
  338.  
  339.     
  340.     def flush_enabled(self):
  341.         
  342.         try:
  343.             self.target.flush()
  344.         except:
  345.             self.disable()
  346.  
  347.  
  348.     
  349.     def disable(self):
  350.         self.set_enabled(False)
  351.  
  352.     
  353.     def enable(self):
  354.         self.set_enabled(True)
  355.  
  356.     
  357.     def disabled(self, data = None):
  358.         pass
  359.  
  360.     
  361.     def set_enabled(self, val):
  362.         if val:
  363.             self.flush = self.flush_enabled
  364.             self.write = self.write_enabled
  365.         else:
  366.             self.flush = self.write = self.disabled
  367.  
  368.  
  369. if __name__ == '__main__':
  370.     from primitives.bits import getrandbytes
  371.     data = getrandbytes(100)
  372.     half_len = len(data) / 2
  373.     from StringIO import StringIO
  374.     in_ = StringIO(data)
  375.     out = None
  376.     
  377.     def reset(i):
  378.         i.seek(0)
  379.         return StringIO()
  380.  
  381.     
  382.     def check(i, o, l, w):
  383.         if i.getvalue()[:l] == o.getvalue():
  384.             pass
  385.         return w == l
  386.  
  387.     __test_stream_copy = '>>> out = reset(in_); written = streamcopy(in_, out); check(in_, out, len(data), written)\nTrue\n>>> out = reset(in_); written = streamcopy(in_, out, chunk = len(data)); check(in_, out, len(data), written)\nTrue\n>>> out = reset(in_); written = streamcopy(in_, out, limit = half_len); check(in_, out, half_len, written)\nTrue\n>>> out = reset(in_); written = streamcopy(in_, out, limit = half_len, chunk = half_len+1); check(in_, out, half_len, written)\nTrue\n>>> out = reset(in_); written = streamcopy(in_, out, limit = half_len, chunk = half_len-1); check(in_, out, half_len, written)\nTrue\n'
  388.     __test_tail = '>>> in_.seek(0); tail(in_, 5) == in_.getvalue()[-5:]\nTrue\n>>> in_.seek(0); tail(in_, 1000) == in_.getvalue()\nTrue\n'
  389.     __test__ = dict(streamcopy = __test_stream_copy, tail = __test_tail)
  390.     import doctest
  391.     doctest.testmod(verbose = True)
  392.     import sys
  393.     f = DelayedStreamLimiter(sys.stdout, limit = 8, window = 1)
  394.     import time as time_mod
  395.     for i in range(20):
  396.         f.write(str(i) + '\n')
  397.         time_mod.sleep(0.04 * i)
  398.     
  399.  
  400.