Vega strike Python Modules doc: Message Class Reference

•All Data Structures Namespaces Files Functions Variables

Inheritance diagram for Message:

Public Member Functions
def	__init__

def	rewindbody

def	readheaders

def	isheader

def	islast

def	iscomment

def	getallmatchingheaders

def	getfirstmatchingheader

def	getrawheader

def	getheader

def	getheaders

def	getaddr

def	getaddrlist

def	getdate

def	getdate_tz

def	__len__

def	__getitem__

def	__setitem__

def	__delitem__

def	get

def	setdefault

def	has_key

def	keys

def	values

def	items

def	__str__

Data Fields
	fp

	seekable

	startofheaders

	startofbody

	dict

	unixfrom

	headers

	status

Static Public Attributes
	get = getheader

Detailed Description

Represents a single RFC 2822-compliant message.

Definition at line 81 of file rfc822.py.

Constructor & Destructor Documentation

def __init__	(	self,
		fp,
		seekable = `1`
	)

Initialize the class instance and read the headers.

Definition at line 84 of file rfc822.py.

References Message.headers.

 
     def __init__(self, fp, seekable = 1):
         """Initialize the class instance and read the headers."""
         if seekable == 1:
             # Exercise tell() to make sure it works
             # (and then assume seek() works, too)
             try:
                 fp.tell()
             except (AttributeError, IOError):
                 seekable = 0
             else:
                 seekable = 1
         self.fp = fp
         self.seekable = seekable
         self.startofheaders = None
         self.startofbody = None
         #
         if self.seekable:
             try:
                 self.startofheaders = self.fp.tell()
             except IOError:
                 self.seekable = 0
         #
         self.readheaders()
         #
         if self.seekable:
             try:
                 self.startofbody = self.fp.tell()
             except IOError:
                 self.seekable = 0

Member Function Documentation

def __delitem__	(	self,
		name
	)

Delete all occurrences of a specific header, if it is present.

Definition at line 406 of file rfc822.py.

 
     def __delitem__(self, name):
         """Delete all occurrences of a specific header, if it is present."""
         name = name.lower()
         if not self.dict.has_key(name):
             return
         del self.dict[name]
         name = name + ':'
         n = len(name)
         list = []
         hit = 0
         for i in range(len(self.headers)):
             line = self.headers[i]
             if line[:n].lower() == name:
                 hit = 1
             elif not line[:1].isspace():
                 hit = 0
             if hit:
                 list.append(i)
         list.reverse()
         for i in list:
             del self.headers[i]

def __getitem__	(	self,
		name
	)

Get a specific header, as from a dictionary.

Definition at line 388 of file rfc822.py.

 
     def __getitem__(self, name):
         """Get a specific header, as from a dictionary."""
         return self.dict[name.lower()]

def __len__ ( self)

Get the number of headers in a message.

Definition at line 384 of file rfc822.py.

 
     def __len__(self):
         """Get the number of headers in a message."""
         return len(self.dict)

def __setitem__	(	self,
		name,
		value
	)

Set the value of a header.

Note: This is not a perfect inversion of __getitem__, because any
changed headers get stuck at the end of the raw-headers list rather
than where the altered header was.

Definition at line 392 of file rfc822.py.

 
     def __setitem__(self, name, value):
         """Set the value of a header.
 
         Note: This is not a perfect inversion of __getitem__, because any
         changed headers get stuck at the end of the raw-headers list rather
         than where the altered header was.
         """
         del self[name] # Won't fail if it doesn't exist
         self.dict[name.lower()] = value
         text = name + ": " + value
         lines = text.split("\n")
         for line in lines:
             self.headers.append(line + "\n")

def __str__ ( self)

Definition at line 466 of file rfc822.py.

References Message.headers, BaseHTTPRequestHandler.headers, MiniFieldStorage.headers, FieldStorage.headers, and HTTP.headers.

 
     def __str__(self):
         str = ''
         for hdr in self.headers:
             str = str + hdr
         return str
 
 
 # Utility functions
 # -----------------
 
 # XXX Should fix unquote() and quote() to be really conformant.
 # XXX The inverses of the parse functions may also be useful.
 

