Polish merge and bump to v0.10.1

Author: bradleyayers

README.rst

@@ -63,6 +63,17 @@ globally, use::
 Change log
 ==========
 
+v0.10.1
+-------
+
+- Fixed support for Django 1.4's paginator (thanks koledennix)
+- Some juggling of internal implementation. `TableData` now supports slicing
+ and returns new `TableData` instances. `BoundRows` now takes a single
+ argument `data` (a `TableData` instance).
+- Add support for `get_pagination` on `SingleTableMixin`.
+- `SingleTableMixin` and `SingleTableView` are now importable directly from
+ `django_tables2`.
+
 v0.10.0
 -------
 

django_tables2/__init__.py

@@ -3,3 +3,4 @@
 from .columns import Column, CheckBoxColumn, LinkColumn, TemplateColumn
 from .config import RequestConfig
 from .utils import A, Attrs
+from .views import SingleTableMixin, SingleTableView

django_tables2/rows.py

@@ -173,45 +173,28 @@ class BoundRows(object):
  """
  Container for spawning :class:`.BoundRow` objects.
 
- The :attr:`.Table.rows` attribute is a :class:`.BoundRows` object.
- It provides functionality that would not be possible with a simple iterator
- in the table class.
-
- :type table: :class:`.Table` object
- :param table: the table in which the rows exist.
+ :type data: :class:`.TableData` object
+ :param data: the table in which the rows exist.
 
+ This is used for :attr:`.Table.rows`.
  """
- def __init__(self, table, slice=None):
- self.table = table
- if slice is not None:
- self._data = table.data[slice]
- else:
- self._data = None
-
- @property
- def data(self):
- if self._data:
- return self._data
- else:
- return self.table.data
+ def __init__(self, data):
+ self.data = data
 
  def __iter__(self):
- """Convience method for :meth:`.BoundRows.all`"""
+ table = self.data.table # avoid repeated lookups
  for record in self.data:
- yield BoundRow(self.table, record)
+ yield BoundRow(table, record)
 
  def __len__(self):
- """Returns the number of rows in the table."""
  return len(self.data)
 
- # for compatibility with QuerySetPaginator
- count = __len__
-
  def __getitem__(self, key):
- """Allows normal list slicing syntax to be used."""
+ """
+ Slicing returns a new :class:`.BoundRows` instance, indexing returns
+ a single :class:`.BoundRow` instance.
+ """
  if isinstance(key, slice):
- return BoundRows(self.table, key)
- elif isinstance(key, int):
- return BoundRow(self.table, self.data[key])
+ return BoundRows(self.data[key])
  else:
- raise TypeError('Key must be a slice or integer.')
+ return BoundRow(self.data.table, self.data[key])

django_tables2/tables.py

@@ -21,14 +21,14 @@
 
 class TableData(object):
  """
- Exposes a consistent API for :term:`table data`. It currently supports a
- :class:`QuerySet`, or a :class:`list` of :class:`dict` objects.
+ Exposes a consistent API for :term:`table data`.
 
- This class is used by :class:`.Table` to wrap any
- input table data.
+ :param data: iterable containing data for each row
+ :type data: :class:`QuerySet` or :class:`list` of :class:`dict`
+ :param table: :class:`.Table` object
  """
  def __init__(self, data, table):
- self._table = table
+ self.table = table
  # data may be a QuerySet-like objects with count() and order_by()
  if (hasattr(data, 'count') and callable(data.count) and
  hasattr(data, 'order_by') and callable(data.order_by)):
@@ -70,7 +70,7 @@ def _translate_aliases_to_accessors(self, aliases):
  """
  Translate from order by aliases to column accessors.
  """
- columns = (self._table.columns[OrderBy(alias).bare] for alias in aliases)
+ columns = (self.table.columns[OrderBy(alias).bare] for alias in aliases)
  return OrderByTuple(itertools.chain(*(c.order_by for c in columns)))
 
  def __iter__(self):
