home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_656 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  12.2 KB  |  505 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import re
  5. import socket
  6. __all__ = [
  7.     'NNTP',
  8.     'NNTPReplyError',
  9.     'NNTPTemporaryError',
  10.     'NNTPPermanentError',
  11.     'NNTPProtocolError',
  12.     'NNTPDataError',
  13.     'error_reply',
  14.     'error_temp',
  15.     'error_perm',
  16.     'error_proto',
  17.     'error_data']
  18.  
  19. class NNTPError(Exception):
  20.     
  21.     def __init__(self, *args):
  22.         Exception.__init__(self, *args)
  23.         
  24.         try:
  25.             self.response = args[0]
  26.         except IndexError:
  27.             self.response = 'No response given'
  28.  
  29.  
  30.  
  31.  
  32. class NNTPReplyError(NNTPError):
  33.     pass
  34.  
  35.  
  36. class NNTPTemporaryError(NNTPError):
  37.     pass
  38.  
  39.  
  40. class NNTPPermanentError(NNTPError):
  41.     pass
  42.  
  43.  
  44. class NNTPProtocolError(NNTPError):
  45.     pass
  46.  
  47.  
  48. class NNTPDataError(NNTPError):
  49.     pass
  50.  
  51. error_reply = NNTPReplyError
  52. error_temp = NNTPTemporaryError
  53. error_perm = NNTPPermanentError
  54. error_proto = NNTPProtocolError
  55. error_data = NNTPDataError
  56. NNTP_PORT = 119
  57. LONGRESP = [
  58.     '100',
  59.     '215',
  60.     '220',
  61.     '221',
  62.     '222',
  63.     '224',
  64.     '230',
  65.     '231',
  66.     '282']
  67. CRLF = '\r\n'
  68.  
  69. class NNTP:
  70.     
  71.     def __init__(self, host, port = NNTP_PORT, user = None, password = None, readermode = None, usenetrc = True):
  72.         self.host = host
  73.         self.port = port
  74.         self.sock = socket.create_connection((host, port))
  75.         self.file = self.sock.makefile('rb')
  76.         self.debugging = 0
  77.         self.welcome = self.getresp()
  78.         readermode_afterauth = 0
  79.         if readermode:
  80.             
  81.             try:
  82.                 self.welcome = self.shortcmd('mode reader')
  83.             except NNTPPermanentError:
  84.                 pass
  85.             except NNTPTemporaryError:
  86.                 e = None
  87.                 if user and e.response[:3] == '480':
  88.                     readermode_afterauth = 1
  89.                 else:
  90.                     raise 
  91.                 e.response[:3] == '480'
  92.             
  93.  
  94.         None<EXCEPTION MATCH>NNTPPermanentError
  95.         
  96.         try:
  97.             if usenetrc and not user:
  98.                 import netrc
  99.                 credentials = netrc.netrc()
  100.                 auth = credentials.authenticators(host)
  101.                 if auth:
  102.                     user = auth[0]
  103.                     password = auth[2]
  104.                 
  105.         except IOError:
  106.             pass
  107.  
  108.         if user:
  109.             resp = self.shortcmd('authinfo user ' + user)
  110.             if resp[:3] == '381':
  111.                 if not password:
  112.                     raise NNTPReplyError(resp)
  113.                 password
  114.                 resp = self.shortcmd('authinfo pass ' + password)
  115.                 if resp[:3] != '281':
  116.                     raise NNTPPermanentError(resp)
  117.                 resp[:3] != '281'
  118.             
  119.             if readermode_afterauth:
  120.                 
  121.                 try:
  122.                     self.welcome = self.shortcmd('mode reader')
  123.                 except NNTPPermanentError:
  124.                     pass
  125.                 except:
  126.                     None<EXCEPTION MATCH>NNTPPermanentError
  127.                 
  128.  
  129.             None<EXCEPTION MATCH>NNTPPermanentError
  130.         
  131.  
  132.     
  133.     def getwelcome(self):
  134.         if self.debugging:
  135.             print '*welcome*', repr(self.welcome)
  136.         
  137.         return self.welcome
  138.  
  139.     
  140.     def set_debuglevel(self, level):
  141.         self.debugging = level
  142.  
  143.     debug = set_debuglevel
  144.     
  145.     def putline(self, line):
  146.         line = line + CRLF
  147.         if self.debugging > 1:
  148.             print '*put*', repr(line)
  149.         
  150.         self.sock.sendall(line)
  151.  
  152.     
  153.     def putcmd(self, line):
  154.         if self.debugging:
  155.             print '*cmd*', repr(line)
  156.         
  157.         self.putline(line)
  158.  
  159.     
  160.     def getline(self):
  161.         line = self.file.readline()
  162.         if self.debugging > 1:
  163.             print '*get*', repr(line)
  164.         
  165.         if not line:
  166.             raise EOFError
  167.         line
  168.         if line[-2:] == CRLF:
  169.             line = line[:-2]
  170.         elif line[-1:] in CRLF:
  171.             line = line[:-1]
  172.         
  173.         return line
  174.  
  175.     
  176.     def getresp(self):
  177.         resp = self.getline()
  178.         if self.debugging:
  179.             print '*resp*', repr(resp)
  180.         
  181.         c = resp[:1]
  182.         if c == '4':
  183.             raise NNTPTemporaryError(resp)
  184.         c == '4'
  185.         if c == '5':
  186.             raise NNTPPermanentError(resp)
  187.         c == '5'
  188.         if c not in '123':
  189.             raise NNTPProtocolError(resp)
  190.         c not in '123'
  191.         return resp
  192.  
  193.     
  194.     def getlongresp(self, file = None):
  195.         openedFile = None
  196.         
  197.         try:
  198.             if isinstance(file, str):
  199.                 openedFile = file = open(file, 'w')
  200.             
  201.             resp = self.getresp()
  202.             if resp[:3] not in LONGRESP:
  203.                 raise NNTPReplyError(resp)
  204.             resp[:3] not in LONGRESP
  205.             list = []
  206.             while None:
  207.                 line = self.getline()
  208.                 if line == '.':
  209.                     break
  210.                 
  211.                 if line[:2] == '..':
  212.                     line = line[1:]
  213.                 
  214.                 if file:
  215.                     file.write(line + '\n')
  216.                     continue
  217.                 list.append(line)
  218.             if openedFile:
  219.                 openedFile.close()
  220.             
  221.             return (resp, list)
  222.  
  223.  
  224.     
  225.     def shortcmd(self, line):
  226.         self.putcmd(line)
  227.         return self.getresp()
  228.  
  229.     
  230.     def longcmd(self, line, file = None):
  231.         self.putcmd(line)
  232.         return self.getlongresp(file)
  233.  
  234.     
  235.     def newgroups(self, date, time, file = None):
  236.         return self.longcmd('NEWGROUPS ' + date + ' ' + time, file)
  237.  
  238.     
  239.     def newnews(self, group, date, time, file = None):
  240.         cmd = 'NEWNEWS ' + group + ' ' + date + ' ' + time
  241.         return self.longcmd(cmd, file)
  242.  
  243.     
  244.     def list(self, file = None):
  245.         (resp, list) = self.longcmd('LIST', file)
  246.         for i in range(len(list)):
  247.             list[i] = tuple(list[i].split())
  248.         
  249.         return (resp, list)
  250.  
  251.     
  252.     def description(self, group):
  253.         (resp, lines) = self.descriptions(group)
  254.         if len(lines) == 0:
  255.             return ''
  256.         return lines[0][1]
  257.  
  258.     
  259.     def descriptions(self, group_pattern):
  260.         line_pat = re.compile('^(?P<group>[^ \t]+)[ \t]+(.*)$')
  261.         (resp, raw_lines) = self.longcmd('LIST NEWSGROUPS ' + group_pattern)
  262.         if resp[:3] != '215':
  263.             (resp, raw_lines) = self.longcmd('XGTITLE ' + group_pattern)
  264.         
  265.         lines = []
  266.         for raw_line in raw_lines:
  267.             match = line_pat.search(raw_line.strip())
  268.             if match:
  269.                 lines.append(match.group(1, 2))
  270.                 continue
  271.         
  272.         return (resp, lines)
  273.  
  274.     
  275.     def group(self, name):
  276.         resp = self.shortcmd('GROUP ' + name)
  277.         if resp[:3] != '211':
  278.             raise NNTPReplyError(resp)
  279.         resp[:3] != '211'
  280.         words = resp.split()
  281.         count = first = last = 0
  282.         n = len(words)
  283.         if n > 1:
  284.             count = words[1]
  285.             if n > 2:
  286.                 first = words[2]
  287.                 if n > 3:
  288.                     last = words[3]
  289.                     if n > 4:
  290.                         name = words[4].lower()
  291.                     
  292.                 
  293.             
  294.         
  295.         return (resp, count, first, last, name)
  296.  
  297.     
  298.     def help(self, file = None):
  299.         return self.longcmd('HELP', file)
  300.  
  301.     
  302.     def statparse(self, resp):
  303.         if resp[:2] != '22':
  304.             raise NNTPReplyError(resp)
  305.         resp[:2] != '22'
  306.         words = resp.split()
  307.         nr = 0
  308.         id = ''
  309.         n = len(words)
  310.         if n > 1:
  311.             nr = words[1]
  312.             if n > 2:
  313.                 id = words[2]
  314.             
  315.         
  316.         return (resp, nr, id)
  317.  
  318.     
  319.     def statcmd(self, line):
  320.         resp = self.shortcmd(line)
  321.         return self.statparse(resp)
  322.  
  323.     
  324.     def stat(self, id):
  325.         return self.statcmd('STAT ' + id)
  326.  
  327.     
  328.     def next(self):
  329.         return self.statcmd('NEXT')
  330.  
  331.     
  332.     def last(self):
  333.         return self.statcmd('LAST')
  334.  
  335.     
  336.     def artcmd(self, line, file = None):
  337.         (resp, list) = self.longcmd(line, file)
  338.         (resp, nr, id) = self.statparse(resp)
  339.         return (resp, nr, id, list)
  340.  
  341.     
  342.     def head(self, id):
  343.         return self.artcmd('HEAD ' + id)
  344.  
  345.     
  346.     def body(self, id, file = None):
  347.         return self.artcmd('BODY ' + id, file)
  348.  
  349.     
  350.     def article(self, id):
  351.         return self.artcmd('ARTICLE ' + id)
  352.  
  353.     
  354.     def slave(self):
  355.         return self.shortcmd('SLAVE')
  356.  
  357.     
  358.     def xhdr(self, hdr, str, file = None):
  359.         pat = re.compile('^([0-9]+) ?(.*)\n?')
  360.         (resp, lines) = self.longcmd('XHDR ' + hdr + ' ' + str, file)
  361.         for i in range(len(lines)):
  362.             line = lines[i]
  363.             m = pat.match(line)
  364.             if m:
  365.                 lines[i] = m.group(1, 2)
  366.                 continue
  367.         
  368.         return (resp, lines)
  369.  
  370.     
  371.     def xover(self, start, end, file = None):
  372.         (resp, lines) = self.longcmd('XOVER ' + start + '-' + end, file)
  373.         xover_lines = []
  374.         for line in lines:
  375.             elem = line.split('\t')
  376.             
  377.             try:
  378.                 xover_lines.append((elem[0], elem[1], elem[2], elem[3], elem[4], elem[5].split(), elem[6], elem[7]))
  379.             continue
  380.             except IndexError:
  381.                 raise NNTPDataError(line)
  382.                 continue
  383.             
  384.  
  385.         
  386.         return (resp, xover_lines)
  387.  
  388.     
  389.     def xgtitle(self, group, file = None):
  390.         line_pat = re.compile('^([^ \t]+)[ \t]+(.*)$')
  391.         (resp, raw_lines) = self.longcmd('XGTITLE ' + group, file)
  392.         lines = []
  393.         for raw_line in raw_lines:
  394.             match = line_pat.search(raw_line.strip())
  395.             if match:
  396.                 lines.append(match.group(1, 2))
  397.                 continue
  398.         
  399.         return (resp, lines)
  400.  
  401.     
  402.     def xpath(self, id):
  403.         resp = self.shortcmd('XPATH ' + id)
  404.         if resp[:3] != '223':
  405.             raise NNTPReplyError(resp)
  406.         resp[:3] != '223'
  407.         
  408.         try:
  409.             (resp_num, path) = resp.split()
  410.         except ValueError:
  411.             raise NNTPReplyError(resp)
  412.  
  413.         return (resp, path)
  414.  
  415.     
  416.     def date(self):
  417.         resp = self.shortcmd('DATE')
  418.         if resp[:3] != '111':
  419.             raise NNTPReplyError(resp)
  420.         resp[:3] != '111'
  421.         elem = resp.split()
  422.         if len(elem) != 2:
  423.             raise NNTPDataError(resp)
  424.         len(elem) != 2
  425.         date = elem[1][2:8]
  426.         time = elem[1][-6:]
  427.         if len(date) != 6 or len(time) != 6:
  428.             raise NNTPDataError(resp)
  429.         len(time) != 6
  430.         return (resp, date, time)
  431.  
  432.     
  433.     def post(self, f):
  434.         resp = self.shortcmd('POST')
  435.         if resp[0] != '3':
  436.             raise NNTPReplyError(resp)
  437.         resp[0] != '3'
  438.         while None:
  439.             line = f.readline()
  440.             if not line:
  441.                 break
  442.             
  443.             if line[-1] == '\n':
  444.                 line = line[:-1]
  445.             
  446.             if line[:1] == '.':
  447.                 line = '.' + line
  448.             
  449.             continue
  450.             self.putline('.')
  451.             return self.getresp()
  452.  
  453.     
  454.     def ihave(self, id, f):
  455.         resp = self.shortcmd('IHAVE ' + id)
  456.         if resp[0] != '3':
  457.             raise NNTPReplyError(resp)
  458.         resp[0] != '3'
  459.         while None:
  460.             line = f.readline()
  461.             if not line:
  462.                 break
  463.             
  464.             if line[-1] == '\n':
  465.                 line = line[:-1]
  466.             
  467.             if line[:1] == '.':
  468.                 line = '.' + line
  469.             
  470.             continue
  471.             self.putline('.')
  472.             return self.getresp()
  473.  
  474.     
  475.     def quit(self):
  476.         resp = self.shortcmd('QUIT')
  477.         self.file.close()
  478.         self.sock.close()
  479.         del self.file
  480.         del self.sock
  481.         return resp
  482.  
  483.  
  484. if __name__ == '__main__':
  485.     import os
  486.     if 'news':
  487.         pass
  488.     newshost = os.environ['NNTPSERVER']
  489.     if newshost.find('.') == -1:
  490.         mode = 'readermode'
  491.     else:
  492.         mode = None
  493.     s = NNTP(newshost, readermode = mode)
  494.     (resp, count, first, last, name) = s.group('comp.lang.python')
  495.     print resp
  496.     print 'Group', name, 'has', count, 'articles, range', first, 'to', last
  497.     (resp, subs) = s.xhdr('subject', first + '-' + last)
  498.     print resp
  499.     for item in subs:
  500.         print '%7s %s' % item
  501.     
  502.     resp = s.quit()
  503.     print resp
  504.  
  505.