def get	(	self,
		name,
		default = `""`
	)

Definition at line 428 of file rfc822.py.

 
     def get(self, name, default=""):
         name = name.lower()
         if self.dict.has_key(name):
             return self.dict[name]
         else:
             return default

def getaddr	(	self,
		name
	)

Get a single address from a header, as a tuple.

An example return value:
('Guido van Rossum', 'guido@cwi.nl')

Definition at line 322 of file rfc822.py.

 
     def getaddr(self, name):
         """Get a single address from a header, as a tuple.
 
         An example return value:
         ('Guido van Rossum', 'guido@cwi.nl')
         """
         # New, by Ben Escoto
         alist = self.getaddrlist(name)
         if alist:
             return alist[0]
         else:
             return (None, None)

def getaddrlist	(	self,
		name
	)

Get a list of addresses from a header.

Retrieves a list of addresses from a header, where each address is a
tuple as returned by getaddr().  Scans all named headers, so it works
properly with multiple To: or Cc: headers for example.

Definition at line 335 of file rfc822.py.

References Message.getaddr().

 
     def getaddrlist(self, name):
         """Get a list of addresses from a header.
 
         Retrieves a list of addresses from a header, where each address is a
         tuple as returned by getaddr().  Scans all named headers, so it works
         properly with multiple To: or Cc: headers for example.
         """
         raw = []
         for h in self.getallmatchingheaders(name):
             if h[0] in ' \t':
                 raw.append(h)
             else:
                 if raw:
                     raw.append(', ')
                 i = h.find(':')
                 if i > 0:
                     addr = h[i+1:]
                 raw.append(addr)
         alladdrs = ''.join(raw)
         a = AddrlistClass(alladdrs)
         return a.getaddrlist()

def getallmatchingheaders	(	self,
		name
	)

Find all header lines matching a given header name.

Look through the list of headers and find all lines matching a given
header name (and their continuation lines).  A list of the lines is
returned, without interpretation.  If the header does not occur, an
empty list is returned.  If the header occurs multiple times, all
occurrences are returned.  Case is not important in the header name.

Definition at line 227 of file rfc822.py.

 
     def getallmatchingheaders(self, name):
         """Find all header lines matching a given header name.
 
         Look through the list of headers and find all lines matching a given
         header name (and their continuation lines).  A list of the lines is
         returned, without interpretation.  If the header does not occur, an
         empty list is returned.  If the header occurs multiple times, all
         occurrences are returned.  Case is not important in the header name.
         """
         name = name.lower() + ':'
         n = len(name)
         list = []
         hit = 0
         for line in self.headers:
             if line[:n].lower() == name:
                 hit = 1
             elif not line[:1].isspace():
                 hit = 0
             if hit:
                 list.append(line)
         return list

def getdate	(	self,
		name
	)

Retrieve a date field from a header.

Retrieves a date field from the named header, returning a tuple
compatible with time.mktime().

Definition at line 357 of file rfc822.py.

 
     def getdate(self, name):
         """Retrieve a date field from a header.
 
         Retrieves a date field from the named header, returning a tuple
         compatible with time.mktime().
         """
         try:
             data = self[name]
         except KeyError:
             return None
         return parsedate(data)

def getdate_tz	(	self,
		name
	)

Retrieve a date field from a header as a 10-tuple.

The first 9 elements make up a tuple compatible with time.mktime(),
and the 10th is the offset of the poster's time zone from GMT/UTC.

Definition at line 369 of file rfc822.py.

 
     def getdate_tz(self, name):
         """Retrieve a date field from a header as a 10-tuple.
 
         The first 9 elements make up a tuple compatible with time.mktime(),
         and the 10th is the offset of the poster's time zone from GMT/UTC.
         """
         try:
             data = self[name]
         except KeyError:
             return None
         return parsedate_tz(data)
 

def getfirstmatchingheader	(	self,
		name
	)

Get the first header line matching name.

This is similar to getallmatchingheaders, but it returns only the
first matching header (and its continuation lines).

