Lots of organizational changes for consistency with the rest of the

documentation.

Fix a few small markup nits.

Doc/lib/liburllib2.tex

@@ -2,7 +2,6 @@
          extensible library for opening URLs}
 
 \declaremodule{standard}{urllib2}
-
 \moduleauthor{Jeremy Hylton}{jhylton@users.sourceforge.net}
 \sectionauthor{Moshe Zadka}{moshez@users.sourceforge.net}
 
@@ -10,7 +9,7 @@
                 protocols}
 
 The \module{urllib2} module defines functions and classes which help
-in opening URLs (mostly HTTP) in a complex world -- basic and digest
+in opening URLs (mostly HTTP) in a complex world --- basic and digest
 authentication, redirections and more.
 
 The \module{urllib2} module defines the following functions:
@@ -18,21 +17,20 @@ The \module{urllib2} module defines the following functions:
 \begin{funcdesc}{urlopen}{url\optional{, data}}
 Open the url \var{url}, which can either a string or a \class{Request}
 object (currently the code checks that it really is a \class{Request}
-instance, or an instance of a subclass of \class{Request}.
+instance, or an instance of a subclass of \class{Request}).
 
 \var{data} should be a string, which specifies additional data to
 send to the server. In HTTP requests, which are the only ones that
 support \var{data}, it should be a buffer in the format of
-\code{application/x-www-form-urlencoded}, for example one returned
+\mimetype{application/x-www-form-urlencoded}, for example one returned
-from \function{urllib.urlencode}.
+from \function{urllib.urlencode()}.
 
 This function returns a file-like object with two additional methods:
 
 \begin{itemize}
-
+  \item \method{geturl()} --- return the URL of the resource retrieved
-	\item \code{geturl()} --- return the URL of the resource retrieved
+  \item \method{info()} --- return the meta-information of the page, as
-	\item \code{info()} --- return the meta-information of the page, as
+                            a dictionary-like object
-                                a dictionary-like object
 \end{itemize}
 
 Raises \exception{URLError} on errors.
@@ -44,8 +42,7 @@ The code does not check for a real \class{OpenerDirector}, and any
 class with the appropriate interface will work.
 \end{funcdesc}
 
