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