Definition at line 249 of file rfc822.py.

 
     def getfirstmatchingheader(self, name):
         """Get the first header line matching name.
 
         This is similar to getallmatchingheaders, but it returns only the
         first matching header (and its continuation lines).
         """
         name = name.lower() + ':'
         n = len(name)
         list = []
         hit = 0
         for line in self.headers:
             if hit:
                 if not line[:1].isspace():
                     break
             elif line[:n].lower() == name:
                 hit = 1
             if hit:
                 list.append(line)
         return list

def getheader	(	self,
		name,
		default = `None`
	)

Get the header value for a name.

This is the normal interface: it returns a stripped version of the
header value for a given header name, or None if it doesn't exist.
This uses the dictionary version which finds the *last* such header.

Definition at line 284 of file rfc822.py.

 
     def getheader(self, name, default=None):
         """Get the header value for a name.
 
         This is the normal interface: it returns a stripped version of the
         header value for a given header name, or None if it doesn't exist.
         This uses the dictionary version which finds the *last* such header.
         """
         try:
             return self.dict[name.lower()]
         except KeyError:
return default

def getheaders	(	self,
		name
	)

Get all values for a header.

This returns a list of values for headers given more than once; each
value in the result list is stripped in the same way as the result of
getheader().  If the header is not given, return an empty list.

Definition at line 297 of file rfc822.py.

References Message.getheader().

 
     def getheaders(self, name):
         """Get all values for a header.
 
         This returns a list of values for headers given more than once; each
         value in the result list is stripped in the same way as the result of
         getheader().  If the header is not given, return an empty list.
         """
         result = []
         current = ''
         have_header = 0
         for s in self.getallmatchingheaders(name):
             if s[0].isspace():
                 if current:
                     current = "%s\n %s" % (current, s.strip())
                 else:
                     current = s.strip()
             else:
                 if have_header:
                     result.append(current)
                 current = s[s.find(":") + 1:].strip()
                 have_header = 1
         if have_header:
             result.append(current)
         return result

def getrawheader	(	self,
		name
	)

A higher-level interface to getfirstmatchingheader().

Return a string containing the literal text of the header but with the
keyword stripped.  All leading, trailing and embedded whitespace is
kept in the string, however.  Return None if the header does not
occur.

Definition at line 269 of file rfc822.py.

References Message.getfirstmatchingheader().

 
     def getrawheader(self, name):
         """A higher-level interface to getfirstmatchingheader().
 
         Return a string containing the literal text of the header but with the
         keyword stripped.  All leading, trailing and embedded whitespace is
         kept in the string, however.  Return None if the header does not
         occur.
         """
 
         list = self.getfirstmatchingheader(name)
         if not list:
             return None
         list[0] = list[0][len(name) + 1:]
         return ''.join(list)

def has_key	(	self,
		name
	)

Determine whether a message contains the named header.

Definition at line 447 of file rfc822.py.

 
     def has_key(self, name):
         """Determine whether a message contains the named header."""
         return self.dict.has_key(name.lower())

def iscomment	(	self,
		line
	)

Determine whether a line should be skipped entirely.

You may override this method in order to use Message parsing on tagged
data in RFC 2822-like formats that support embedded comments or
free-text data.

Definition at line 218 of file rfc822.py.

 
     def iscomment(self, line):
         """Determine whether a line should be skipped entirely.
 
         You may override this method in order to use Message parsing on tagged
         data in RFC 2822-like formats that support embedded comments or
         free-text data.
         """
         return None

def isheader	(	self,
		line
	)

Determine whether a given line is a legal header.

This method should return the header name, suitably canonicalized.
You may override this method in order to use Message parsing on tagged
data in RFC 2822-like formats with special header formats.

Definition at line 195 of file rfc822.py.

 
     def isheader(self, line):
         """Determine whether a given line is a legal header.
 
         This method should return the header name, suitably canonicalized.
         You may override this method in order to use Message parsing on tagged
         data in RFC 2822-like formats with special header formats.
         """
         i = line.find(':')
         if i > 0:
             return line[:i].lower()
         else:
             return None

def islast	(	self,
		line
	)

