home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_265 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  6.6 KB  |  241 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import socket
  5. import asyncore
  6. from collections import deque
  7. from sys import py3kwarning
  8. from warnings import filterwarnings, catch_warnings
  9.  
  10. class async_chat(asyncore.dispatcher):
  11.     ac_in_buffer_size = 4096
  12.     ac_out_buffer_size = 4096
  13.     
  14.     def __init__(self, sock = None, map = None):
  15.         self.ac_in_buffer = ''
  16.         self.incoming = []
  17.         self.producer_fifo = deque()
  18.         asyncore.dispatcher.__init__(self, sock, map)
  19.  
  20.     
  21.     def collect_incoming_data(self, data):
  22.         raise NotImplementedError('must be implemented in subclass')
  23.  
  24.     
  25.     def _collect_incoming_data(self, data):
  26.         self.incoming.append(data)
  27.  
  28.     
  29.     def _get_data(self):
  30.         d = ''.join(self.incoming)
  31.         del self.incoming[:]
  32.         return d
  33.  
  34.     
  35.     def found_terminator(self):
  36.         raise NotImplementedError('must be implemented in subclass')
  37.  
  38.     
  39.     def set_terminator(self, term):
  40.         self.terminator = term
  41.  
  42.     
  43.     def get_terminator(self):
  44.         return self.terminator
  45.  
  46.     
  47.     def handle_read(self):
  48.         
  49.         try:
  50.             data = self.recv(self.ac_in_buffer_size)
  51.         except socket.error:
  52.             why = None
  53.             self.handle_error()
  54.             return None
  55.  
  56.         self.ac_in_buffer = self.ac_in_buffer + data
  57.         while self.ac_in_buffer:
  58.             lb = len(self.ac_in_buffer)
  59.             terminator = self.get_terminator()
  60.             if not terminator:
  61.                 self.collect_incoming_data(self.ac_in_buffer)
  62.                 self.ac_in_buffer = ''
  63.                 continue
  64.             if isinstance(terminator, int) or isinstance(terminator, long):
  65.                 n = terminator
  66.                 if lb < n:
  67.                     self.collect_incoming_data(self.ac_in_buffer)
  68.                     self.ac_in_buffer = ''
  69.                     self.terminator = self.terminator - lb
  70.                 else:
  71.                     self.collect_incoming_data(self.ac_in_buffer[:n])
  72.                     self.ac_in_buffer = self.ac_in_buffer[n:]
  73.                     self.terminator = 0
  74.                     self.found_terminator()
  75.             lb < n
  76.             terminator_len = len(terminator)
  77.             index = self.ac_in_buffer.find(terminator)
  78.             if index != -1:
  79.                 if index > 0:
  80.                     self.collect_incoming_data(self.ac_in_buffer[:index])
  81.                 
  82.                 self.ac_in_buffer = self.ac_in_buffer[index + terminator_len:]
  83.                 self.found_terminator()
  84.                 continue
  85.             index = find_prefix_at_end(self.ac_in_buffer, terminator)
  86.             if index:
  87.                 if index != lb:
  88.                     self.collect_incoming_data(self.ac_in_buffer[:-index])
  89.                     self.ac_in_buffer = self.ac_in_buffer[-index:]
  90.                 
  91.                 break
  92.                 continue
  93.             self.collect_incoming_data(self.ac_in_buffer)
  94.             self.ac_in_buffer = ''
  95.  
  96.     
  97.     def handle_write(self):
  98.         self.initiate_send()
  99.  
  100.     
  101.     def handle_close(self):
  102.         self.close()
  103.  
  104.     
  105.     def push(self, data):
  106.         sabs = self.ac_out_buffer_size
  107.         if len(data) > sabs:
  108.             for i in xrange(0, len(data), sabs):
  109.                 self.producer_fifo.append(data[i:i + sabs])
  110.             
  111.         else:
  112.             self.producer_fifo.append(data)
  113.         self.initiate_send()
  114.  
  115.     
  116.     def push_with_producer(self, producer):
  117.         self.producer_fifo.append(producer)
  118.         self.initiate_send()
  119.  
  120.     
  121.     def readable(self):
  122.         return 1
  123.  
  124.     
  125.     def writable(self):
  126.         if not self.producer_fifo:
  127.             pass
  128.         return not (self.connected)
  129.  
  130.     
  131.     def close_when_done(self):
  132.         self.producer_fifo.append(None)
  133.  
  134.     
  135.     def initiate_send(self):
  136.         while self.producer_fifo and self.connected:
  137.             first = self.producer_fifo[0]
  138.             if not first:
  139.                 del self.producer_fifo[0]
  140.                 if first is None:
  141.                     self.handle_close()
  142.                     return None
  143.             
  144.             obs = self.ac_out_buffer_size
  145.             
  146.             try:
  147.                 catch_warnings().__enter__()
  148.                 
  149.                 try:
  150.                     data = buffer(first, 0, obs)
  151.                 finally:
  152.                     pass
  153.  
  154.             except TypeError:
  155.                 data = first.more()
  156.                 if data:
  157.                     self.producer_fifo.appendleft(data)
  158.                     continue
  159.                 del self.producer_fifo[0]
  160.                 continue
  161.  
  162.             
  163.             try:
  164.                 num_sent = self.send(data)
  165.             except socket.error:
  166.                 self.handle_error()
  167.                 return None
  168.  
  169.             if num_sent:
  170.                 if num_sent < len(data) or obs < len(first):
  171.                     self.producer_fifo[0] = first[num_sent:]
  172.                 else:
  173.                     del self.producer_fifo[0]
  174.             
  175.             return None
  176.  
  177.     
  178.     def discard_buffers(self):
  179.         self.ac_in_buffer = ''
  180.         del self.incoming[:]
  181.         self.producer_fifo.clear()
  182.  
  183.  
  184.  
  185. class simple_producer:
  186.     
  187.     def __init__(self, data, buffer_size = 512):
  188.         self.data = data
  189.         self.buffer_size = buffer_size
  190.  
  191.     
  192.     def more(self):
  193.         if len(self.data) > self.buffer_size:
  194.             result = self.data[:self.buffer_size]
  195.             self.data = self.data[self.buffer_size:]
  196.             return result
  197.         result = self.data
  198.         self.data = ''
  199.         return result
  200.  
  201.  
  202.  
  203. class fifo:
  204.     
  205.     def __init__(self, list = None):
  206.         if not list:
  207.             self.list = deque()
  208.         else:
  209.             self.list = deque(list)
  210.  
  211.     
  212.     def __len__(self):
  213.         return len(self.list)
  214.  
  215.     
  216.     def is_empty(self):
  217.         return not (self.list)
  218.  
  219.     
  220.     def first(self):
  221.         return self.list[0]
  222.  
  223.     
  224.     def push(self, data):
  225.         self.list.append(data)
  226.  
  227.     
  228.     def pop(self):
  229.         if self.list:
  230.             return (1, self.list.popleft())
  231.         return (0, None)
  232.  
  233.  
  234.  
  235. def find_prefix_at_end(haystack, needle):
  236.     l = len(needle) - 1
  237.     while l and not haystack.endswith(needle[:l]):
  238.         l -= 1
  239.     return l
  240.  
  241.