/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to urlgrabber/grabber.py

Merge James.

Show diffs side-by-side

added added

removed removed

Lines of Context:
urlgrabber/grabber.py
1
 
#   This library is free software; you can redistribute it and/or
2
 
#   modify it under the terms of the GNU Lesser General Public
3
 
#   License as published by the Free Software Foundation; either
4
 
#   version 2.1 of the License, or (at your option) any later version.
5
 
#
6
 
#   This library is distributed in the hope that it will be useful,
7
 
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
8
 
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
9
 
#   Lesser General Public License for more details.
10
 
#
11
 
#   You should have received a copy of the GNU Lesser General Public
12
 
#   License along with this library; if not, write to the 
13
 
#      Free Software Foundation, Inc., 
14
 
#      59 Temple Place, Suite 330, 
15
 
#      Boston, MA  02111-1307  USA
16
 
 
17
 
# This file is part of urlgrabber, a high-level cross-protocol url-grabber
18
 
# Copyright 2002-2004 Michael D. Stenner, Ryan Tomayko
19
 
 
20
 
"""A high-level cross-protocol url-grabber.
21
 
 
22
 
GENERAL ARGUMENTS (kwargs)
23
 
 
24
 
  Where possible, the module-level default is indicated, and legal
25
 
  values are provided.
26
 
 
27
 
  copy_local = 0   [0|1]
28
 
 
29
 
    ignored except for file:// urls, in which case it specifies
30
 
    whether urlgrab should still make a copy of the file, or simply
31
 
    point to the existing copy. The module level default for this
32
 
    option is 0.
33
 
 
34
 
  close_connection = 0   [0|1]
35
 
 
36
 
    tells URLGrabber to close the connection after a file has been
37
 
    transfered. This is ignored unless the download happens with the
38
 
    http keepalive handler (keepalive=1).  Otherwise, the connection
39
 
    is left open for further use. The module level default for this
40
 
    option is 0 (keepalive connections will not be closed).
41
 
 
42
 
  keepalive = 1   [0|1]
43
 
 
44
 
    specifies whether keepalive should be used for HTTP/1.1 servers
45
 
    that support it. The module level default for this option is 1
46
 
    (keepalive is enabled).
47
 
 
48
 
  progress_obj = None
49
 
 
50
 
    a class instance that supports the following methods:
51
 
      po.start(filename, url, basename, length, text)
52
 
      # length will be None if unknown
53
 
      po.update(read) # read == bytes read so far
54
 
      po.end()
55
 
 
56
 
  text = None
57
 
  
58
 
    specifies an alternativ text item in the beginning of the progress
59
 
    bar line. If not given, the basename of the file is used.
60
 
 
61
 
  throttle = 1.0
62
 
 
63
 
    a number - if it's an int, it's the bytes/second throttle limit.
64
 
    If it's a float, it is first multiplied by bandwidth.  If throttle
65
 
    == 0, throttling is disabled.  If None, the module-level default
66
 
    (which can be set on default_grabber.throttle) is used. See
67
 
    BANDWIDTH THROTTLING for more information.
68
 
 
69
 
  timeout = None
70
 
 
71
 
    a positive float expressing the number of seconds to wait for socket
72
 
    operations. If the value is None or 0.0, socket operations will block
73
 
    forever. Setting this option causes urlgrabber to call the settimeout
74
 
    method on the Socket object used for the request. See the Python
75
 
    documentation on settimeout for more information.
76
 
    http://www.python.org/doc/current/lib/socket-objects.html
77
 
 
78
 
  bandwidth = 0
79
 
 
80
 
    the nominal max bandwidth in bytes/second.  If throttle is a float
81
 
    and bandwidth == 0, throttling is disabled.  If None, the
82
 
    module-level default (which can be set on
83
 
    default_grabber.bandwidth) is used. See BANDWIDTH THROTTLING for
84
 
    more information.
85
 
 
86
 
  range = None
87
 
 
88
 
    a tuple of the form (first_byte, last_byte) describing a byte
89
 
    range to retrieve. Either or both of the values may set to
90
 
    None. If first_byte is None, byte offset 0 is assumed. If
91
 
    last_byte is None, the last byte available is assumed. Note that
92
 
    the range specification is python-like in that (0,10) will yeild
93
 
    the first 10 bytes of the file.
94
 
 
95
 
    If set to None, no range will be used.
96
 
    
97
 
  reget = None   [None|'simple'|'check_timestamp']
98
 
 
99
 
    whether to attempt to reget a partially-downloaded file.  Reget
100
 
    only applies to .urlgrab and (obviously) only if there is a
101
 
    partially downloaded file.  Reget has two modes:
102
 
 
103
 
      'simple' -- the local file will always be trusted.  If there
104
 
        are 100 bytes in the local file, then the download will always
105
 
        begin 100 bytes into the requested file.
106
 
 
107
 
      'check_timestamp' -- the timestamp of the server file will be
108
 
        compared to the timestamp of the local file.  ONLY if the
109
 
        local file is newer than or the same age as the server file
110
 
        will reget be used.  If the server file is newer, or the
111
 
        timestamp is not returned, the entire file will be fetched.
112
 
 
113
 
    NOTE: urlgrabber can do very little to verify that the partial
114
 
    file on disk is identical to the beginning of the remote file.
115
 
    You may want to either employ a custom "checkfunc" or simply avoid
116
 
    using reget in situations where corruption is a concern.
117
 
 
118
 
  user_agent = 'urlgrabber/VERSION'
119
 
 
120
 
    a string, usually of the form 'AGENT/VERSION' that is provided to
121
 
    HTTP servers in the User-agent header. The module level default
122
 
    for this option is "urlgrabber/VERSION".
123
 
 
124
 
  http_headers = None
125
 
 
126
 
    a tuple of 2-tuples, each containing a header and value.  These
127
 
    will be used for http and https requests only.  For example, you
128
 
    can do
129
 
      http_headers = (('Pragma', 'no-cache'),)
130
 
 
131
 
  ftp_headers = None
132
 
 
133
 
    this is just like http_headers, but will be used for ftp requests.
134
 
 
135
 
  proxies = None
136
 
 
137
 
    a dictionary that maps protocol schemes to proxy hosts. For
138
 
    example, to use a proxy server on host "foo" port 3128 for http
139
 
    and https URLs:
140
 
      proxies={ 'http' : 'http://foo:3128', 'https' : 'http://foo:3128' }
141
 
    note that proxy authentication information may be provided using
142
 
    normal URL constructs:
143
 
      proxies={ 'http' : 'http://user:host@foo:3128' }
144
 
    Lastly, if proxies is None, the default environment settings will
145
 
    be used.
146
 
 
147
 
  prefix = None
148
 
 
149
 
    a url prefix that will be prepended to all requested urls.  For
150
 
    example:
151
 
      g = URLGrabber(prefix='http://foo.com/mirror/')
152
 
      g.urlgrab('some/file.txt')
153
 
      ## this will fetch 'http://foo.com/mirror/some/file.txt'
154
 
    This option exists primarily to allow identical behavior to
155
 
    MirrorGroup (and derived) instances.  Note: a '/' will be inserted
156
 
    if necessary, so you cannot specify a prefix that ends with a
157
 
    partial file or directory name.
158
 
 
159
 
  opener = None
160
 
  
161
 
    Overrides the default urllib2.OpenerDirector provided to urllib2
162
 
    when making requests.  This option exists so that the urllib2
163
 
    handler chain may be customized.  Note that the range, reget,
164
 
    proxy, and keepalive features require that custom handlers be
165
 
    provided to urllib2 in order to function properly.  If an opener
166
 
    option is provided, no attempt is made by urlgrabber to ensure
167
 
    chain integrity.  You are responsible for ensuring that any
168
 
    extension handlers are present if said features are required.
169
 
    
170
 
RETRY RELATED ARGUMENTS
171
 
 
172
 
  retry = None
173
 
 
174
 
    the number of times to retry the grab before bailing.  If this is
175
 
    zero, it will retry forever. This was intentional... really, it
176
 
    was :). If this value is not supplied or is supplied but is None
177
 
    retrying does not occur.
178
 
 
179
 
  retrycodes = [-1,2,4,5,6,7]
180
 
 
181
 
    a sequence of errorcodes (values of e.errno) for which it should
182
 
    retry. See the doc on URLGrabError for more details on
183
 
    this. retrycodes defaults to [-1,2,4,5,6,7] if not specified
184
 
    explicitly.
185
 
 
186
 
  checkfunc = None
187
 
 
188
 
    a function to do additional checks. This defaults to None, which
189
 
    means no additional checking.  The function should simply return
190
 
    on a successful check.  It should raise URLGrabError on an
191
 
    unsuccessful check.  Raising of any other exception will be
192
 
    considered immediate failure and no retries will occur.
193
 
 
194
 
    If it raises URLGrabError, the error code will determine the retry
195
 
    behavior.  Negative error numbers are reserved for use by these
196
 
    passed in functions, so you can use many negative numbers for
197
 
    different types of failure.  By default, -1 results in a retry,
198
 
    but this can be customized with retrycodes.
199
 
 
200
 
    If you simply pass in a function, it will be given exactly one
201
 
    argument: a CallbackObject instance with the .url attribute
202
 
    defined and either .filename (for urlgrab) or .data (for urlread).
203
 
    For urlgrab, .filename is the name of the local file.  For
204
 
    urlread, .data is the actual string data.  If you need other
205
 
    arguments passed to the callback (program state of some sort), you
206
 
    can do so like this:
207
 
 
208
 
      checkfunc=(function, ('arg1', 2), {'kwarg': 3})
209
 
 
210
 
    if the downloaded file has filename /tmp/stuff, then this will
211
 
    result in this call (for urlgrab):
212
 
 
213
 
      function(obj, 'arg1', 2, kwarg=3)
214
 
      # obj.filename = '/tmp/stuff'
215
 
      # obj.url = 'http://foo.com/stuff'
216
 
      
217
 
    NOTE: both the "args" tuple and "kwargs" dict must be present if
218
 
    you use this syntax, but either (or both) can be empty.
219
 
 
220
 
  failure_callback = None
221
 
 
222
 
    The callback that gets called during retries when an attempt to
223
 
    fetch a file fails.  The syntax for specifying the callback is
224
 
    identical to checkfunc, except for the attributes defined in the
225
 
    CallbackObject instance.  In this case, it will have .exception
226
 
    and .url defined.  As you might suspect, .exception is the
227
 
    exception that was raised.
228
 
 
229
 
    The callback is present primarily to inform the calling program of
230
 
    the failure, but if it raises an exception (including the one it's
231
 
    passed) that exception will NOT be caught and will therefore cause
232
 
    future retries to be aborted.
233
 
 
234
 
BANDWIDTH THROTTLING
235
 
 
236
 
  urlgrabber supports throttling via two values: throttle and
237
 
  bandwidth Between the two, you can either specify and absolute
238
 
  throttle threshold or specify a theshold as a fraction of maximum
239
 
  available bandwidth.
240
 
 
241
 
  throttle is a number - if it's an int, it's the bytes/second
242
 
  throttle limit.  If it's a float, it is first multiplied by
243
 
  bandwidth.  If throttle == 0, throttling is disabled.  If None, the
244
 
  module-level default (which can be set with set_throttle) is used.
245
 
 
246
 
  bandwidth is the nominal max bandwidth in bytes/second.  If throttle
247
 
  is a float and bandwidth == 0, throttling is disabled.  If None, the
248
 
  module-level default (which can be set with set_bandwidth) is used.
249
 
 
250
 
  THROTTLING EXAMPLES:
251
 
 
252
 
  Lets say you have a 100 Mbps connection.  This is (about) 10^8 bits
253
 
  per second, or 12,500,000 Bytes per second.  You have a number of
254
 
  throttling options:
255
 
 
256
 
  *) set_bandwidth(12500000); set_throttle(0.5) # throttle is a float
257
 
 
258
 
     This will limit urlgrab to use half of your available bandwidth.
259
 
 
260
 
  *) set_throttle(6250000) # throttle is an int
261
 
 
262
 
     This will also limit urlgrab to use half of your available
263
 
     bandwidth, regardless of what bandwidth is set to.
264
 
 
265
 
  *) set_throttle(6250000); set_throttle(1.0) # float
266
 
 
267
 
     Use half your bandwidth
268
 
 
269
 
  *) set_throttle(6250000); set_throttle(2.0) # float
270
 
 
271
 
    Use up to 12,500,000 Bytes per second (your nominal max bandwidth)
272
 
 
273
 
  *) set_throttle(6250000); set_throttle(0) # throttle = 0
274
 
 
275
 
     Disable throttling - this is more efficient than a very large
276
 
     throttle setting.
277
 
 
278
 
  *) set_throttle(0); set_throttle(1.0) # throttle is float, bandwidth = 0
279
 
 
280
 
     Disable throttling - this is the default when the module is loaded.
281
 
 
282
 
  SUGGESTED AUTHOR IMPLEMENTATION (THROTTLING)
283
 
 
284
 
  While this is flexible, it's not extremely obvious to the user.  I
285
 
  suggest you implement a float throttle as a percent to make the
286
 
  distinction between absolute and relative throttling very explicit.
287
 
 
288
 
  Also, you may want to convert the units to something more convenient
289
 
  than bytes/second, such as kbps or kB/s, etc.
290
 
 
291
 
"""
292
 
 
293
 