-\begin{funcdesc}{build_opener}{\optional{handler\optional{, 
+\begin{funcdesc}{build_opener}{\optional{handler, \moreargs}}
-                                         handler\optional{, ...}}}}
 Return an \class{OpenerDirector} instance, which chains the
 handlers in the order given. \var{handler}s can be either instances
 of \class{BaseHandler}, or subclasses of \class{BaseHandler} (in
@@ -57,20 +54,23 @@ them, instances of them or subclasses of them:
 \code{ProxyHandler, UnknownHandler, HTTPHandler, HTTPDefaultErrorHandler, 
       HTTPRedirectHandler, FTPHandler, FileHandler}
 
-If the Python installation has SSL support (\code{socket.ssl} exists),
+If the Python installation has SSL support (\function{socket.ssl()}
-\class{HTTPSHandler} will also be added.
+exists), \class{HTTPSHandler} will also be added.
 \end{funcdesc}
 
+
+The following exceptions are raised as appropriate:
+
 \begin{excdesc}{URLError}
-The error handlers raise when they run into a problem. It is a subclass
+The error handlers raise when they run into a problem. It is a
-of \exception{IOError}.
+subclass of \exception{IOError}.
 \end{excdesc}
 
 \begin{excdesc}{HTTPError}
 A subclass of \exception{URLError}, it can also function as a 
-non-exceptional file-like return value (the same thing that \function{urlopen}
+non-exceptional file-like return value (the same thing that
-returns). This is useful when handling exotic HTTP errors, such as
+\function{urlopen()} returns).  This is useful when handling exotic
-requests for authentications.
+HTTP errors, such as requests for authentication.
 \end{excdesc}
 
 \begin{excdesc}{GopherError}
@@ -78,22 +78,138 @@ A subclass of \exception{URLError}, this is the error raised by the
 Gopher handler.
 \end{excdesc}
 
-\begin{classdesc}{Request}{url\optional{data, \optional{, headers}}}
+
+The following classes are provided:
+
+\begin{classdesc}{Request}{url\optional{, data\optional{, headers}}}
 This class is an abstraction of a URL request.
 
 \var{url} should be a string which is a valid URL. For descrtion
-of \var{data} see the \method{add_data} description.
+of \var{data} see the \method{add_data()} description.
 \var{headers} should be a dictionary, and will be treated as if
-\method{add_header} was called with each key and value as arguments.
+\method{add_header()} was called with each key and value as arguments.
 \end{classdesc}
 
+\begin{classdesc}{OpenerDirector}{}
+The \class{OpenerDirector} class opens URLs via \class{BaseHandler}s
+chained together. It manages the chaining of handlers, and recovery
+from errors.
+\end{classdesc}
+
+\begin{classdesc}{BaseHandler}{}
+This is the base class for all registered handlers --- and handles only
+the simple mechanics of registration.
+\end{classdesc}
+
+\begin{classdesc}{HTTPDefaultErrorHandler}{}
+A class which defines a default handler for HTTP error responses; all
+responses are turned into \exception{HTTPError} exceptions.
+\end{classdesc}
+
+\begin{classdesc}{HTTPRedirectHandler}{}
+A class to handle redirections.
+\end{classdesc}
+
+\begin{classdesc}{ProxyHandler}{\optional{proxies}}
+Cause requests to go through a proxy.
+If \var{proxies} is given, it must be a dictionary mapping
+protocol names to URLs of proxies.
+The default is to read the list of proxies from the environment
+variables \envvar{\var{protocol}_proxy}.
+\end{classdesc}
+
+\begin{classdesc}{HTTPPasswordMgr}{}
+Keep a database of 
+\code{(\var{realm}, \var{uri}) -> (\var{user}, \var{password})}
+mappings.
+\end{classdesc}
+
+\begin{classdesc}{HTTPPasswordMgrWithDefaultRealm}{}
+Keep a database of 
+\code{(\var{realm}, \var{uri}) -> (\var{user}, \var{password})} mappings.
+A realm of \code{None} is considered a catch-all realm, which is searched
+if no other realm fits.
+\end{classdesc}
+
+\begin{classdesc}{AbstractBasicAuthHandler}{\optional{password_mgr}}
+This is a mixin class that helps with HTTP authentication, both
+to the remote host and to a proxy.
+
+\var{password_mgr} should be something that is compatible with
+\class{HTTPPasswordMgr} --- supplies the documented interface above.
+\end{classdesc}
+
+\begin{classdesc}{HTTPBasicAuthHandler}{\optional{password_mgr}}
+Handle authentication with the remote host.
+Valid \var{password_mgr}, if given, are the same as for
+\class{AbstractBasicAuthHandler}.
+\end{classdesc}
+
+\begin{classdesc}{ProxyBasicAuthHandler}{\optional{password_mgr}}
+Handle authentication with the proxy.
+Valid \var{password_mgr}, if given, are the same as for
+\class{AbstractBasicAuthHandler}.
+\end{classdesc}
+
+\begin{classdesc}{AbstractDigestAuthHandler}{\optional{password_mgr}}
+This is a mixin class, that helps with HTTP authentication, both
+to the remote host and to a proxy.
+
+\var{password_mgr} should be something that is compatible with
+\class{HTTPPasswordMgr} --- supplies the documented interface above.
+\end{classdesc}
+
+\begin{classdesc}{HTTPDigestAuthHandler}{\optional{password_mgr}}
+Handle authentication with the remote host.
+Valid \var{password_mgr}, if given, are the same as for
+\class{AbstractBasicAuthHandler}.
+\end{classdesc}
+
+\begin{classdesc}{ProxyDigestAuthHandler}{\optional{password_mgr}}
+Handle authentication with the proxy.
+\var{password_mgr}, if given, shoudl be the same as for 
+the constructor of \class{AbstractDigestAuthHandler}.
+\end{classdesc}
+
+\begin{classdesc}{HTTPHandler}{}
+A class to handle opening of HTTP URLs.
+\end{classdesc}
+
+\begin{classdesc}{HTTPSHandler}{}
+A class to handle opening of HTTPS URLs.
+\end{classdesc}
+
+\begin{classdesc}{FileHandler}{}
+Open local files.
+\end{classdesc}
+
+\begin{classdesc}{FTPHandler}{}
+Open FTP URLs.
+\end{classdesc}
+
+\begin{classdesc}{CacheFTPHandler}{}
+Open FTP URLs, keeping a cache of open FTP connections to minimize
+delays.
+\end{classdesc}
+
+\begin{classdesc}{GopherHandler}{}
+Open gopher URLs.
+\end{classdesc}
+
+\begin{classdesc}{UnknownHandler}{}
+A catch-all class to handle unknown URLs.
+\end{classdesc}
+
+
+\subsection{Request Objects \label{request-objects}}
+
 The following methods describe all of \class{Request}'s public interface,
 and so all must be overridden in subclasses.
 
 \begin{methoddesc}[Request]{add_data}{data}
 Set the \class{Request} data to \var{data} is ignored
 by all handlers except HTTP handlers --- and there it should be an
-\code{application/x-www-form-encoded} buffer, and will change the
+\mimetype{application/x-www-form-encoded} buffer, and will change the
 request to be \code{POST} rather then \code{GET}. 
 \end{methoddesc}
 
@@ -106,12 +222,12 @@ Return the instance's data.
 \end{methoddesc}
 
 \begin{methoddesc}[Request]{add_header}{key, val}
-Add another header to the request. Headers
+Add another header to the request.  Headers are currently ignored by
-are currently ignored by all handlers except HTTP handlers, where they
+all handlers except HTTP handlers, where they are added to the list
-are added to the list of headers sent to the server. Note that there
+of headers sent to the server.  Note that there cannot be more then
-cannot be more then one header with the same name, and later calls
+one header with the same name, and later calls will overwrite
-will overwrite previous calls in case the \var{key} collides. Currently, 
+previous calls in case the \var{key} collides.  Currently, this is
-this is no loss of HTTP functionality, since all headers which have meaning
+no loss of HTTP functionality, since all headers which have meaning
 when used more then once have a (header-specific) way of gaining the
 same functionality using only one header.
 \end{methoddesc}
@@ -121,7 +237,7 @@ Return the URL given in the constructor.
 \end{methoddesc}
 
 \begin{methoddesc}[Request]{get_type}{}
-Return the type of the URL --- also known as the schema.
+Return the type of the URL --- also known as the scheme.
 \end{methoddesc}
 
 \begin{methoddesc}[Request]{get_host}{}
@@ -134,28 +250,27 @@ the server.
 \end{methoddesc}
 
 \begin{methoddesc}[Request]{set_proxy}{host, type}
-Make the request by connecting to a proxy server. The \var{host} and \var{type}
+Make the request by connecting to a proxy server. The \var{host} and
-will replace those of the instance, and the instance's selector will be
+\var{type} will replace those of the instance, and the instance's
-the original URL given in the constructor.
+selector will be the original URL given in the constructor.
 \end{methoddesc}
 
-\begin{classdesc}{OpenerDirector}{}
+
-The \class{OpenerDirector} class opens URLs via \class{BaseHandler}s chained
+\subsection{OpenerDirector Objects \label{opener-director-objects}}
-together. It manages the chaining of handlers, and recovery from errors.
+
-\end{classdesc}
+\class{OpenerDirector} instances have the following methods:
 
 \begin{methoddesc}[OpenerDirector]{add_handler}{handler}
-\var{handler} should be an instance of \class{BaseHandler}. The following
+\var{handler} should be an instance of \class{BaseHandler}.  The
-methods are searched, and added to the possible chains.
+following methods are searched, and added to the possible chains.
 
 \begin{itemize}
-	\item \code{{\em protocol}_open} --- signal that the handler knows how
+  \item \method{\var{protocol}_open()} ---
-                                             to open {\em protocol} URLs.
+    signal that the handler knows how to open \var{protocol} URLs.
-	\item \code{{\em protocol}_error_{\em type}} -- signal that the handler
+  \item \method{\var{protocol}_error_\var{type}()} ---
-                                             knows how to handle {\em type}
+    signal that the handler knows how to handle \var{type} errors from
-	                                     errors from {\em protocol}.
+    \var{protocol}.
 \end{itemize}
-
 \end{methoddesc}
 
 \begin{methoddesc}[OpenerDirector]{close}{}
@@ -171,23 +286,26 @@ the cycles.
 Open the given \var{url}. (which can be a request object or a string),
 optionally passing the given \var{data}.
 Arguments, return values and exceptions raised are the same as those
-of \function{urlopen} (which simply calls the \method{open()} method
+of \function{urlopen()} (which simply calls the \method{open()} method
 on the default installed \class{OpenerDirector}.
 \end{methoddesc}
 
-\begin{methoddesc}[OpenerDirector]{error}{proto\optional{, arg\optional{, ...}}}
+\begin{methoddesc}[OpenerDirector]{error}{proto\optional{,
+                                          arg\optional{, \moreargs}}}
 Handle an error in a given protocol. The HTTP protocol is special cased to
 use the code as the error. This will call the registered error handlers
 for the given protocol with the given arguments (which are protocol specific).
 
 Return values and exceptions raised are the same as those
-of \function{urlopen}.
+of \function{urlopen()}.
 \end{methoddesc}
 
-\begin{classdesc}{BaseHandler}{}
+
-This is the base class for all registered handlers --- and handles only
+\subsection{BaseHandler Objects \label{base-handler-objects}}
-the simple mechanics of registration.
+
-\end{classdesc}
+\class{BaseHandler} objects provide a couple of methods that are
+directly useful, and others that are meant to be used by derived
+classes.  These are intended for direct use:
 
 \begin{methoddesc}[BaseHandler]{add_parent}{director}
 Add a director as parent.
@@ -197,168 +315,136 @@ Add a director as parent.
 Remove any parents.
 \end{methoddesc}
 
-The following members and methods should be used only be classes derived
+The following members and methods should be used only be classes
-from \class{BaseHandler}:
+derived from \class{BaseHandler}:
 
 \begin{memberdesc}[BaseHandler]{parent}
-A valid \class{OpenerDirector}, which can be used to open using a different
+A valid \class{OpenerDirector}, which can be used to open using a
-protocol, or handle errors.
+different protocol, or handle errors.
 \end{memberdesc}
 
 \begin{methoddesc}[BaseHandler]{default_open}{req}
-This method is {\em not} defined in \class{BaseHandler}, but subclasses
+This method is \emph{not} defined in \class{BaseHandler}, but
-should define it if they want to catch all URLs.
+subclasses should define it if they want to catch all URLs.
 
 This method, if exists, will be called by the \member{parent}
-\class{OpenerDirector}. It should return a file-like object as described
+\class{OpenerDirector}.  It should return a file-like object as
-in the return value of the \method{open} of \class{OpenerDirector} or
+described in the return value of the \method{open()} of
-\code{None}. It should raise \exception{URLError}, unless a truly exceptional
+\class{OpenerDirector} or \code{None}.  It should raise
-thing happens (for example, \exception{MemoryError} should not be mapped
+\exception{URLError}, unless a truly exceptional thing happens (for
-to \exception{URLError}.
+example, \exception{MemoryError} should not be mapped to
+\exception{URLError}.
 
 This method will be called before any protocol-specific open method.
 \end{methoddesc}
 
-\begin{methoddesc}[BaseHandler]{{\em protocol}_open}{req}
+\begin{methoddesc}[BaseHandler]{\var{protocol}_open}{req}
-This method is {\em not} defined in \class{BaseHandler}, but subclasses
+This method is \emph{not} defined in \class{BaseHandler}, but
-should define it if they want to handle URLs with the given protocol.
+subclasses should define it if they want to handle URLs with the given
+protocol.
 
-This method, if exists, will be called by the \member{parent} 
+This method, if defined, will be called by the \member{parent} 
-\class{OpenerDirector}. Return values should be the same as for 
+\class{OpenerDirector}.  Return values should be the same as for 
-\method{default_open}.
+\method{default_open()}.
 \end{methoddesc}
 
 \begin{methoddesc}[BaseHandler]{unknown_open}{req}
-This method is {\em not} defined in \class{BaseHandler}, but subclasses
+This method is \var{not} defined in \class{BaseHandler}, but
-should define it if they want to catch all URLs with no specific
+subclasses should define it if they want to catch all URLs with no
-registerd handler to open it.
+specific registerd handler to open it.
 
 This method, if exists, will be called by the \member{parent} 
-\class{OpenerDirector}. Return values should be the same as for 
+\class{OpenerDirector}.  Return values should be the same as for 
-\method{default_open}.
+\method{default_open()}.
 \end{methoddesc}
 
 \begin{methoddesc}[BaseHandler]{http_error_default}{req, fp, code, msg, hdrs}
-This method is {\em not} defined in \class{BaseHandler}, but subclasses
+This method is \emph{not} defined in \class{BaseHandler}, but
-should override it if they intend to provide a catch-all for otherwise
+subclasses should override it if they intend to provide a catch-all
-unhandled HTTP errors. It will be called automatically by the 
+for otherwise unhandled HTTP errors.  It will be called automatically
-\class{OpenerDirector} getting the error, and should not normally be called
+by the  \class{OpenerDirector} getting the error, and should not
-in other circumstances.
+normally be called in other circumstances.
 
-\var{req} will be a \class{Request} object, \var{fp} will be a file-like
+\var{req} will be a \class{Request} object, \var{fp} will be a
-object with the HTTP error body, \var{code} will be the three-digit code
+file-like object with the HTTP error body, \var{code} will be the
-of the error, \var{msg} will be the user-visible explanation of the
+three-digit code of the error, \var{msg} will be the user-visible
-code and \var{hdrs} will be a dictionary-like object with the headers of
+explanation of the code and \var{hdrs} will be a mapping object with
-the error.
+the headers of the error.
 
 Return values and exceptions raised should be the same as those
-of \function{urlopen}.
+of \function{urlopen()}.
 \end{methoddesc}
 
-\begin{methoddesc}[BaseHandler]{http_error_{\em nnn}}{req, fp, code, msg, hdrs}
+\begin{methoddesc}[BaseHandler]{http_error_\var{nnn}}{req, fp, code, msg, hdrs}
-\code{nnn} should be a three-digit HTTP error code. This method is also
+\var{nnn} should be a three-digit HTTP error code.  This method is
-not defined in \class{BaseHandler}, but will be called, if it exists, on
+also not defined in \class{BaseHandler}, but will be called, if it
-an instance of a subclass, when an HTTP error with code \code{nnn} occurse.
+exists, on an instance of a subclass, when an HTTP error with code
+\var{nnn} occurs.
 
-Subclasses should override this method to handle specific HTTP errors.
+Subclasses should override this method to handle specific HTTP
+errors.
 
-Arguments, return values and exceptions raised shoudl be the same as for
+Arguments, return values and exceptions raised should be the same as
-\method{http_error_default}
+for \method{http_error_default()}.
 \end{methoddesc}
 
 
-\begin{classdesc}{HTTPDefaultErrorHandler}{}
+\subsection{HTTPRedirectHandler Objects \label{http-redirect-handler}}
-A class which catches all HTTP errors.
-\end{classdesc}
-
-\begin{methoddesc}[HTTPDefaultErrorHandler]{http_error_default}{req, fp, code, 
-                                                                msg, hdrs}
-Raise an \exception{HTTPError}
-\end{methoddesc}
-
-\begin{classdesc}{HTTPRedirectHandler}{}
-A class to handle redirections.
-\end{classdesc}
-
-\begin{methoddesc}[HTTPRedirectHandler]{http_error_301}{req, fp, code, 
-                                                        msg, hdrs}
-Redirect to the \code{Location:} URL. This method gets called by
-the parent \class{OpenerDirector} when getting an HTTP permanent-redirect
-error.
-\end{methoddesc}
-
-\begin{methoddesc}[HTTPRedirectHandler]{http_error_302}{req, fp, code, 
-                                                        msg, hdrs}
-The same as \method{http_error_301}.
-\end{methoddesc}
 
 \strong{Note:} 303 redirection is not supported by this version of 
 \module{urllib2}.
 
-\begin{classdesc}{ProxyHandler}{\optional{proxies}}
+\begin{methoddesc}[HTTPRedirectHandler]{http_error_301}{req,
-Cause requests to go through a proxy.
+                                                  fp, code, msg, hdrs}
-If \var{proxies} is given, it must be a dictionary mapping
+Redirect to the \code{Location:} URL.  This method is called by
-protocol names to URLs of proxies.
+the parent \class{OpenerDirector} when getting an HTTP
-The default is to read the list of proxies from the environment
+permanent-redirect response.
-variables \code{{\em protocol}_proxy}.
-\end{classdesc}
-
-\begin{methoddesc}[ProxyHandler]{{\em protocol}_open}{request}
-The \class{ProxyHandler} will have a method \code{{\em protocol}_open} for
-every {\em protocol} which has a proxy in the \var{proxies} dictionary
-given in the constructor. The method will modify requests to go
-through the proxy, by calling \code{request.set_proxy()}, and call the next 
-handler in the chain to actually execute the protocol.
 \end{methoddesc}
 
-\begin{classdesc}{HTTPPasswordMgr}{}
+\begin{methoddesc}[HTTPRedirectHandler]{http_error_302}{req,
-Keep a database of 
+                                                  fp, code, msg, hdrs}
-\code{(\var{realm}, \var{uri}) -> (\var{user}, \var{password})} mapping.
+The same as \method{http_error_301()}, but called for the
-\end{classdesc}
+temporary-redirect response.
+\end{methoddesc}
+
+
+\subsection{ProxyHandler Objects \label{proxy-handler}}
+
+\begin{methoddesc}[ProxyHandler]{\var{protocol}_open}{request}
+The \class{ProxyHandler} will have a method
+\method{\var{protocol}_open()} for every \var{protocol} which has a
+proxy in the \var{proxies} dictionary given in the constructor.  The
+method will modify requests to go through the proxy, by calling
+\code{request.set_proxy()}, and call the next handler in the chain to
+actually execute the protocol.
+\end{methoddesc}
+
+
+\subsection{HTTPPasswordMgr Objects \label{http-password-mgr}}
+
+These methods are available on \class{HTTPPasswordMgr} and
+\class{HTTPPasswordMgrWithDefaultRealm} objects.
 
 \begin{methoddesc}[HTTPPasswordMgr]{add_password}{realm, uri, user, passwd}
 \var{uri} can be either a single URI, or a sequene of URIs. \var{realm},
 \var{user} and \var{passwd} must be strings. This causes
- \code{(\var{user}, \var{passwd})} to be used as authentication tokens
+\code{(\var{user}, \var{passwd})} to be used as authentication tokens
 when authentication for \var{realm} and a super-URI of any of the
 given URIs is given.
 \end{methoddesc}  
 
 \begin{methoddesc}[HTTPPasswordMgr]{find_user_password}{realm, authuri}
-Get user/password for given realm and URI, if any. This method will
+Get user/password for given realm and URI, if any.  This method will
-return \code{(None, None)} if there is no user/password is known.
+return \code{(None, None)} if there is no matching user/password.
+
+For \class{HTTPPasswordMgrWithDefaultRealm} objects, the realm
+\code{None} will be searched if the given \var{realm} has no matching
+user/password.
 \end{methoddesc}
 
-\begin{classdesc}{HTTPPasswordMgrWithDefaultRealm}{}
-Keep a database of 
-\code{(\var{realm}, \var{uri}) -> (\var{user}, \var{password})} mapping.
-A realm of \code{None} is considered a catch-all realm, which is searched
-if no other realm fits.
-\end{classdesc}
 
-\begin{methoddesc}[HTTPPasswordMgrWithDefaultRealm]{add_password}
+\subsection{AbstractBasicAuthHandler Objects
-                                                   {realm, uri, user, passwd}
+            \label{abstract-basic-auth-handler}}
-\var{uri} can be either a single URI, or a sequene of URIs. \var{realm},
-\var{user} and \var{passwd} must be strings. This causes
- \code{(\var{user}, \var{passwd})} to be used as authentication tokens
-when authentication for \var{realm} and a super-URI of any of the
-given URIs is given.
-\end{methoddesc}  
-
-\begin{methoddesc}[HTTPPasswordMgr]{find_user_password}{realm, authuri}
-Get user/password for given realm and URI, if any. This method will
-return \code{(None, None)} if there is no user/password is known.
-If the given \var{realm} has no user/password, the realm \code{None}
-will be searched.
-\end{methoddesc}
-
-\begin{classdesc}[AbstractBasicAuthHandler]{\optional{password_mgr}}
-This is a mixin class, that helps with HTTP authentication, both
-to the remote host and to a proxy.
-
-\var{password_mgr} should be something that is compatible with
-\class{HTTPPasswordMgr} --- supplies the documented interface above.
-\end{classdesc}
 
 \begin{methoddesc}[AbstractBasicAuthHandler]{handle_authentication_request}
                                             {authreq, host, req, headers}
@@ -368,37 +454,29 @@ the realm, \var{host} is the host to authenticate too, \var{req} should be the
 (failed) \class{Request} object, and \var{headers} should be the error headers.
 \end{methoddesc}
 
-\begin{classdesc}{HTTPBasicAuthHandler}{\optional{password_mgr}}
+
-Handle authentication with the remote host.
+\subsection{HTTPBasicAuthHandler Objects
-Valid \var{password_mgr}, if given, are the same as for
+            \label{http-basic-auth-handler}}
-\class{AbstractBasicAuthHandler}.
-\end{classdesc}
 
 \begin{methoddesc}[HTTPBasicAuthHandler]{http_error_401}{req, fp, code, 
                                                         msg, hdrs}
 Retry the request with authentication info, if available.
 \end{methoddesc}
 
-\begin{classdesc}{ProxyBasicAuthHandler}{\optional{password_mgr}}
+
-Handle authentication with the proxy.
+\subsection{ProxyBasicAuthHandler Objects
-Valid \var{password_mgr}, if given, are the same as for
+            \label{proxy-basic-auth-handler}}
-\class{AbstractBasicAuthHandler}.
-\end{classdesc}
 
 \begin{methoddesc}[ProxyBasicAuthHandler]{http_error_407}{req, fp, code, 
                                                         msg, hdrs}
 Retry the request with authentication info, if available.
 \end{methoddesc}
 
-\begin{classdesc}{AbstractDigestAuthHandler}{\optional{password_mgr}}
-This is a mixin class, that helps with HTTP authentication, both
-to the remote host and to a proxy.
 
-\var{password_mgr} should be something that is compatible with
+\subsection{AbstractDigestAuthHandler Objects
-\class{HTTPPasswordMgr} --- supplies the documented interface above.
+            \label{abstract-digest-auth-handler}}
-\end{classdesc}
 
-\begin{methoddesc}[AbstractBasicAuthHandler]{handle_authentication_request}
+\begin{methoddesc}[AbstractDigestAuthHandler]{handle_authentication_request}
                                             {authreq, host, req, headers}
 \var{authreq} should be the name of the header where the information about
 the realm, \var{host} should be the host to authenticate too, \var{req} 
@@ -406,83 +484,63 @@ should be the (failed) \class{Request} object, and \var{headers} should be the
 error headers.
 \end{methoddesc}
 
-\begin{classdesc}{HTTPDigestAuthHandler}{\optional{password_mgr}}
+
-Handle authentication with the remote host.
+\subsection{HTTPDigestAuthHandler Objects
-Valid \var{password_mgr}, if given, are the same as for
+            \label{http-digest-auth-handler}}
-\class{AbstractBasicAuthHandler}.
-\end{classdesc}
 
 \begin{methoddesc}[HTTPDigestAuthHandler]{http_error_401}{req, fp, code, 
                                                         msg, hdrs}
 Retry the request with authentication info, if available.
 \end{methoddesc}
 
-\begin{classdesc}{ProxyDigestAuthHandler}{\optional{password_mgr}}
+
-Handle authentication with the proxy.
+\subsection{ProxyDigestAuthHandler Objects
-\var{password_mgr}, if given, shoudl be the same as for 
+            \label{proxy-digest-auth-handler}}
-the constructor of \class{AbstractDigestAuthHandler}.
-\end{classdesc}
 
 \begin{methoddesc}[ProxyDigestAuthHandler]{http_error_407}{req, fp, code, 
                                                         msg, hdrs}
-Retry the request with authentication info, if available.
+Retry the request with authentication information, if available.
 \end{methoddesc}
 
-\begin{classdesc}{HTTPHandler}{}
+
-A class to handle opening of HTTP URLs
+\subsection{HTTPHandler Objects \label{http-handler-objects}}
-\end{classdesc}
 
 \begin{methoddesc}[HTTPHandler]{http_open}{req}
-Send an HTTP request (either GET or POST, depending on whether
+Send an HTTP request, whcih can be either GET or POST, depending on
-\code{req.has_data()}.
+\code{\var{req}.has_data()}.
 \end{methoddesc}
 
-\begin{classdesc}{HTTPSHandler}{}
+
-A class to handle opening of HTTPS URLs
+\subsection{HTTPSHandler Objects \label{https-handler-objects}}
-\end{classdesc}
 
 \begin{methoddesc}[HTTPSHandler]{https_open}{req}
-Send an HTTPS request (either GET or POST, depending on whether
+Send an HTTPS request, which can be either GET or POST, depending on
-\code{req.has_data()}.
+\code{\var{req}.has_data()}.
 \end{methoddesc}
 
-\begin{classdesc}{UknownHandler}{}
-A catch-all class to handle unknown URLs.
-\end{classdesc}
 
-\begin{methoddesc}[UknownHandler]{unknown_open}
+\subsection{FileHandler Objects \label{file-handler-objects}}
-Raise a \exception{URLError} exception
-\end{methoddesc}
-
-\begin{classdesc}{FileHandler}{}
-Open local files.
-\end{classdesc}
 
 \begin{methoddesc}[FileHandler]{file_open}{req}
 Open the file locally, if there is no host name, or
-the host name is \code{"localhost"}. Change the
+the host name is \code{'localhost'}. Change the
 protocol to \code{ftp} otherwise, and retry opening
 it using \member{parent}.
 \end{methoddesc}
 
-\begin{classdesc}{FTPHandler}{}
+
-Open FTP URLs.
+\subsection{FTPHandler Objects \label{ftp-handler-objects}}
-\end{classdesc}
 
 \begin{methoddesc}[FTPHandler]{ftp_open}{req}
 Open the FTP file indicated by \var{req}.
 The login is always done with empty username and password.
 \end{methoddesc}
 
-\begin{classdesc}{CacheFTPHandler}{}
-Open FTP URLs, keeping a cache of open FTP connections to minimize
-delays.
-\end{classdesc}
 
-\begin{methoddesc}[CacheFTPHandler]{ftp_open}{req}
+\subsection{CacheFTPHandler Objects \label{cacheftp-handler-objects}}
-Open the FTP file indicated by \var{req}.
+
-The login is always done with empty username and password.
+\class{CacheFTPHandler} objects are \class{FTPHandler} objects with
-\end{methoddesc}
+the following additional methods:
 
 \begin{methoddesc}[CacheFTPHandler]{setTimeout}{t}
 Set timeout of connections to \var{t} seconds.
@@ -492,10 +550,16 @@ Set timeout of connections to \var{t} seconds.
 Set maximum number of cached connections to \var{m}.
 \end{methoddesc}
 
-\begin{classdesc}{GopherHandler}{}
+
-Open gopher URLs.
+\subsection{GopherHandler Objects \label{gopher-handler}}
-\end{classdesc}
 
 \begin{methoddesc}[GopherHandler]{gopher_open}{req}
 Open the gopher resource indicated by \var{req}.
 \end{methoddesc}
+
+
+\subsection{UnknownHandler Objects \label{unknown-handler-objects}}
+
+\begin{methoddesc}[UnknownHandler]{unknown_open}
+Raise a \exception{URLError} exception.
+\end{methoddesc}