appendonly 1.2

appendonly.AppendStack

This class provides a LIFO stack of separately-persisted objects:

• The stack manages a set of “layer” objects, with a configurable limit on the number of layers. Each layer has a configurable maximum length, and a sequential generation number.

• The stack appends items to most recent layer until the layer is filled; it then adds a new layer.

• If the number of layers then exceeds the configured maximum, the stack pruneds the oldest layer(s) to conform to that limit.

• When pruning, the stack calls an application-supplied callback for archiving / cleanup of the pruned layer.

• Iteration over the stack yields (generation, index, object) tuples. in reverse order to that in which the objects were appended.

The stack is implemented as a single persistent record, with custom ZODB conflict resolution code.

appendonly.Archive

This class provides a linked list of separately-persisted copies of layer data pruned from an AppendStack. The intended use would be something like:

from appendonly import AppendStack
from appendonly import Archive

class RecentItems(object):
    def __init__(self):
        self._recent = AppendStack()
        self._archive = Archive()

    def pushItem(object):
        self._stack.push(object, self._archive.addLayer)

    def __iter__(self):
        for generation, index, item in self._stack:
            yield item
        for generation, index, item in self._archive:
            yield items

appendonly.Accumulator

This class provides a list-like data structure, where the only mutations allowed are to append to or clear the list. Intended uses are for a set of pending operations / changes / notifications, which get processed as a unit (at which point the accumulator is cleared).

1.2 (2014-12-28)

• Add support for Python 3.4.

• Make ZODB dependency unconditional, now that it fully supports Py3k.

• Add support for testing on Travis.

1.1 (2013-11-28)

• Add Accumulator.extend method to enhance list-ness.

• Add support for PyPy.

• Add support for Python 3.2 / 3.3.

1.0.1 (2013-02-25)

• Fix brown-bag in 1.0 release (Accumulator.append changes were not persisted).

1.0 (2013-02-25)

• Add a conflict-free ‘Accumulator’ class: manages a queue of items which can be iterated, appended to, or conumed entirely (no partial / pop).

• Automate tests for supported Python versions via ‘tox’.

• Drop support for Python 2.4 / 2.5.

0.10 (2012-02-21)

• Add an ‘Archive’ class, intended to support long-term storage of the layer data pruned from an ‘AppendStack’.

0.9 (2010-08-09)

• Initial public release.