Determine whether a line is a legal end of RFC 2822 headers.

You may override this method if your application wants to bend the
rules, e.g. to strip trailing whitespace, or to recognize MH template
separators ('--------').  For convenience (e.g. for code reading from
sockets) a line consisting of \r\n also matches.

Definition at line 208 of file rfc822.py.

 
     def islast(self, line):
         """Determine whether a line is a legal end of RFC 2822 headers.
 
         You may override this method if your application wants to bend the
         rules, e.g. to strip trailing whitespace, or to recognize MH template
         separators ('--------').  For convenience (e.g. for code reading from
         sockets) a line consisting of \r\n also matches.
         """
         return line in _blanklines

def items ( self)

Get all of a message's headers.

Returns a list of name, value tuples.

Definition at line 459 of file rfc822.py.

 
     def items(self):
         """Get all of a message's headers.
 
         Returns a list of name, value tuples.
         """
         return self.dict.items()

def keys ( self)

Get all of a message's header field names.

Definition at line 451 of file rfc822.py.

 
     def keys(self):
         """Get all of a message's header field names."""
         return self.dict.keys()

def readheaders ( self)

Read header lines.

Read header lines up to the entirely blank line that terminates them.
The (normally blank) line that ends the headers is skipped, but not
included in the returned list.  If a non-header line ends the headers,
(which is an error), an attempt is made to backspace over it; it is
never included in the returned list.

The variable self.status is set to the empty string if all went well,
otherwise it is an error message.  The variable self.headers is a
completely uninterpreted list of lines contained in the header (so
printing them will reproduce the header exactly as it appears in the
file).

Definition at line 120 of file rfc822.py.

References Message.headers, BaseHTTPRequestHandler.headers, MiniFieldStorage.headers, FieldStorage.headers, HTTP.headers, HTTPResponse.status, and Message.status.

 
     def readheaders(self):
         """Read header lines.
 
         Read header lines up to the entirely blank line that terminates them.
         The (normally blank) line that ends the headers is skipped, but not
         included in the returned list.  If a non-header line ends the headers,
         (which is an error), an attempt is made to backspace over it; it is
         never included in the returned list.
 
         The variable self.status is set to the empty string if all went well,
         otherwise it is an error message.  The variable self.headers is a
         completely uninterpreted list of lines contained in the header (so
         printing them will reproduce the header exactly as it appears in the
         file).
         """
         self.dict = {}
         self.unixfrom = ''
         self.headers = list = []
         self.status = ''
         headerseen = ""
         firstline = 1
         startofline = unread = tell = None
         if hasattr(self.fp, 'unread'):
             unread = self.fp.unread
         elif self.seekable:
             tell = self.fp.tell
         while 1:
             if tell:
                 try:
                     startofline = tell()
                 except IOError:
                     startofline = tell = None
                     self.seekable = 0
             line = self.fp.readline()
             if not line:
                 self.status = 'EOF in headers'
                 break
             # Skip unix From name time lines
             if firstline and line.startswith('From '):
                 self.unixfrom = self.unixfrom + line
                 continue
             firstline = 0
             if headerseen and line[0] in ' \t':
                 # It's a continuation line.
                 list.append(line)
                 x = (self.dict[headerseen] + "\n " + line.strip())
                 self.dict[headerseen] = x.strip()
                 continue
             elif self.iscomment(line):
                 # It's a comment.  Ignore it.
                 continue
             elif self.islast(line):
                 # Note! No pushback here!  The delimiter line gets eaten.
                 break
             headerseen = self.isheader(line)
             if headerseen:
                 # It's a legal header line, save it.
                 list.append(line)
                 self.dict[headerseen] = line[len(headerseen)+1:].strip()
                 continue
             else:
                 # It's not a header line; throw it back and stop here.
                 if not self.dict:
                     self.status = 'No headers'
                 else:
                     self.status = 'Non-header line where header expected'
                 # Try to undo the read.
                 if unread:
                     unread(line)
                 elif tell:
                     self.fp.seek(startofline)
                 else:
                     self.status = self.status + '; bad seek'
                 break

Public Member Functions

Data Fields

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation