lazr.batchnavigator 2.0.0

Batch navigation provides a way to navigate batch results in a web page by providing URL links to the next, previous and numbered pages of results.

It uses four query/POST arguments to control the batching:

• memo: A record of the underlying storage index pointer for the position of the batch.

• direction: Indicates whether the memo is at the start or end of the batch.

• start: Cosmetic - used to calculate the apparent location (but note that due to the concurrent nature of repeated visits to batches that the true offset may differ - however the collection won’t skip or show items twice. For compatibility with saved URLs, if memo and direction are both missing then start is used to do list slicing into the collection.

• batch: Controls the amount of items we are showing per batch. It will only appear if it’s different from the default value set when the batch is created.

These values can be overriden in the request, unless you also pass force_start=True, which will make the start argument (again, defaulting to 0) always chosen.

Imports:

>>> from lazr.batchnavigator import BatchNavigator, ListRangeFactory
>>> from zope.publisher.browser import TestRequest
>>> from zope.publisher.http import HTTPCharsets
>>> from zope.component import getSiteManager
>>> sm = getSiteManager()
>>> sm.registerAdapter(HTTPCharsets)

>>> def build_request(query_string_args=None, method='GET'):
...   if query_string_args is None:
...       query_string = ''
...   else:
...       if getattr(query_string_args, 'items', None) is not None:
...           query_string_args = query_string_args.items()
...       query_string = "&".join(
...           ["%s=%s" % (k,v) for k,v in query_string_args])
...   request = TestRequest(SERVER_URL='http://www.example.com/foo',
...                                  method=method,
...                                  environ={'QUERY_STRING': query_string})
...   request.processInputs()
...   return request

A sample request object:

Some sample data.

>>> reindeer = ['Dasher', 'Dancer', 'Prancer', 'Vixen', 'Comet',
...             'Cupid', 'Donner', 'Blitzen', 'Rudolph']

Because slicing large collections can be very expensive, BatchNavigator offers a non-slice protocol for determining the edge of batches. The range_factory supplies an object implementing IRangeFactory and manages this protocol. ListRangeFactory is a simple included implementation which BatchNavigator will use if no range_factory is supplied.

>>> _ = BatchNavigator(reindeer, build_request(),
...     range_factory=ListRangeFactory(reindeer))

For the examples in the documentation we let BatchNavigator construct a range_factory implicitly:

>>> safe_reindeer = reindeer
>>> safe_reindeer_batch_navigator = BatchNavigator(
...     safe_reindeer, build_request(), size=3)

An important feature of lazr.batchnavigator is its reluctance to invoke len() on an underlying data set. len() can be an expensive operation that provides little benefit, so this library tries hard to avoid calling len() unless it’s absolutely necessary. To show this off, we’ll define a subclass of Python’s list type that explodes when len() is invoked on it.

>>> class ListWithExplosiveLen(list):
...     """A list subclass that doesn't like its len() being called."""
...     def __len__(self):
...         raise RuntimeError

Unless otherwise stated, we will use this list exclusively throughout this test, to verify that len() is never called unless we want it to be.

>>> explosive_reindeer = ListWithExplosiveLen(reindeer)
>>> reindeer_batch_navigator = BatchNavigator(
...     explosive_reindeer, build_request(), size=3)

The BatchNavigator implements IBatchNavigator. We need to use the ‘safe’ batch navigator here, because verifyObject probes all methods of the object it’s passed, including __len__.

>>> from zope.interface.verify import verifyObject
>>> from lazr.batchnavigator.interfaces import IBatchNavigator

>>> verifyObject(IBatchNavigator, safe_reindeer_batch_navigator)
True

The BatchNavigator class provides IBatchNavigatorFactory. This can be used to register a batch navigator factory as a utility, for instance.

>>> from lazr.batchnavigator.interfaces import IBatchNavigatorFactory

>>> verifyObject(IBatchNavigatorFactory, BatchNavigator)
True

You can ask the navigator for the chunk of results currently being shown (e.g. to iterate over them for rendering in ZPT):

>>> list(reindeer_batch_navigator.currentBatch())
['Dasher', 'Dancer', 'Prancer']

You can ask for the first, previous, next and last results’ links:

>>> reindeer_batch_navigator.firstBatchURL()
''
>>> reindeer_batch_navigator.prevBatchURL()
''
>>> reindeer_batch_navigator.nextBatchURL()
'http://www.example.com/foo?memo=3&start=3'

There’s no way to get the URL to the final batch without knowing the length of the entire list, so we’ll use the safe batch navigator to demonstrate lastBatchURL():

>>> safe_reindeer_batch_navigator.lastBatchURL()
'http://www.example.com/foo?direction=backwards&start=6'

The next link will be empty when there are no further results:

>>> request = build_request({"start": "3", "batch": "20"})
>>> last_reindeer_batch_navigator = BatchNavigator(reindeer, request=request)
>>> last_reindeer_batch_navigator.nextBatchURL()
''

The first and previous link should appear even when we start at a point between 0 and the batch size:

>>> request = build_request({"start": "2", "batch": "3"})
>>> last_reindeer_batch_navigator = BatchNavigator(reindeer, request=request)

Here, we can see too that the batch argument appears as part of the URL. That’s because the request asked for a different size than the default one when we create the Batch object, by default, it’s 5.

>>> last_reindeer_batch_navigator.firstBatchURL()
'http://www.example.com/foo?batch=3'

>>> last_reindeer_batch_navigator.prevBatchURL()
'http://www.example.com/foo?batch=3&direction=backwards&memo=2'

This all works with other values in the query string, too:

>>> request = build_request({'fnorb': 'bar',
...                          'start': '3',
...                          'batch': '3'})
>>> reindeer_batch_navigator_with_qs = BatchNavigator(
...     reindeer, request, size=3)
>>> safe_reindeer_batch_navigator_with_qs = BatchNavigator(
...     safe_reindeer, request, size=3)

In this case, we created the BatchNavigator with a default size of ‘3’ and the request is asking exactly that number of items per batch, and thus, we don’t need to show ‘batch’ as part of the URL.

>>> reindeer_batch_navigator_with_qs.firstBatchURL()
'http://www.example.com/foo?fnorb=bar'
>>> reindeer_batch_navigator_with_qs.prevBatchURL()
'http://www.example.com/foo?fnorb=bar&direction=backwards&memo=3'
>>> reindeer_batch_navigator_with_qs.nextBatchURL()
'http://www.example.com/foo?fnorb=bar&memo=6&start=6'

(Again, there’s no way to get the last batch without knowing the size of the entire list.)

>>> safe_reindeer_batch_navigator_with_qs.lastBatchURL()
'http://www.example.com/foo?fnorb=bar&direction=backwards&start=6'

The force_start argument allows you to ignore the start value in the request. This can be useful when, for instance, a filter has changed, and the desired behavior is to restart at 0.

>>> reindeer_batch_navigator_with_qs = BatchNavigator(
...     reindeer, request, size=3, force_start=True)
>>> reindeer_batch_navigator_with_qs.currentBatch().start
0
>>> reindeer_batch_navigator_with_qs.nextBatchURL()
'http://www.example.com/foo?fnorb=bar&memo=3&start=3'
>>> reindeer[:3] == list(reindeer_batch_navigator_with_qs.currentBatch())
True

We ensure that batch arguments supplied in the URL are observed for POST operations too:

>>> request = build_request({'fnorb': 'bar',
...                          'start': '3',
...                          'batch': '3'}, method='POST')
>>> reindeer_batch_navigator_post_with_qs = BatchNavigator(
...     reindeer, request)

>>> reindeer_batch_navigator_post_with_qs.start
3
>>> reindeer_batch_navigator_post_with_qs.nextBatchURL()
'http://www.example.com/foo?fnorb=bar&batch=3&memo=6&start=6'

We ensure that multiple size and batch arguments supplied in the URL don’t blow up the application. The first one is preferred.

>>> request = build_request(
...     [('batch', '1'), ('batch', '7'), ('start', '2'), ('start', '10')])
>>> navigator = BatchNavigator(reindeer, request=request)
>>> navigator.nextBatchURL()
'http://www.example.com/foo?batch=1&memo=3&start=3'

The batch argument must be positive. Other numbers are ignored, and the default batch size is used instead.

>>> from six.moves.urllib.parse import parse_qs
>>> request = build_request({'batch': '0'})
>>> navigator = BatchNavigator(range(99), request=request)
>>> print('batch' in parse_qs(navigator.nextBatchURL()))
False

>>> request = build_request({'batch': '-1'})
>>> navigator = BatchNavigator(range(99), request=request)
>>> print('batch' in parse_qs(navigator.nextBatchURL()))
False