2
:mod:`nntplib` --- NNTP protocol client
3
=======================================
6
:synopsis: NNTP protocol client (requires sockets).
11
single: Network News Transfer Protocol
13
This module defines the class :class:`NNTP` which implements the client side of
14
the NNTP protocol. It can be used to implement a news reader or poster, or
15
automated news processors. For more information on NNTP (Network News Transfer
16
Protocol), see Internet :rfc:`977`.
18
Here are two small examples of how it can be used. To list some statistics
19
about a newsgroup and print the subjects of the last 10 articles::
21
>>> s = NNTP('news.cwi.nl')
22
>>> resp, count, first, last, name = s.group('comp.lang.python')
23
>>> print('Group', name, 'has', count, 'articles, range', first, 'to', last)
24
Group comp.lang.python has 59 articles, range 3742 to 3803
25
>>> resp, subs = s.xhdr('subject', first + '-' + last)
26
>>> for id, sub in subs[-10:]: print(id, sub)
28
3792 Re: Removing elements from a list while iterating...
29
3793 Re: Who likes Info files?
30
3794 Emacs and doc strings
31
3795 a few questions about the Mac implementation
32
3796 Re: executable python scripts
33
3797 Re: executable python scripts
34
3798 Re: a few questions about the Mac implementation
35
3799 Re: PROPOSAL: A Generic Python Object Interface for Python C Modules
36
3802 Re: executable python scripts
37
3803 Re: \POSIX{} wait and SIGCHLD
39
'205 news.cwi.nl closing connection. Goodbye.'
41
To post an article from a file (this assumes that the article has valid
44
>>> s = NNTP('news.cwi.nl')
45
>>> f = open('/tmp/article')
47
'240 Article posted successfully.'
49
'205 news.cwi.nl closing connection. Goodbye.'
51
The module itself defines the following items:
54
.. class:: NNTP(host[, port [, user[, password [, readermode][, usenetrc]]]])
56
Return a new instance of the :class:`NNTP` class, representing a connection
57
to the NNTP server running on host *host*, listening at port *port*. The
58
default *port* is 119. If the optional *user* and *password* are provided,
59
or if suitable credentials are present in :file:`/.netrc` and the optional
60
flag *usenetrc* is true (the default), the ``AUTHINFO USER`` and ``AUTHINFO
61
PASS`` commands are used to identify and authenticate the user to the server.
62
If the optional flag *readermode* is true, then a ``mode reader`` command is
63
sent before authentication is performed. Reader mode is sometimes necessary
64
if you are connecting to an NNTP server on the local machine and intend to
65
call reader-specific commands, such as ``group``. If you get unexpected
66
:exc:`NNTPPermanentError`\ s, you might need to set *readermode*.
67
*readermode* defaults to ``None``. *usenetrc* defaults to ``True``.
70
.. exception:: NNTPError
72
Derived from the standard exception :exc:`Exception`, this is the base class for
73
all exceptions raised by the :mod:`nntplib` module.
76
.. exception:: NNTPReplyError
78
Exception raised when an unexpected reply is received from the server. For
79
backwards compatibility, the exception ``error_reply`` is equivalent to this
83
.. exception:: NNTPTemporaryError
85
Exception raised when an error code in the range 400--499 is received. For
86
backwards compatibility, the exception ``error_temp`` is equivalent to this
90
.. exception:: NNTPPermanentError
92
Exception raised when an error code in the range 500--599 is received. For
93
backwards compatibility, the exception ``error_perm`` is equivalent to this
97
.. exception:: NNTPProtocolError
99
Exception raised when a reply is received from the server that does not begin
100
with a digit in the range 1--5. For backwards compatibility, the exception
101
``error_proto`` is equivalent to this class.
104
.. exception:: NNTPDataError
106
Exception raised when there is some error in the response data. For backwards
107
compatibility, the exception ``error_data`` is equivalent to this class.
115
NNTP instances have the following methods. The *response* that is returned as
116
the first item in the return tuple of almost all methods is the server's
117
response: a string beginning with a three-digit code. If the server's response
118
indicates an error, the method raises one of the above exceptions.
121
.. method:: NNTP.getwelcome()
123
Return the welcome message sent by the server in reply to the initial
124
connection. (This message sometimes contains disclaimers or help information
125
that may be relevant to the user.)
128
.. method:: NNTP.set_debuglevel(level)
130
Set the instance's debugging level. This controls the amount of debugging
131
output printed. The default, ``0``, produces no debugging output. A value of
132
``1`` produces a moderate amount of debugging output, generally a single line
133
per request or response. A value of ``2`` or higher produces the maximum amount
134
of debugging output, logging each line sent and received on the connection
135
(including message text).
138
.. method:: NNTP.newgroups(date, time, [file])
140
Send a ``NEWGROUPS`` command. The *date* argument should be a string of the
141
form ``'yymmdd'`` indicating the date, and *time* should be a string of the form
142
``'hhmmss'`` indicating the time. Return a pair ``(response, groups)`` where
143
*groups* is a list of group names that are new since the given date and time. If
144
the *file* parameter is supplied, then the output of the ``NEWGROUPS`` command
145
is stored in a file. If *file* is a string, then the method will open a file
146
object with that name, write to it then close it. If *file* is a file object,
147
then it will start calling :meth:`write` on it to store the lines of the command
148
output. If *file* is supplied, then the returned *list* is an empty list.
151
.. method:: NNTP.newnews(group, date, time, [file])
153
Send a ``NEWNEWS`` command. Here, *group* is a group name or ``'*'``, and
154
*date* and *time* have the same meaning as for :meth:`newgroups`. Return a pair
155
``(response, articles)`` where *articles* is a list of message ids. If the
156
*file* parameter is supplied, then the output of the ``NEWNEWS`` command is
157
stored in a file. If *file* is a string, then the method will open a file
158
object with that name, write to it then close it. If *file* is a file object,
159
then it will start calling :meth:`write` on it to store the lines of the command
160
output. If *file* is supplied, then the returned *list* is an empty list.
163
.. method:: NNTP.list([file])
165
Send a ``LIST`` command. Return a pair ``(response, list)`` where *list* is a
166
list of tuples. Each tuple has the form ``(group, last, first, flag)``, where
167
*group* is a group name, *last* and *first* are the last and first article
168
numbers (as strings), and *flag* is ``'y'`` if posting is allowed, ``'n'`` if
169
not, and ``'m'`` if the newsgroup is moderated. (Note the ordering: *last*,
170
*first*.) If the *file* parameter is supplied, then the output of the ``LIST``
171
command is stored in a file. If *file* is a string, then the method will open
172
a file object with that name, write to it then close it. If *file* is a file
173
object, then it will start calling :meth:`write` on it to store the lines of the
174
command output. If *file* is supplied, then the returned *list* is an empty
178
.. method:: NNTP.descriptions(grouppattern)
180
Send a ``LIST NEWSGROUPS`` command, where *grouppattern* is a wildmat string as
181
specified in RFC2980 (it's essentially the same as DOS or UNIX shell wildcard
182
strings). Return a pair ``(response, list)``, where *list* is a list of tuples
183
containing ``(name, title)``.
186
.. method:: NNTP.description(group)
188
Get a description for a single group *group*. If more than one group matches
189
(if 'group' is a real wildmat string), return the first match. If no group
190
matches, return an empty string.
192
This elides the response code from the server. If the response code is needed,
193
use :meth:`descriptions`.
196
.. method:: NNTP.group(name)
198
Send a ``GROUP`` command, where *name* is the group name. Return a tuple
199
``(response, count, first, last, name)`` where *count* is the (estimated) number
200
of articles in the group, *first* is the first article number in the group,
201
*last* is the last article number in the group, and *name* is the group name.
202
The numbers are returned as strings.
205
.. method:: NNTP.help([file])
207
Send a ``HELP`` command. Return a pair ``(response, list)`` where *list* is a
208
list of help strings. If the *file* parameter is supplied, then the output of
209
the ``HELP`` command is stored in a file. If *file* is a string, then the
210
method will open a file object with that name, write to it then close it. If
211
*file* is a file object, then it will start calling :meth:`write` on it to store
212
the lines of the command output. If *file* is supplied, then the returned *list*
216
.. method:: NNTP.stat(id)
218
Send a ``STAT`` command, where *id* is the message id (enclosed in ``'<'`` and
219
``'>'``) or an article number (as a string). Return a triple ``(response,
220
number, id)`` where *number* is the article number (as a string) and *id* is the
221
message id (enclosed in ``'<'`` and ``'>'``).
224
.. method:: NNTP.next()
226
Send a ``NEXT`` command. Return as for :meth:`stat`.
229
.. method:: NNTP.last()
231
Send a ``LAST`` command. Return as for :meth:`stat`.
234
.. method:: NNTP.head(id)
236
Send a ``HEAD`` command, where *id* has the same meaning as for :meth:`stat`.
237
Return a tuple ``(response, number, id, list)`` where the first three are the
238
same as for :meth:`stat`, and *list* is a list of the article's headers (an
239
uninterpreted list of lines, without trailing newlines).
242
.. method:: NNTP.body(id,[file])
244
Send a ``BODY`` command, where *id* has the same meaning as for :meth:`stat`.
245
If the *file* parameter is supplied, then the body is stored in a file. If
246
*file* is a string, then the method will open a file object with that name,
247
write to it then close it. If *file* is a file object, then it will start
248
calling :meth:`write` on it to store the lines of the body. Return as for
249
:meth:`head`. If *file* is supplied, then the returned *list* is an empty list.
252
.. method:: NNTP.article(id)
254
Send an ``ARTICLE`` command, where *id* has the same meaning as for
255
:meth:`stat`. Return as for :meth:`head`.
258
.. method:: NNTP.slave()
260
Send a ``SLAVE`` command. Return the server's *response*.
263
.. method:: NNTP.xhdr(header, string, [file])
265
Send an ``XHDR`` command. This command is not defined in the RFC but is a
266
common extension. The *header* argument is a header keyword, e.g.
267
``'subject'``. The *string* argument should have the form ``'first-last'``
268
where *first* and *last* are the first and last article numbers to search.
269
Return a pair ``(response, list)``, where *list* is a list of pairs ``(id,
270
text)``, where *id* is an article number (as a string) and *text* is the text of
271
the requested header for that article. If the *file* parameter is supplied, then
272
the output of the ``XHDR`` command is stored in a file. If *file* is a string,
273
then the method will open a file object with that name, write to it then close
274
it. If *file* is a file object, then it will start calling :meth:`write` on it
275
to store the lines of the command output. If *file* is supplied, then the
276
returned *list* is an empty list.
279
.. method:: NNTP.post(file)
281
Post an article using the ``POST`` command. The *file* argument is an open file
282
object which is read until EOF using its :meth:`readline` method. It should be
283
a well-formed news article, including the required headers. The :meth:`post`
284
method automatically escapes lines beginning with ``.``.
287
.. method:: NNTP.ihave(id, file)
289
Send an ``IHAVE`` command. *id* is a message id (enclosed in ``'<'`` and
290
``'>'``). If the response is not an error, treat *file* exactly as for the
294
.. method:: NNTP.date()
296
Return a triple ``(response, date, time)``, containing the current date and time
297
in a form suitable for the :meth:`newnews` and :meth:`newgroups` methods. This
298
is an optional NNTP extension, and may not be supported by all servers.
301
.. method:: NNTP.xgtitle(name, [file])
303
Process an ``XGTITLE`` command, returning a pair ``(response, list)``, where
304
*list* is a list of tuples containing ``(name, title)``. If the *file* parameter
305
is supplied, then the output of the ``XGTITLE`` command is stored in a file.
306
If *file* is a string, then the method will open a file object with that name,
307
write to it then close it. If *file* is a file object, then it will start
308
calling :meth:`write` on it to store the lines of the command output. If *file*
309
is supplied, then the returned *list* is an empty list. This is an optional NNTP
310
extension, and may not be supported by all servers.
312
RFC2980 says "It is suggested that this extension be deprecated". Use
313
:meth:`descriptions` or :meth:`description` instead.
316
.. method:: NNTP.xover(start, end, [file])
318
Return a pair ``(resp, list)``. *list* is a list of tuples, one for each
319
article in the range delimited by the *start* and *end* article numbers. Each
320
tuple is of the form ``(article number, subject, poster, date, id, references,
321
size, lines)``. If the *file* parameter is supplied, then the output of the
322
``XOVER`` command is stored in a file. If *file* is a string, then the method
323
will open a file object with that name, write to it then close it. If *file*
324
is a file object, then it will start calling :meth:`write` on it to store the
325
lines of the command output. If *file* is supplied, then the returned *list* is
326
an empty list. This is an optional NNTP extension, and may not be supported by
330
.. method:: NNTP.xpath(id)
332
Return a pair ``(resp, path)``, where *path* is the directory path to the
333
article with message ID *id*. This is an optional NNTP extension, and may not
334
be supported by all servers.
337
.. method:: NNTP.quit()
339
Send a ``QUIT`` command and close the connection. Once this method has been
340
called, no other methods of the NNTP object should be called.
added
removed
Doc/library/nntplib.rst