# $Id: grabber.py,v 1.39 2005/03/03 00:54:23 mstenner Exp $
294
 
 
295
 
import os
296
 
import os.path
297
 
import urlparse
298
 
import rfc822
299
 
import time
300
 
import string
301
 
import urllib
302
 
import urllib2
303
 
from stat import *  # S_* and ST_*
304
 
 
305
 
try:
306
 
    exec('from ' + (__name__.split('.'))[0] + ' import __version__')
307
 
except:
308
 
    __version__ = '???'
309
 
 
310
 
auth_handler = urllib2.HTTPBasicAuthHandler( \
311
 
     urllib2.HTTPPasswordMgrWithDefaultRealm())
312
 
 
313
 
DEBUG=0
314
 
 
315
 
try:
316
 
    from i18n import _
317
 
except ImportError, msg:
318
 
    def _(st): return st
319
 
 
320
 
try:
321
 
    from httplib import HTTPException
322
 
except ImportError, msg:
323
 
    HTTPException = None
324
 
 
325
 
try:
326
 
    # This is a convenient way to make keepalive optional.
327
 
    # Just rename the module so it can't be imported.
328
 
    from keepalive import HTTPHandler
329
 
except ImportError, msg:
330
 
    keepalive_handler = None
331
 
else:
332
 
    keepalive_handler = HTTPHandler()