@@ -81,9 +81,16 @@ def __iter__(self):
  """
  return iter(self.list) if hasattr(self, 'list') else iter(self.queryset)
 
- def __getitem__(self, index):
- """Forwards indexing accesses to underlying data"""
- return (self.list if hasattr(self, 'list') else self.queryset)[index]
+ def __getitem__(self, key):
+ """
+ Slicing returns a new :class:`.TableData` instance, indexing returns a
+ single record.
+ """
+ data = (self.list if hasattr(self, 'list') else self.queryset)[key]
+ if isinstance(key, slice):
+ return type(self)(data, self.table)
+ else:
+ return data
 
 
 class DeclarativeColumnsMetaclass(type):
@@ -226,9 +233,9 @@ def __init__(self, data, order_by=None, orderable=None, empty_text=None,
  order_by_field=None, page_field=None, per_page_field=None,
  template=None, sortable=None):
  super(Table, self).__init__()
- self.rows = BoundRows(self)
- self.columns = BoundColumns(self)
  self.data = self.TableDataClass(data=data, table=self)
+ self.rows = BoundRows(self.data)
+ self.columns = BoundColumns(self)
  self.attrs = attrs
  self.empty_text = empty_text
  if sortable is not None:

django_tables2/utils.py

@@ -64,7 +64,12 @@ class OrderBy(str):
  @property
  def bare(self):
  """
- Return the :term:`bare <bare orderby>` form.
+ Return the bare form.
+
+ The *bare form* is the non-prefixed form. Typically the bare form is
+ just the ascending form.
+
+ Example: ``age`` is the bare form of ``-age``
 
  :rtype: :class:`.OrderBy` object
  """

docs/conf.py

@@ -54,9 +54,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = '0.9'
+version = '0.10'
 # The full version, including alpha/beta/rc tags.
-release = '0.9.6'
+release = '0.10.1'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/index.rst

@@ -26,8 +26,8 @@ It's available in a few places, feedback is always welcome.
 Tutorial
 ========
 
-Install the app via ``pip install django-tables2``, then add
-``'django_tables2'`` to ``INSTALLED_APPS``.
+1. ``pip install django-tables2``
+2. Add ``'django_tables2'`` to ``INSTALLED_APPS``
 
 Find some data that you'd like to render as a table. A QuerySet will work, but
 ease of demonstration we'll use a list of dicts:
@@ -342,31 +342,24 @@ a hook that allows abitrary attributes to be added to the ``<table>`` tag.
 --------------------------------
 
 If you want to adjust the way table cells in a particular column are rendered,
-you can implement a ``render_FOO`` method. ``FOO`` is replaced with the
+you can implement a ``render_FOO`` method. ``FOO`` should be the
 :term:`name <column name>` of the column.
 
 This approach provides a lot of control, but is only suitable if you intend to
 customise the rendering for a single table (otherwise you'll end up having to
 copy & paste the method to every table you want to modify – which violates
 DRY).
 
-For convenience, a bunch of commonly used/useful values are passed to
-``render_FOO`` functions, when writing the signature, simply accept the
-arguments you're interested in, and the function will recieve them
+Supported keyword arguments include: (only the arguments declared will be passed)
 
-.. note:: Due to the implementation, a "catch-extra" arguments (e.g. ``*args``
- or ``**kwargs``) will not recieve any arguments. This is because
- ``inspect.getargsspec()`` is used to check what arguments a ``render_FOO``
- method expect, and only to supply those.
+- ``record`` -- the entire record for the row from the :term:`table data`
+- ``value`` -- the value for the cell retrieved from the :term:`table data`
+- ``column`` -- the :class:`.Column` object
+- ``bound_column`` -- the :class:`.BoundColumn` object
+- ``bound_row`` -- the :class:`.BoundRow` object
+- ``table`` -- alias for ``self``
 
-:param value: the value for the cell retrieved from the :term:`table data`
-:param record: the entire record for the row from :term:`table data`
-:param column: the :class:`.Column` object
-:param bound_column: the :class:`.BoundColumn` object
-:param bound_row: the :class:`.BoundRow` object
-:param table: alias for ``self``
-
-.. code-block:: python
+Example::
 
  >>> import django_tables2 as tables
  >>> class SimpleTable(tables.Table):
@@ -390,6 +383,15 @@ arguments you're interested in, and the function will recieve them
  <10>
  31
 
+.. note::
+
+ Due to the implementation of dynamic argument passing, any "catch-extra"
+ arguments (e.g. ``*args`` or ``**kwargs``) will not recieve any arguments.
+ This is because `inspect.getargsspec()`__ is used to check what arguments a
+ ``render_FOO`` method expect, and only to supply those.
+
+.. __: http://docs.python.org/library/inspect.html#inspect.getargspec
+
 
 .. _query-string-fields:
 
@@ -645,37 +647,37 @@ Class Based Generic Mixins
 Django 1.3 introduced `class based views`__ as a mechanism to reduce the
 repetition in view code. django-tables2 comes with a single class based view
 mixin: ``SingleTableMixin``. It makes it trivial to incorporate a table into a
-view/template, however it requires a few variables to be defined on the view:
+view/template.
+
+The following view parameters are supported:
 
 - ``table_class`` –- the table class to use, e.g. ``SimpleTable``
-- ``table_data`` (or ``get_table_data()``) -- the data used to populate the
- table
-- ``context_table_name`` -- the name of template variable containing the table
- object
+- ``table_data`` (or ``get_table_data()``) -- the data used to populate the table
+- ``context_table_name`` -- the name of template variable containing the table object
+- ``table_pagination`` -- pagination options to pass to :class:`RequestConfig`
 
 .. __: https://docs.djangoproject.com/en/1.3/topics/class-based-views/
 
 For example:
 
 .. code-block:: python
 
- from django_tables2.views import SingleTableMixin
- from django.views.generic.list import ListView
+ from django_tables2 import SingleTableView
 
 
- class Simple(models.Model):
+ class Person(models.Model):
  first_name = models.CharField(max_length=200)
  last_name = models.CharField(max_length=200)
 
 
- class SimpleTable(tables.Table):
- first_name = tables.Column()
- last_name = tables.Column()
+ class PersonTable(tables.Table):
+ class Meta:
+  model = Simple
 
 
- class MyTableView(SingleTableMixin, ListView):
- model = Simple
- table_class = SimpleTable
+ class PersonList(SingleTableView):
+ model = Person
+ table_class = PersonTable
 
 
 The template could then be as simple as:
@@ -691,11 +693,14 @@ when one isn't explicitly defined.
 
 .. note::
 
- If you want more than one table on a page, at the moment the simplest way
- to do it is to use ``SimpleTableMixin`` for one of the tables, and write
- the boilerplate for the other yourself in ``get_context_data()``. Obviously
- this isn't particularly elegant, and as such will hopefully be resolved in
- the future.
+ If you need more than one table on a page, use ``SingleTableView`` and use
+ ``get_context_data()`` to initialise the other tables and add them to the
+ context.
+
+.. note::
+
+ You don't have to base your view on ``ListView``, you're able to mix
+ ``SingleTableMixin`` directly.
 
 
 Table Mixins
@@ -811,8 +816,8 @@ fixed in a similar way -- the :attr:`.Table.Meta.sequence` option::
 API Reference
 =============
 
-:class:`Accessor` Objects:
---------------------------
+:class:`Accessor` (`A`) Objects:
+--------------------------------
 
 .. autoclass:: django_tables2.utils.Accessor
 
@@ -1060,7 +1065,7 @@ API Reference
 --------------------------
 
 .. autoclass:: django_tables2.rows.BoundRows
- :members: __iter__, __len__, count
+ :members: __iter__, __len__
 
 
 :class:`BoundRow` Objects
@@ -1070,27 +1075,6 @@ API Reference
  :members: __getitem__, __contains__, __iter__, record, table, items
 
 
-:class:`AttributeDict` Objects
-------------------------------
-
-.. autoclass:: django_tables2.utils.AttributeDict
- :members:
-
-
-:class:`OrderBy` Objects
-------------------------
-
-.. autoclass:: django_tables2.utils.OrderBy
- :members:
-
-
-:class:`OrderByTuple` Objects
------------------------------
-
-.. autoclass:: django_tables2.utils.OrderByTuple
- :members: __unicode__, __contains__, __getitem__, cmp, get
-
-
 Upgrading from django-tables Version 1
 ======================================
 
@@ -1163,12 +1147,6 @@ Glossary
  accessor
  Refers to an :class:`~django_tables2.utils.Accessor` object
 
- bare orderby
- The non-prefixed form of an :class:`~django_tables2.utils.OrderBy`
- object. Typically the bare form is just the ascending form.
-
- Example: ``age`` is the bare form of ``-age``
-
  column name
  The name given to a column. In the follow example, the *column name* is
  ``age``.

setup.py

@@ -4,7 +4,7 @@
 
 setup(
  name='django-tables2',
- version='0.10.0',
+ version='0.10.1',
  description='Table/data-grid framework for Django',
 
  author='Bradley Ayers',

tests/__init__.py

@@ -12,10 +12,12 @@
 from .rows import rows
 from .templates import templates
 from .utils import utils
+from .views import views
 
 
 loader = django_attest.FancyReporter.test_loader
-everything = Tests([columns, config, core, models, rows, templates, utils])
+everything = Tests([columns, config, core, models, rows, templates, utils,
+ views])
 
 
 # -----------------------------------------------------------------------------