| # An NNTP client class.  Based on RFC 977: Network News Transfer | 
 | # Protocol, by Brian Kantor and Phil Lapsley. | 
 |  | 
 |  | 
 | # Example: | 
 | # | 
 | # >>> from nntplib import NNTP | 
 | # >>> s = NNTP('news') | 
 | # >>> resp, count, first, last, name = s.group('comp.lang.python') | 
 | # >>> print 'Group', name, 'has', count, 'articles, range', first, 'to', last | 
 | # Group comp.lang.python has 51 articles, range 5770 to 5821 | 
 | # >>> resp, subs = s.xhdr('subject', first + '-' + last) | 
 | # >>> resp = s.quit() | 
 | # >>> | 
 | # | 
 | # Here 'resp' is the server response line. | 
 | # Error responses are turned into exceptions. | 
 | # | 
 | # To post an article from a file: | 
 | # >>> f = open(filename, 'r') # file containing article, including header | 
 | # >>> resp = s.post(f) | 
 | # >>> | 
 | # | 
 | # For descriptions of all methods, read the comments in the code below. | 
 | # Note that all arguments and return values representing article numbers | 
 | # are strings, not numbers, since they are rarely used for calculations. | 
 |  | 
 | # (xover, xgtitle, xpath, date methods by Kevan Heydon) | 
 |  | 
 |  | 
 | # Imports | 
 | import re | 
 | import socket | 
 | import string | 
 |  | 
 |  | 
 | # Exception raised when an error or invalid response is received | 
 |  | 
 | error_reply = 'nntplib.error_reply'	# unexpected [123]xx reply | 
 | error_temp = 'nntplib.error_temp'	# 4xx errors | 
 | error_perm = 'nntplib.error_perm'	# 5xx errors | 
 | error_proto = 'nntplib.error_proto'	# response does not begin with [1-5] | 
 | error_data = 'nntplib.error_data'	# error in response data | 
 |  | 
 |  | 
 | # Standard port used by NNTP servers | 
 | NNTP_PORT = 119 | 
 |  | 
 |  | 
 | # Response numbers that are followed by additional text (e.g. article) | 
 | LONGRESP = ['100', '215', '220', '221', '222', '224', '230', '231', '282'] | 
 |  | 
 |  | 
 | # Line terminators (we always output CRLF, but accept any of CRLF, CR, LF) | 
 | CRLF = '\r\n' | 
 |  | 
 |  | 
 | # The class itself | 
 |  | 
 | class NNTP: | 
 |  | 
 | 	# Initialize an instance.  Arguments: | 
 | 	# - host: hostname to connect to | 
 | 	# - port: port to connect to (default the standard NNTP port) | 
 |  | 
 | 	def __init__(self, host, port = NNTP_PORT, user=None, password=None): | 
 | 		self.host = host | 
 | 		self.port = port | 
 | 		self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | 
 | 		self.sock.connect(self.host, self.port) | 
 | 		self.file = self.sock.makefile('rb') | 
 | 		self.debugging = 0 | 
 | 		self.welcome = self.getresp() | 
 | 		if user: | 
 | 			resp = self.shortcmd('authinfo user '+user) | 
 | 			if resp[:3] == '381': | 
 | 				if not password: | 
 | 					raise error_reply, resp | 
 | 				else: | 
 | 					resp = self.shortcmd( | 
 | 						'authinfo pass '+password) | 
 | 					if resp[:3] != '281': | 
 | 						raise error_perm, resp | 
 |  | 
 | 	# Get the welcome message from the server | 
 | 	# (this is read and squirreled away by __init__()). | 
 | 	# If the response code is 200, posting is allowed; | 
 | 	# if it 201, posting is not allowed | 
 |  | 
 | 	def getwelcome(self): | 
 | 		if self.debugging: print '*welcome*', `self.welcome` | 
 | 		return self.welcome | 
 |  | 
 | 	# Set the debugging level.  Argument level means: | 
 | 	# 0: no debugging output (default) | 
 | 	# 1: print commands and responses but not body text etc. | 
 | 	# 2: also print raw lines read and sent before stripping CR/LF | 
 |  | 
 | 	def set_debuglevel(self, level): | 
 | 		self.debugging = level | 
 | 	debug = set_debuglevel | 
 |  | 
 | 	# Internal: send one line to the server, appending CRLF | 
 | 	def putline(self, line): | 
 | 		line = line + CRLF | 
 | 		if self.debugging > 1: print '*put*', `line` | 
 | 		self.sock.send(line) | 
 |  | 
 | 	# Internal: send one command to the server (through putline()) | 
 | 	def putcmd(self, line): | 
 | 		if self.debugging: print '*cmd*', `line` | 
 | 		self.putline(line) | 
 |  | 
 | 	# Internal: return one line from the server, stripping CRLF. | 
 | 	# Raise EOFError if the connection is closed | 
 | 	def getline(self): | 
 | 		line = self.file.readline() | 
 | 		if self.debugging > 1: | 
 | 			print '*get*', `line` | 
 | 		if not line: raise EOFError | 
 | 		if line[-2:] == CRLF: line = line[:-2] | 
 | 		elif line[-1:] in CRLF: line = line[:-1] | 
 | 		return line | 
 |  | 
 | 	# Internal: get a response from the server. | 
 | 	# Raise various errors if the response indicates an error | 
 | 	def getresp(self): | 
 | 		resp = self.getline() | 
 | 		if self.debugging: print '*resp*', `resp` | 
 | 		c = resp[:1] | 
 | 		if c == '4': | 
 | 			raise error_temp, resp | 
 | 		if c == '5': | 
 | 			raise error_perm, resp | 
 | 		if c not in '123': | 
 | 			raise error_proto, resp | 
 | 		return resp | 
 |  | 
 | 	# Internal: get a response plus following text from the server. | 
 | 	# Raise various errors if the response indicates an error | 
 | 	def getlongresp(self): | 
 | 		resp = self.getresp() | 
 | 		if resp[:3] not in LONGRESP: | 
 | 			raise error_reply, resp | 
 | 		list = [] | 
 | 		while 1: | 
 | 			line = self.getline() | 
 | 			if line == '.': | 
 | 				break | 
 | 			if line[:2] == '..': | 
 | 				line = line[1:] | 
 | 			list.append(line) | 
 | 		return resp, list | 
 |  | 
 | 	# Internal: send a command and get the response | 
 | 	def shortcmd(self, line): | 
 | 		self.putcmd(line) | 
 | 		return self.getresp() | 
 |  | 
 | 	# Internal: send a command and get the response plus following text | 
 | 	def longcmd(self, line): | 
 | 		self.putcmd(line) | 
 | 		return self.getlongresp() | 
 |  | 
 | 	# Process a NEWGROUPS command.  Arguments: | 
 | 	# - date: string 'yymmdd' indicating the date | 
 | 	# - time: string 'hhmmss' indicating the time | 
 | 	# Return: | 
 | 	# - resp: server response if succesful | 
 | 	# - list: list of newsgroup names | 
 |  | 
 | 	def newgroups(self, date, time): | 
 | 		return self.longcmd('NEWGROUPS ' + date + ' ' + time) | 
 |  | 
 | 	# Process a NEWNEWS command.  Arguments: | 
 | 	# - group: group name or '*' | 
 | 	# - date: string 'yymmdd' indicating the date | 
 | 	# - time: string 'hhmmss' indicating the time | 
 | 	# Return: | 
 | 	# - resp: server response if succesful | 
 | 	# - list: list of article ids | 
 |  | 
 | 	def newnews(self, group, date, time): | 
 | 		cmd = 'NEWNEWS ' + group + ' ' + date + ' ' + time | 
 | 		return self.longcmd(cmd) | 
 |  | 
 | 	# Process a LIST command.  Return: | 
 | 	# - resp: server response if succesful | 
 | 	# - list: list of (group, last, first, flag) (strings) | 
 |  | 
 | 	def list(self): | 
 | 		resp, list = self.longcmd('LIST') | 
 | 		for i in range(len(list)): | 
 | 			# Parse lines into "group last first flag" | 
 | 			list[i] = tuple(string.split(list[i])) | 
 | 		return resp, list | 
 |  | 
 | 	# Process a GROUP command.  Argument: | 
 | 	# - group: the group name | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - count: number of articles (string) | 
 | 	# - first: first article number (string) | 
 | 	# - last: last article number (string) | 
 | 	# - name: the group name | 
 |  | 
 | 	def group(self, name): | 
 | 		resp = self.shortcmd('GROUP ' + name) | 
 | 		if resp[:3] <> '211': | 
 | 			raise error_reply, resp | 
 | 		words = string.split(resp) | 
 | 		count = first = last = 0 | 
 | 		n = len(words) | 
 | 		if n > 1: | 
 | 			count = words[1] | 
 | 			if n > 2: | 
 | 				first = words[2] | 
 | 				if n > 3: | 
 | 					last = words[3] | 
 | 					if n > 4: | 
 | 						name = string.lower(words[4]) | 
 | 		return resp, count, first, last, name | 
 |  | 
 | 	# Process a HELP command.  Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - list: list of strings | 
 |  | 
 | 	def help(self): | 
 | 		return self.longcmd('HELP') | 
 |  | 
 | 	# Internal: parse the response of a STAT, NEXT or LAST command | 
 | 	def statparse(self, resp): | 
 | 		if resp[:2] <> '22': | 
 | 			raise error_reply, resp | 
 | 		words = string.split(resp) | 
 | 		nr = 0 | 
 | 		id = '' | 
 | 		n = len(words) | 
 | 		if n > 1: | 
 | 			nr = words[1] | 
 | 			if n > 2: | 
 | 				id = string.lower(words[2]) | 
 | 		return resp, nr, id | 
 |  | 
 | 	# Internal: process a STAT, NEXT or LAST command | 
 | 	def statcmd(self, line): | 
 | 		resp = self.shortcmd(line) | 
 | 		return self.statparse(resp) | 
 |  | 
 | 	# Process a STAT command.  Argument: | 
 | 	# - id: article number or message id | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - nr:   the article number | 
 | 	# - id:   the article id | 
 |  | 
 | 	def stat(self, id): | 
 | 		return self.statcmd('STAT ' + id) | 
 |  | 
 | 	# Process a NEXT command.  No arguments.  Return as for STAT | 
 |  | 
 | 	def next(self): | 
 | 		return self.statcmd('NEXT') | 
 |  | 
 | 	# Process a LAST command.  No arguments.  Return as for STAT | 
 |  | 
 | 	def last(self): | 
 | 		return self.statcmd('LAST') | 
 |  | 
 | 	# Internal: process a HEAD, BODY or ARTICLE command | 
 | 	def artcmd(self, line): | 
 | 		resp, list = self.longcmd(line) | 
 | 		resp, nr, id = self.statparse(resp) | 
 | 		return resp, nr, id, list | 
 |  | 
 | 	# Process a HEAD command.  Argument: | 
 | 	# - id: article number or message id | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - nr: article number | 
 | 	# - id: message id | 
 | 	# - list: the lines of the article's header | 
 |  | 
 | 	def head(self, id): | 
 | 		return self.artcmd('HEAD ' + id) | 
 |  | 
 | 	# Process a BODY command.  Argument: | 
 | 	# - id: article number or message id | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - nr: article number | 
 | 	# - id: message id | 
 | 	# - list: the lines of the article's body | 
 |  | 
 | 	def body(self, id): | 
 | 		return self.artcmd('BODY ' + id) | 
 |  | 
 | 	# Process an ARTICLE command.  Argument: | 
 | 	# - id: article number or message id | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - nr: article number | 
 | 	# - id: message id | 
 | 	# - list: the lines of the article | 
 |  | 
 | 	def article(self, id): | 
 | 		return self.artcmd('ARTICLE ' + id) | 
 |  | 
 | 	# Process a SLAVE command.  Returns: | 
 | 	# - resp: server response if succesful | 
 |  | 
 | 	def slave(self): | 
 | 		return self.shortcmd('SLAVE') | 
 |  | 
 | 	# Process an XHDR command (optional server extension).  Arguments: | 
 | 	# - hdr: the header type (e.g. 'subject') | 
 | 	# - str: an article nr, a message id, or a range nr1-nr2 | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - list: list of (nr, value) strings | 
 |  | 
 | 	def xhdr(self, hdr, str): | 
 | 		pat = re.compile('^([0-9]+) ?(.*)\n?') | 
 | 		resp, lines = self.longcmd('XHDR ' + hdr + ' ' + str) | 
 | 		for i in range(len(lines)): | 
 | 			line = lines[i] | 
 | 			m = pat.match(line) | 
 | 			if m: | 
 | 				lines[i] = m.group(1, 2) | 
 | 		return resp, lines | 
 |  | 
 | 	# Process an XOVER command (optional server extension) Arguments: | 
 | 	# - start: start of range | 
 | 	# - end: end of range | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - list: list of (art-nr, subject, poster, date, id, refrences, size, lines) | 
 |  | 
 | 	def xover(self,start,end): | 
 | 		resp, lines = self.longcmd('XOVER ' + start + '-' + end) | 
 | 		xover_lines = [] | 
 | 		for line in lines: | 
 | 			elem = string.splitfields(line,"\t") | 
 | 			try: | 
 | 				xover_lines.append((elem[0], | 
 | 						    elem[1], | 
 | 						    elem[2], | 
 | 						    elem[3], | 
 | 						    elem[4], | 
 | 						    string.split(elem[5]), | 
 | 						    elem[6], | 
 | 						    elem[7])) | 
 | 			except IndexError: | 
 | 				raise error_data,line | 
 | 		return resp,xover_lines | 
 |  | 
 | 	# Process an XGTITLE command (optional server extension) Arguments: | 
 | 	# - group: group name wildcard (i.e. news.*) | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# - list: list of (name,title) strings | 
 |  | 
 | 	def xgtitle(self, group): | 
 | 		line_pat = re.compile("^([^ \t]+)[ \t]+(.*)$") | 
 | 		resp, raw_lines = self.longcmd('XGTITLE ' + group) | 
 | 		lines = [] | 
 | 		for raw_line in raw_lines: | 
 | 			match = line_pat.search(string.strip(raw_line)) | 
 | 			if match: | 
 | 				lines.append(match.group(1, 2)) | 
 | 		return resp, lines | 
 |  | 
 | 	# Process an XPATH command (optional server extension) Arguments: | 
 | 	# - id: Message id of article | 
 | 	# Returns: | 
 | 	# resp: server response if succesful | 
 | 	# path: directory path to article | 
 |  | 
 | 	def xpath(self,id): | 
 | 		resp = self.shortcmd("XPATH " + id) | 
 | 		if resp[:3] <> '223': | 
 | 			raise error_reply, resp | 
 | 		try: | 
 | 			[resp_num, path] = string.split(resp) | 
 | 		except ValueError: | 
 | 			raise error_reply, resp | 
 | 		else: | 
 | 			return resp, path | 
 |  | 
 | 	# Process the DATE command. Arguments: | 
 | 	# None | 
 | 	# Returns: | 
 | 	# resp: server response if succesful | 
 | 	# date: Date suitable for newnews/newgroups commands etc. | 
 | 	# time: Time suitable for newnews/newgroups commands etc. | 
 |  | 
 | 	def date (self): | 
 | 		resp = self.shortcmd("DATE") | 
 | 		if resp[:3] <> '111': | 
 | 			raise error_reply, resp | 
 | 		elem = string.split(resp) | 
 | 		if len(elem) != 2: | 
 | 			raise error_data, resp | 
 | 		date = elem[1][2:8] | 
 | 		time = elem[1][-6:] | 
 | 		if len(date) != 6 or len(time) != 6: | 
 | 			raise error_data, resp | 
 | 		return resp, date, time | 
 |  | 
 |  | 
 | 	# Process a POST command.  Arguments: | 
 | 	# - f: file containing the article | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 |  | 
 | 	def post(self, f): | 
 | 		resp = self.shortcmd('POST') | 
 | 		# Raises error_??? if posting is not allowed | 
 | 		if resp[0] <> '3': | 
 | 			raise error_reply, resp | 
 | 		while 1: | 
 | 			line = f.readline() | 
 | 			if not line: | 
 | 				break | 
 | 			if line[-1] == '\n': | 
 | 				line = line[:-1] | 
 | 			if line[:1] == '.': | 
 | 				line = '.' + line | 
 | 			self.putline(line) | 
 | 		self.putline('.') | 
 | 		return self.getresp() | 
 |  | 
 | 	# Process an IHAVE command.  Arguments: | 
 | 	# - id: message-id of the article | 
 | 	# - f:  file containing the article | 
 | 	# Returns: | 
 | 	# - resp: server response if succesful | 
 | 	# Note that if the server refuses the article an exception is raised | 
 |  | 
 | 	def ihave(self, id, f): | 
 | 		resp = self.shortcmd('IHAVE ' + id) | 
 | 		# Raises error_??? if the server already has it | 
 | 		if resp[0] <> '3': | 
 | 			raise error_reply, resp | 
 | 		while 1: | 
 | 			line = f.readline() | 
 | 			if not line: | 
 | 				break | 
 | 			if line[-1] == '\n': | 
 | 				line = line[:-1] | 
 | 			if line[:1] == '.': | 
 | 				line = '.' + line | 
 | 			self.putline(line) | 
 | 		self.putline('.') | 
 | 		return self.getresp() | 
 |  | 
 | 	 # Process a QUIT command and close the socket.  Returns: | 
 | 	 # - resp: server response if succesful | 
 |  | 
 | 	def quit(self): | 
 | 		resp = self.shortcmd('QUIT') | 
 | 		self.file.close() | 
 | 		self.sock.close() | 
 | 		del self.file, self.sock | 
 | 		return resp | 
 |  | 
 |  | 
 | # Minimal test function | 
 | def _test(): | 
 | 	s = NNTP('news') | 
 | 	resp, count, first, last, name = s.group('comp.lang.python') | 
 | 	print resp | 
 | 	print 'Group', name, 'has', count, 'articles, range', first, 'to', last | 
 | 	resp, subs = s.xhdr('subject', first + '-' + last) | 
 | 	print resp | 
 | 	for item in subs: | 
 | 		print "%7s %s" % item | 
 | 	resp = s.quit() | 
 | 	print resp | 
 |  | 
 |  | 
 | # Run the test when run as a script | 
 | if __name__ == '__main__': | 
 | 	_test() |