333
 
 
334
 
try:
335
 
    # add in range support conditionally too
336
 
    from urlgrabber.byterange import HTTPRangeHandler, FileRangeHandler, \
337
 
         FTPRangeHandler, range_tuple_normalize, range_tuple_to_header, \
338
 
         RangeError
339
 
except ImportError, msg:
340
 
    range_handlers = ()
341
 
    RangeError = None
342
 
    have_range = 0
343
 
else:
344
 
    range_handlers = (HTTPRangeHandler(), FileRangeHandler(), FTPRangeHandler())
345
 
    have_range = 1
346
 
 
347
 
 
348
 
# check whether socket timeout support is available (Python >= 2.3)
349
 
import socket
350
 
try:
351
 
    TimeoutError = socket.timeout
352
 
    have_socket_timeout = True
353
 
except AttributeError:
354
 
    TimeoutError = None
355
 
    have_socket_timeout = False
356
 
 
357
 
class URLGrabError(IOError):
358
 
    """
359
 
    URLGrabError error codes:
360
 
 
361
 
      URLGrabber error codes (0 -- 255)
362
 
        0    - everything looks good (you should never see this)
363
 
        1    - malformed url
364
 
        2    - local file doesn't exist
365
 
        3    - request for non-file local file (dir, etc)
366
 
        4    - IOError on fetch
367
 
        5    - OSError on fetch
368
 
        6    - no content length header when we expected one
369
 
        7    - HTTPException
370
 
        8    - Exceeded read limit (for urlread)
371
 
        9    - Requested byte range not satisfiable.
372
 
        10   - Byte range requested, but range support unavailable
373
 
        11   - Illegal reget mode
374
 
        12   - Socket timeout.
375
 
 
376
 
      MirrorGroup error codes (256 -- 511)
377
 
        256  - No more mirrors left to try
378
 
 
379
 
      Custom (non-builtin) classes derived from MirrorGroup (512 -- 767)
380
 
        [ this range reserved for application-specific error codes ]
381
 
 
382
 
      Retry codes (< 0)
383
 
        -1   - retry the download, unknown reason
384
 
 
385
 
    Note: to test which group a code is in, you can simply do integer
386
 
    division by 256: e.errno / 256
387
 
 
388
 
    Negative codes are reserved for use by functions passed in to
389
 
    retrygrab with checkfunc.  The value -1 is built in as a generic
390
 
    retry code and is already included in the retrycodes list.
391
 
    Therefore, you can create a custom check function that simply
392
 
    returns -1 and the fetch will be re-tried.  For more customized
393
 
    retries, you can use other negative number and include them in
394
 
    retry-codes.  This is nice for outputting useful messages about
395
 
    what failed.
396
 
 
397
 
    You can use these error codes like so:
398
 
      try: urlgrab(url)
399
 
      except URLGrabError, e:
400
 
         if e.errno == 3: ...
401
 
           # or
402
 
         print e.strerror
403
 
           # or simply
404
 
         print e  #### print '[Errno %i] %s' % (e.errno, e.strerror)
405
 
    """
406
 
    pass
407
 
 
408
 
class CallbackObject:
409
 
    """Container for returned callback data.
410
 
 
411
 
    This is currently a dummy class into which urlgrabber can stuff
412
 
    information for passing to callbacks.  This way, the prototype for
413
 
    all callbacks is the same, regardless of the data that will be
414
 
    passed back.  Any function that accepts a callback function as an
415
 
    argument SHOULD document what it will define in this object.
416
 
 
417
 
    It is possible that this class will have some greater
418
 
    functionality in the future.
419
 
    """
420
 
    pass
421
 
 
422
 
def close_all():
423
 
    """close any open keepalive connections"""
424
 
    if keepalive_handler: keepalive_handler.close_all()
425
 
 
426
 
def urlgrab(url, filename=None, **kwargs):
427
 
    """grab the file at <url> and make a local copy at <filename>
428
 
    If filename is none, the basename of the url is used.
429
 
    urlgrab returns the filename of the local file, which may be different
430
 
    from the passed-in filename if the copy_local kwarg == 0.
431
 
    
432
 
    See module documentation for a description of possible kwargs.
433
 
    """
434
 
    return default_grabber.urlgrab(url, filename, **kwargs)
435
 
 
436
 
def urlopen(url, **kwargs):
437
 
    """open the url and return a file object
438
 
    If a progress object or throttle specifications exist, then
439
 
    a special file object will be returned that supports them.
440
 
    The file object can be treated like any other file object.
441
 
    
442
 
    See module documentation for a description of possible kwargs.
443
 
    """
444
 
    return default_grabber.urlopen(url, **kwargs)
445
 
 
446
 
def urlread(url, limit=None, **kwargs):
447
 
    """read the url into a string, up to 'limit' bytes
448
 
    If the limit is exceeded, an exception will be thrown.  Note that urlread
449
 
    is NOT intended to be used as a way of saying "I want the first N bytes"
450
 
    but rather 'read the whole file into memory, but don't use too much'
451
 
    
452
 
    See module documentation for a description of possible kwargs.
453
 
    """
454
 
    return default_grabber.urlread(url, limit, **kwargs)
455
 
 
456
 
 
457
 
class URLGrabberOptions:
458
 
    """Class to ease kwargs handling."""
459
 
 
460
 
    def __init__(self, delegate=None, **kwargs):
461
 
        """Initialize URLGrabberOptions object.
462
 
        Set default values for all options and then update options specified
463
 
        in kwargs.
464
 
        """
465
 
        self.delegate = delegate
466
 
        if delegate is None:
467
 
            self._set_defaults()
468
 
        self._set_attributes(**kwargs)
469
 
    
470
 
    def __getattr__(self, name):
471
 
        if self.delegate and hasattr(self.delegate, name):
472
 
            return getattr(self.delegate, name)
473
 
        raise AttributeError, name
474
 
    
475
 
    def raw_throttle(self):
476
 
        """Calculate raw throttle value from throttle and bandwidth 
477
 
        values.
478
 
        """
479
 
        if self.throttle <= 0:  
480
 
            return 0
481
 
        elif type(self.throttle) == type(0): 
482
 
            return float(self.throttle)
483
 
        else: # throttle is a float
484
 
            return self.bandwidth * self.throttle
485
 
        
486
 
    def derive(self, **kwargs):
487
 
        """Create a derived URLGrabberOptions instance.
488
 
        This method creates a new instance and overrides the
489
 
        options specified in kwargs.
490
 
        """
491
 
        return URLGrabberOptions(delegate=self, **kwargs)
492
 
        
493
 
    def _set_attributes(self, **kwargs):
494
 
        """Update object attributes with those provided in kwargs."""
495
 
        self.__dict__.update(kwargs)
496
 
        if have_range and kwargs.has_key('range'):
497
 
            # normalize the supplied range value
498
 
            self.range = range_tuple_normalize(self.range)
499
 
        if not self.reget in [None, 'simple', 'check_timestamp']:
500
 
            raise URLGrabError(11, _('Illegal reget mode: %s') \
501
 
                               % (self.reget, ))
502
 
 
503
 
    def _set_defaults(self):
504
 
        """Set all options to their default values. 
505
 
        When adding new options, make sure a default is
506
 
        provided here.
507
 
        """
508
 
        self.progress_obj = None
509
 
        self.throttle = 1.0
510
 
        self.bandwidth = 0
511
 
        self.retry = None
512
 
        self.retrycodes = [-1,2,4,5,6,7]
513
 
        self.checkfunc = None
514
 
        self.copy_local = 0
515
 
        self.close_connection = 0
516
 
        self.range = None
517
 
        self.user_agent = 'urlgrabber/%s' % __version__
518
 
        self.keepalive = 1
519
 
        self.proxies = None
520
 
        self.reget = None
521
 
        self.failure_callback = None
522
 
        self.prefix = None
523
 
        self.opener = None
524
 
        self.cache_openers = True
525
 
        self.timeout = None
526
 
        self.text = None
527
 
        self.http_headers = None
528
 
        self.ftp_headers = None
529
 
 
530
 
class URLGrabber:
531
 
    """Provides easy opening of URLs with a variety of options.
532
 
    
533
 
    All options are specified as kwargs. Options may be specified when
534
 
    the class is created and may be overridden on a per request basis.
535
 
    
536
 
    New objects inherit default values from default_grabber.
537
 
    """
538
 
    
539
 
    def __init__(self, **kwargs):
540
 
        self.opts = URLGrabberOptions(**kwargs)
541
 
    
542
 
    def _retry(self, opts, func, *args):
543
 
        tries = 0
544
 
        while 1:
545
 
            tries = tries + 1
546
 
            try:
547
 
                return apply(func, (opts,) + args, {})
548
 
            except URLGrabError, e:
549
 
                if DEBUG: print 'EXCEPTION: %s' % e
550
 
                if (opts.retry is None) \
551
 
                    or (tries == opts.retry) \
552
 
                    or (e.errno not in opts.retrycodes): raise
553
 
                if opts.failure_callback:
554
 
                    cb_func, cb_args, cb_kwargs = \
555
 
                          self._make_callback(opts.failure_callback)
556
 
                    # this is a little icky - for now, the first element
557
 
                    # of args is the url.  we might consider a way to tidy
558
 
                    # that up, though
559
 
                    obj = CallbackObject()
560
 
                    obj.exception = e
561
 
                    obj.url = args[0]
562
 
                    cb_func(obj, *cb_args, **cb_kwargs)
563
 
    
564
 
    def urlopen(self, url, **kwargs):
565
 
        """open the url and return a file object
566
 
        If a progress object or throttle value specified when this 
567
 
        object was created, then  a special file object will be 
568
 
        returned that supports them. The file object can be treated 
569
 
        like any other file object.
570
 
        """
571
 
        opts = self.opts.derive(**kwargs)
572
 
        (url,parts) = self._parse_url(url) 
573
 
        def retryfunc(opts, url):
574
 
            return URLGrabberFileObject(url, filename=None, opts=opts)
575
 
        return self._retry(opts, retryfunc, url)
576
 
    
577
 
    def urlgrab(self, url, filename=None, **kwargs):
578
 
        """grab the file at <url> and make a local copy at <filename>
579
 
        If filename is none, the basename of the url is used.
580
 
        urlgrab returns the filename of the local file, which may be 
581
 
        different from the passed-in filename if copy_local == 0.
582
 
        """
583
 
        opts = self.opts.derive(**kwargs)
584
 
        (url, parts) = self._parse_url(url)
585
 
        (scheme, host, path, parm, query, frag) = parts
586
 
        if filename is None:
587
 
            if scheme in [ 'http', 'https' ]:
588
 
                filename = os.path.basename( urllib.unquote(path) )
589
 
            else:
590
 
                filename = os.path.basename( path )
591
 
        if scheme == 'file' and not opts.copy_local:
592
 
            # just return the name of the local file - don't make a 
593
 
            # copy currently
594
 
            if not os.path.exists(path):
595
 
                raise URLGrabError(2, 
596
 
                      _('Local file does not exist: %s') % (path, ))
597
 
            elif not os.path.isfile(path):
598
 
                raise URLGrabError(3, 
599
 
                              _('Not a normal file: %s') % (path, ))
600
 
            elif not opts.range:
601
 
                return path
602
 
        
603
 
        def retryfunc(opts, url, filename):
604
 
            fo = URLGrabberFileObject(url, filename, opts)
605
 
            try:
606
 
                fo._do_grab()
607
 
                if not opts.checkfunc is None:
608
 
                    cb_func, cb_args, cb_kwargs = \
609
 
                             self._make_callback(opts.checkfunc)
610
 
                    obj = CallbackObject()
611
 
                    obj.filename = filename
612
 
                    obj.url = url
613
 
                    apply(cb_func, (obj, )+cb_args, cb_kwargs)
614
 
            finally:
615
 
                fo.close()
616
 
            return filename
617
 
        
618
 
        return self._retry(opts, retryfunc, url, filename)
619
 
    
620
 
    def urlread(self, url, limit=None, **kwargs):
621
 
        """read the url into a string, up to 'limit' bytes
622
 
        If the limit is exceeded, an exception will be thrown.  Note
623
 
        that urlread is NOT intended to be used as a way of saying 
624
 
        "I want the first N bytes" but rather 'read the whole file 
625
 
        into memory, but don't use too much'
626
 
        """
627
 
        opts = self.opts.derive(**kwargs)
628
 
        (url, parts) = self._parse_url(url)
629
 
        if limit is not None:
630
 
            limit = limit + 1
631
 
            
632
 
        def retryfunc(opts, url, limit):
633
 
            fo = URLGrabberFileObject(url, filename=None, opts=opts)
634
 
            s = ''
635
 
            try:
636
 
                # this is an unfortunate thing.  Some file-like objects
637
 
                # have a default "limit" of None, while the built-in (real)
638
 
                # file objects have -1.  They each break the other, so for
639
 
                # now, we just force the default if necessary.
640
 
                if limit is None: s = fo.read()
641
 
                else: s = fo.read(limit)
642
 
 
643
 
                if not opts.checkfunc is None:
644
 
                    cb_func, cb_args, cb_kwargs = \
645
 
                             self._make_callback(opts.checkfunc)
646
 
                    obj = CallbackObject()
647
 
                    obj.data = s
648
 
                    obj.url = url
649
 
                    apply(cb_func, (obj, )+cb_args, cb_kwargs)
650
 
            finally:
651
 
                fo.close()
652
 
            return s
653
 
            
654
 
        s = self._retry(opts, retryfunc, url, limit)
655
 
        if limit and len(s) > limit:
656
 
            raise URLGrabError(8, 
657
 
                        _('Exceeded limit (%i): %s') % (limit, url))
658
 
        return s
659
 
        
660
 
    def _parse_url(self,url):
661
 
        """break up the url into its component parts
662
 
 
663
 
        This function disassembles a url and
664
 
        1) "normalizes" it, tidying it up a bit
665
 
        2) does any authentication stuff it needs to do
666
 
 
667
 
        it returns the (cleaned) url and a tuple of component parts
668
 
        """
669
 
        if self.opts.prefix:
670
 
            p = self.opts.prefix
671
 
            if p[-1] == '/' or url[0] == '/': url = p + url
672
 
            else: url = p + '/' + url
673
 
            
674
 
        (scheme, host, path, parm, query, frag) = \
675
 
                                             urlparse.urlparse(url)
676
 
        if not scheme:
677
 
            if not url[0] == '/': url = os.path.abspath(url)
678
 
            url = 'file:' + url
679
 
            (scheme, host, path, parm, query, frag) = \
680
 
                                             urlparse.urlparse(url)
681
 
        path = os.path.normpath(path)
682
 
        if scheme in ['http', 'https']: path = urllib.quote(path)
683
 
        if '@' in host and auth_handler and scheme in ['http', 'https']:
684
 
            try:
685
 
                user_pass, host = host.split('@', 1)
686
 
                if ':' in user_pass: user, password = user_pass.split(':', 1)
687
 
            except ValueError, e:
688
 
                raise URLGrabError(1, _('Bad URL: %s') % url)
689
 
            if DEBUG: print 'adding HTTP auth: %s, %s' % (user, password)
690
 
            auth_handler.add_password(None, host, user, password)
691
 
        parts = (scheme, host, path, parm, query, frag)
692
 
        url = urlparse.urlunparse(parts)
693
 
        return url, parts
694
 
        
695
 
    def _make_callback(self, callback_obj):
696
 
        if callable(callback_obj):
697
 
            return callback_obj, (), {}
698
 
        else:
699
 
            return callback_obj
700
 
 
701
 
# create the default URLGrabber used by urlXXX functions.
702
 
# NOTE: actual defaults are set in URLGrabberOptions
703
 
default_grabber = URLGrabber()
704
 
 
705
 
class URLGrabberFileObject:
706
 
    """This is a file-object wrapper that supports progress objects 
707
 
    and throttling.
708
 
 
709
 
    This exists to solve the following problem: lets say you want to
710
 
    drop-in replace a normal open with urlopen.  You want to use a
711
 
    progress meter and/or throttling, but how do you do that without
712
 
    rewriting your code?  Answer: urlopen will return a wrapped file
713
 
    object that does the progress meter and-or throttling internally.
714
 
    """
715
 
 
716
 
    def __init__(self, url, filename, opts):
717
 
        self.url = url
718
 
        self.filename = filename
719
 
        self.opts = opts
720
 
        self.fo = None
721
 
        self._rbuf = ''
722
 
        self._rbufsize = 1024*8
723
 
        self._ttime = time.time()
724
 
        self._tsize = 0
725
 
        self._amount_read = 0
726
 
        self._opener = None
727
 
        self._do_open()
728
 
        
729
 
    def __getattr__(self, name):
730
 
        """This effectively allows us to wrap at the instance level.
731
 
        Any attribute not found in _this_ object will be searched for
732
 
        in self.fo.  This includes methods."""
733
 
        if hasattr(self.fo, name):
734
 
            return getattr(self.fo, name)
735
 
        raise AttributeError, name
736
 
    
737
 
    def _get_opener(self):
738
 
        """Build a urllib2 OpenerDirector based on request options."""
739
 
        if self.opts.opener:
740
 
            return self.opts.opener
741
 
        elif self._opener is None:
742
 
            handlers = []
743
 
            need_keepalive_handler = (keepalive_handler and self.opts.keepalive)
744
 
            need_range_handler = (range_handlers and \
745
 
                                  (self.opts.range or self.opts.reget))
746
 
            # if you specify a ProxyHandler when creating the opener
747
 
            # it _must_ come before all other handlers in the list or urllib2
748
 
            # chokes.
749
 
            if self.opts.proxies:
750
 
                handlers.append( CachedProxyHandler(self.opts.proxies) )
751
 
 
752
 
                # -------------------------------------------------------
753
 
                # OK, these next few lines are a serious kludge to get
754
 
                # around what I think is a bug in python 2.2's
755
 
                # urllib2.  The basic idea is that default handlers
756
 
                # get applied first.  If you override one (like a
757
 
                # proxy handler), then the default gets pulled, but
758
 
                # the replacement goes on the end.  In the case of
759
 
                # proxies, this means the normal handler picks it up
760
 
                # first and the proxy isn't used.  Now, this probably
761
 
                # only happened with ftp or non-keepalive http, so not
762
 
                # many folks saw it.  The simple approach to fixing it
763
 
                # is just to make sure you override the other
764
 
                # conflicting defaults as well.  I would LOVE to see
765
 
                # these go way or be dealt with more elegantly.  The
766
 
                # problem isn't there after 2.2.  -MDS 2005/02/24
767
 
                if not need_keepalive_handler:
768
 
                    handlers.append( urllib2.HTTPHandler() )
769
 
                if not need_range_handler:
770
 
                    handlers.append( urllib2.FTPHandler() )
771
 
                # -------------------------------------------------------
772
 
                    
773
 
            if need_keepalive_handler:
774
 
                handlers.append( keepalive_handler )
775
 
            if need_range_handler:
776
 
                handlers.extend( range_handlers )
777
 
            handlers.append( auth_handler )
778
 
            if self.opts.cache_openers:
779
 
              self._opener = CachedOpenerDirector(*handlers)
780
 
            else:
781
 
              self._opener = urllib2.build_opener(*handlers)
782
 
            # OK, I don't like to do this, but otherwise, we end up with
783
 
            # TWO user-agent headers.
784
 
            self._opener.addheaders = []
785
 
        return self._opener
786
 
        
787
 
    def _do_open(self):
788
 
        opener = self._get_opener()
789
 
 
790
 
        req = urllib2.Request(self.url) # build request object
791
 
        self._add_headers(req) # add misc headers that we need
792
 
        self._build_range(req) # take care of reget and byterange stuff
793
 
 
794
 
        fo, hdr = self._make_request(req, opener)
795
 
        if self.reget_time and self.opts.reget == 'check_timestamp':
796
 
            # do this if we have a local file with known timestamp AND
797
 
            # we're in check_timestamp reget mode.
798
 
            fetch_again = 0
799
 
            try:
800
 
                modified_tuple  = hdr.getdate_tz('last-modified')
801
 
                modified_stamp  = rfc822.mktime_tz(modified_tuple)
802
 
                if modified_stamp > self.reget_time: fetch_again = 1
803
 
            except (TypeError,):
804
 
                fetch_again = 1
805
 
            
806
 
            if fetch_again:
807
 
                # the server version is newer than the (incomplete) local
808
 
                # version, so we should abandon the version we're getting
809
 
                # and fetch the whole thing again.
810
 
                fo.close()
811
 
                self.opts.reget = None
812
 
                del req.headers['Range']
813
 
                self._build_range(req)
814
 
                fo, hdr = self._make_request(req, opener)
815
 
 
816
 
        (scheme, host, path, parm, query, frag) = urlparse.urlparse(self.url)
817
 
        if not (self.opts.progress_obj or self.opts.raw_throttle() \
818
 
                or self.opts.timeout):
819
 
            # if we're not using the progress_obj, throttling, or timeout
820
 
            # we can get a performance boost by going directly to
821
 
            # the underlying fileobject for reads.
822
 
            self.read = fo.read
823
 
            if hasattr(fo, 'readline'):
824
 
                self.readline = fo.readline
825
 
        elif self.opts.progress_obj:
826
 
            try:    length = int(hdr['Content-Length'])
827
 
            except: length = None
828
 
            self.opts.progress_obj.start(str(self.filename), self.url, 
829
 
                                         os.path.basename(path), 
830
 
                                         length,
831
 
                                         text=self.opts.text)
832
 
            self.opts.progress_obj.update(0)
833
 
        (self.fo, self.hdr) = (fo, hdr)
834
 
    
835
 
    def _add_headers(self, req):
836
 
        if self.opts.user_agent:
837
 
            req.add_header('User-agent', self.opts.user_agent)
838
 
        try: req_type = req.get_type()
839
 
        except ValueError: req_type = None
840
 
        if self.opts.http_headers and req_type in ('http', 'https'):
841
 
            for h, v in self.opts.http_headers:
842
 
                req.add_header(h, v)
843
 
        if self.opts.ftp_headers and req_type == 'ftp':
844
 
            for h, v in self.opts.ftp_headers:
845
 
                req.add_header(h, v)
846
 
 
847
 
    def _build_range(self, req):
848
 
        self.reget_time = None
849
 
        self.append = 0
850
 
        reget_length = 0
851
 
        rt = None
852
 
        if have_range and self.opts.reget and type(self.filename) == type(''):
853
 
            # we have reget turned on and we're dumping to a file
854
 
            try:
855
 
                s = os.stat(self.filename)
856
 
            except OSError:
857
 
                pass
858
 
            else:
859
 
                self.reget_time = s[ST_MTIME]
860
 
                reget_length = s[ST_SIZE]
861
 
                rt = reget_length, ''
862
 
                self.append = 1
863
 
                
864
 
        if self.opts.range:
865
 
            if not have_range:
866
 
                raise URLGrabError(10, _('Byte range requested but range '\
867
 
                                         'support unavailable'))
868
 
            rt = self.opts.range
869
 
            if rt[0]: rt = (rt[0] + reget_length, rt[1])
870
 
 
871
 
        if rt:
872
 
            header = range_tuple_to_header(rt)
873
 
            if header: req.add_header('Range', header)
874
 
 
875
 
    def _make_request(self, req, opener):
876
 
        try:
877
 
            if have_socket_timeout and self.opts.timeout:
878
 
                old_to = socket.getdefaulttimeout()
879
 
                socket.setdefaulttimeout(self.opts.timeout)
880
 
                try:
881
 
                    fo = opener.open(req)
882
 
                finally:
883
 
                    socket.setdefaulttimeout(old_to)
884
 
            else:
885
 
                fo = opener.open(req)
886
 
            hdr = fo.info()
887
 
        except ValueError, e:
888
 
            raise URLGrabError(1, _('Bad URL: %s') % (e, ))
889
 
        except RangeError, e:
890
 
            raise URLGrabError(9, _('%s') % (e, ))
891
 
        except IOError, e:
892
 
            if hasattr(e, 'reason') and have_socket_timeout and \
893
 
                   isinstance(e.reason, TimeoutError):
894
 
                raise URLGrabError(12, _('Timeout: %s') % (e, ))
895
 
            else:
896
 
                raise URLGrabError(4, _('IOError: %s') % (e, ))
897
 
        except OSError, e:
898
 
            raise URLGrabError(5, _('OSError: %s') % (e, ))
899
 
        except HTTPException, e:
900
 
            raise URLGrabError(7, _('HTTP Error (%s): %s') % \
901
 
                            (e.__class__.__name__, e))
902
 
        else:
903
 
            return (fo, hdr)
904
 
        
905
 
    def _do_grab(self):
906
 
        """dump the file to self.filename."""
907
 
        if self.append: new_fo = open(self.filename, 'ab')
908
 
        else: new_fo = open(self.filename, 'wb')
909
 
        bs = 1024*8
910
 
        size = 0
911
 
 
912
 
        block = self.read(bs)
913
 
        size = size + len(block)
914
 
        while block:
915
 
            new_fo.write(block)
916
 
            block = self.read(bs)
917
 
            size = size + len(block)
918
 
 
919
 
        new_fo.close()
920
 
        try:
921
 
            modified_tuple  = self.hdr.getdate_tz('last-modified')
922
 
            modified_stamp  = rfc822.mktime_tz(modified_tuple)
923
 
            os.utime(self.filename, (modified_stamp, modified_stamp))
924
 
        except (TypeError,), e: pass
925
 
 
926
 
        return size
927
 
    
928
 
    def _fill_buffer(self, amt=None):
929
 
        """fill the buffer to contain at least 'amt' bytes by reading
930
 
        from the underlying file object.  If amt is None, then it will
931
 
        read until it gets nothing more.  It updates the progress meter
932
 
        and throttles after every self._rbufsize bytes."""
933
 
        # the _rbuf test is only in this first 'if' for speed.  It's not
934
 
        # logically necessary
935
 
        if self._rbuf and not amt is None:
936
 
            L = len(self._rbuf)
937
 
            if amt > L:
938
 
                amt = amt - L
939
 
            else:
940
 
                return
941
 
 
942
 
        # if we've made it here, then we don't have enough in the buffer
943
 
        # and we need to read more.
944
 
 
945
 
        buf = [self._rbuf]
946
 
        bufsize = len(self._rbuf)
947
 
        while amt is None or amt:
948
 
            # first, delay if necessary for throttling reasons
949
 
            if self.opts.raw_throttle():
950
 
                diff = self._tsize/self.opts.raw_throttle() - \
951
 
                       (time.time() - self._ttime)
952
 
                if diff > 0: time.sleep(diff)
953
 
                self._ttime = time.time()
954
 
                
955
 
            # now read some data, up to self._rbufsize
956
 
            if amt is None: readamount = self._rbufsize
957
 
            else:           readamount = min(amt, self._rbufsize)
958
 
            try:
959
 
                new = self.fo.read(readamount)
960
 
            except socket.error, e:
961
 
                raise URLGrabError(4, _('Socket Error: %s') % (e, ))
962
 
            except TimeoutError, e:
963
 
                raise URLGrabError(12, _('Timeout: %s') % (e, ))
964
 
            newsize = len(new)
965
 
            if not newsize: break # no more to read
966
 
 
967
 
            if amt: amt = amt - newsize
968
 
            buf.append(new)
969
 
            bufsize = bufsize + newsize
970
 
            self._tsize = newsize
971
 
            self._amount_read = self._amount_read + newsize
972
 
            if self.opts.progress_obj:
973
 
                self.opts.progress_obj.update(self._amount_read)
974
 
 
975
 
        self._rbuf = string.join(buf, '')
976
 
        return
977
 
 
978
 
    def read(self, amt=None):
979
 
        self._fill_buffer(amt)
980
 
        if amt is None:
981
 
            s, self._rbuf = self._rbuf, ''
982
 
        else:
983
 
            s, self._rbuf = self._rbuf[:amt], self._rbuf[amt:]
984
 
        return s
985
 
 
986
 
    def readline(self, limit=-1):
987
 
        i = string.find(self._rbuf, '\n')
988
 
        while i < 0 and not (0 < limit <= len(self._rbuf)):
989
 
            L = len(self._rbuf)
990
 
            self._fill_buffer(L + self._rbufsize)
991
 
            if not len(self._rbuf) > L: break
992
 
            i = string.find(self._rbuf, '\n', L)
993
 
 
994
 
        if i < 0: i = len(self._rbuf)
995
 
        else: i = i+1
996
 
        if 0 <= limit < len(self._rbuf): i = limit
997
 
 
998
 
        s, self._rbuf = self._rbuf[:i], self._rbuf[i:]
999
 
        return s
1000
 
 
1001
 
    def close(self):
1002
 
        if self.opts.progress_obj:
1003
 
            self.opts.progress_obj.end(self._amount_read)
1004
 
        self.fo.close()
1005
 
        if self.opts.close_connection:
1006
 
            try: self.fo.close_connection()
1007
 
            except: pass
1008
 
 
1009
 
_handler_cache = []
1010
 
def CachedOpenerDirector(*handlers):
1011
 
    for (cached_handlers, opener) in _handler_cache:
1012
 
        if cached_handlers == handlers:
1013
 
            for handler in opener.handlers:
1014
 
                handler.add_parent(opener)
1015
 
            return opener
1016
 
    opener = urllib2.build_opener(*handlers)
1017
 
    _handler_cache.append( (handlers, opener) )
1018
 
    return opener
1019
 
 
1020
 
_proxy_cache = []
1021
 
def CachedProxyHandler(proxies):
1022
 
    for (pdict, handler) in _proxy_cache:
1023
 
        if pdict == proxies:
1024
 
            break
1025
 
    else:
1026
 
        handler = urllib2.ProxyHandler(proxies)
1027
 
        _proxy_cache.append( (proxies, handler) )
1028
 
    return handler
1029
 
 
1030
 
#####################################################################
1031
 
# DEPRECATED FUNCTIONS
1032
 
def set_throttle(new_throttle):
1033
 
    """Deprecated. Use: default_grabber.throttle = new_throttle"""
1034
 
    default_grabber.throttle = new_throttle
1035
 
 
1036
 
def set_bandwidth(new_bandwidth):
1037
 
    """Deprecated. Use: default_grabber.bandwidth = new_bandwidth"""
1038
 
    default_grabber.bandwidth = new_bandwidth
1039
 
 
1040
 
def set_progress_obj(new_progress_obj):
1041
 
    """Deprecated. Use: default_grabber.progress_obj = new_progress_obj"""
1042
 
    default_grabber.progress_obj = new_progress_obj
1043
 
 
1044
 
def set_user_agent(new_user_agent):
1045
 
    """Deprecated. Use: default_grabber.user_agent = new_user_agent"""
1046
 
    default_grabber.user_agent = new_user_agent
1047
 
    
1048
 
def retrygrab(url, filename=None, copy_local=0, close_connection=0,
1049
 
              progress_obj=None, throttle=None, bandwidth=None,
1050
 
              numtries=3, retrycodes=[-1,2,4,5,6,7], checkfunc=None):
1051
 
    """Deprecated. Use: urlgrab() with the retry arg instead"""
1052
 
    kwargs = {'copy_local' :  copy_local, 
1053
 
              'close_connection' : close_connection,
1054
 
              'progress_obj' : progress_obj, 
1055
 
              'throttle' : throttle, 
1056
 
              'bandwidth' : bandwidth,
1057
 
              'retry' : numtries,
1058
 
              'retrycodes' : retrycodes,
1059
 
              'checkfunc' : checkfunc 
1060
 
              }
1061
 
    return urlgrab(url, filename, **kwargs)
1062
 
 
1063
 
        
1064
 
#####################################################################
1065
 
#  TESTING
1066
 
def _main_test():
1067
 
    import sys
1068
 
    try: url, filename = sys.argv[1:3]
1069
 
    except ValueError:
1070
 
        print 'usage:', sys.argv[0], \
1071
 
              '<url> <filename> [copy_local=0|1] [close_connection=0|1]'
1072
 
        sys.exit()
1073
 
 
1074
 
    kwargs = {}
1075
 
    for a in sys.argv[3:]:
1076
 
        k, v = string.split(a, '=', 1)
1077
 
        kwargs[k] = int(v)
1078
 
 
1079
 
    set_throttle(1.0)
1080
 
    set_bandwidth(32 * 1024)
1081
 
    print "throttle: %s,  throttle bandwidth: %s B/s" % (default_grabber.throttle, 
1082
 
                                                        default_grabber.bandwidth)
1083
 
 
1084
 
    try: from progress import text_progress_meter
1085
 
    except ImportError, e: pass
1086
 
    else: kwargs['progress_obj'] = text_progress_meter()
1087
 
 
1088
 
    try: name = apply(urlgrab, (url, filename), kwargs)
1089
 
    except URLGrabError, e: print e
1090
 
    else: print 'LOCAL FILE:', name
1091
 
 
1092
 
 
1093
 
def _retry_test():
1094
 
    import sys
1095
 
    try: url, filename = sys.argv[1:3]
1096
 
    except ValueError:
1097
 
        print 'usage:', sys.argv[0], \
1098
 
              '<url> <filename> [copy_local=0|1] [close_connection=0|1]'
1099
 
        sys.exit()
1100
 
 
1101
 
    kwargs = {}
1102
 
    for a in sys.argv[3:]:
1103
 
        k, v = string.split(a, '=', 1)
1104
 
        kwargs[k] = int(v)
1105
 
 
1106
 
    try: from progress import text_progress_meter
1107
 
    except ImportError, e: pass
1108
 
    else: kwargs['progress_obj'] = text_progress_meter()
1109
 
 
1110
 
    global DEBUG
1111
 
    #DEBUG = 1
1112
 
    def cfunc(filename, hello, there='foo'):
1113
 
        print hello, there
1114
 
        import random
1115
 
        rnum = random.random()
1116
 
        if rnum < .5:
1117
 
            print 'forcing retry'
1118
 
            raise URLGrabError(-1, 'forcing retry')
1119
 
        if rnum < .75:
1120
 
            print 'forcing failure'
1121
 
            raise URLGrabError(-2, 'forcing immediate failure')
1122
 
        print 'success'
1123
 
        return
1124
 
        
1125
 
    close_all()
1126
 
    kwargs['checkfunc'] = (cfunc, ('hello',), {'there':'there'})
1127
 
    try: name = apply(retrygrab, (url, filename), kwargs)
1128
 
    except URLGrabError, e: print e
1129
 
    else: print 'LOCAL FILE:', name
1130
 
 
1131
 
def _file_object_test(filename=None):
1132
 
    import random, cStringIO, sys
1133
 
    if filename is None:
1134
 
        filename = __file__
1135
 
    print 'using file "%s" for comparisons' % filename
1136
 
    fo = open(filename)
1137
 
    s_input = fo.read()
1138
 
    fo.close()
1139
 
 
1140
 
    for testfunc in [_test_file_object_smallread,
1141
 
                     _test_file_object_readall,
1142
 
                     _test_file_object_readline,
1143
 
                     _test_file_object_readlines]:
1144
 
        fo_input = cStringIO.StringIO(s_input)
1145
 
        fo_output = cStringIO.StringIO()
1146
 
        wrapper = URLGrabberFileObject(fo_input, None, 0)
1147
 
        print 'testing %-30s ' % testfunc.__name__,
1148
 
        testfunc(wrapper, fo_output)
1149
 
        s_output = fo_output.getvalue()
1150
 
        if s_output == s_input: print 'passed'
1151
 
        else: print 'FAILED'
1152
 
            
1153
 
def _test_file_object_smallread(wrapper, fo_output):
1154
 
    while 1:
1155
 
        s = wrapper.read(23)
1156
 
        fo_output.write(s)
1157
 
        if not s: return
1158
 
 
1159
 
def _test_file_object_readall(wrapper, fo_output):
1160
 
    s = wrapper.read()
1161
 
    fo_output.write(s)
1162
 
 
1163
 
def _test_file_object_readline(wrapper, fo_output):
1164
 
    while 1:
1165
 
        s = wrapper.readline()
1166
 
        fo_output.write(s)
1167
 
        if not s: return
1168
 
 
1169
 
def _test_file_object_readlines(wrapper, fo_output):
1170
 
    li = wrapper.readlines()
1171
 
    fo_output.write(string.join(li, ''))
1172
 
 
1173
 
if __name__ == '__main__':
1174
 
    _main_test()
1175
 
    _retry_test()
1176
 
    _file_object_test('test')
1177