^Q\d@s ddlmZmZddlmZddlmZddlmZddl m Z ddl m Z ddl mZmZmZmZmZmZGdd d eZeZejGd d d eZejGd d d eZGdddeZdS))absolute_importunicode_literals) OrderedDict)islice)six)SafeData)title)Accessor AttributeDictOrderBy OrderByTuplecall_with_appropriatecomputed_valuesc@s:eZdZdZddZddZddZdS) Libraryz" A collection of columns. cCs g|_dS)N)columns)selfrP/var/www/dbchiro/venv/lib/python3.4/site-packages/django_tables2/columns/base.py__init__szLibrary.__init__cCs|jj||S)N)rappend)rcolumnrrrregisterszLibrary.registercCso|dkr|jdSxNt|jD]=}t|dsEq*n|j|}|dkrfq*n|SWdS)z{ Return a column object suitable for model field. Returns: `.Column` object or `None` Nr from_field)rreversedhasattrr)rfield candidaterrrrcolumn_for_fields  zLibrary.column_for_fieldN)__name__ __module__ __qualname____doc__rrrrrrrrs   rc @seZdZdZdZdZdZddddddddddddd Zed d Z ed d Z d dZ ddZ ddZ ddZeddZdS)Columna Represents a single column of a table. `.Column` objects control the way a column (including the cells that fall within it) are rendered. Arguments: attrs (dict): HTML attributes for elements that make up the column. This API is extended by subclasses to allow arbitrary HTML attributes to be added to the output. By default `.Column` supports: - *th* -- ``table/thead/tr/th`` elements - *td* -- ``table/tbody/tr/td`` elements - *cell* -- fallback if *th* or *td* isn't defined accessor (str or `~.Accessor`): An accessor that describes how to extract values for this column from the :term:`table data`. default (str or callable): The default value for the column. This can be a value or a callable object [1]_. If an object in the data provides `None` for a column, the default will be used instead. The default value may affect ordering, depending on the type of data the table is using. The only case where ordering is not affected is when a `.QuerySet` is used as the table data (since sorting is performed by the database). empty_values (iterable): list of values considered as a missing value, for which the column will render the default value. Defaults to `(None, '')` exclude_from_export (bool): If `True`, this column will not be added to the data iterator returned from as_values(). footer (str, callable): Defines the footer of this column. If a callable is passed, it can take optional keyword argumetns `column`, `bound_column` and `table`. order_by (str, tuple or `.Accessor`): Allows one or more accessors to be used for ordering rather than *accessor*. orderable (bool): If `False`, this column will not be allowed to influence row ordering/sorting. verbose_name (str): A human readable version of the column name. visible (bool): If `True`, this column will be rendered. localize: If the cells in this column will be localized by the `localize` filter: - If `True`, force localization - If `False`, values are not localized - If `None` (default), localization depends on the ``USE_L10N`` setting. .. [1] The provided callable object must not expect to receive any arguments. rNFTc Cs[|dkp't|tjp't|sFtdt|jnt|rm|dk rmtdn|rt|nd|_||_ ||_ ||_ ||_ |pt |di|_t|tjr|fn|}|dk rt|nd|_|dk r!||_n| |_tj|_tjd7_| |_| |_dS)Nz-accessor must be a string or callable, not %sz:accessor must be string when default is used, not callableattrs) isinstancer string_typescallable TypeErrortyperr accessor_default verbose_namevisible orderablegetattrr$r order_by empty_valueslocalizer"creation_counter_footerexclude_from_export) rr-r+defaultr.r/r$r1r2r3footerr6rrrrrs*     !!     zColumn.__init__cCs t|jr|jS|jS)N)r(r,)rrrrr7szColumn.defaultcCs|jS)ae The value used for the column heading (e.g. inside the ```` tag). By default this returns `~.Column.verbose_name`. :returns: `unicode` or `None` .. note:: This property typically isn't accessed directly when a table is rendered. Instead, `.BoundColumn.header` is accessed which in turn accesses this property. This allows the header to fallback to the column name (it's only available on a `.BoundColumn` object hence accessing that first) when this property doesn't return something useful. )r-)rrrrheadersz Column.headercCsvi|d6|d6|d6}|jdk rSt|jrIt|j|S|jSnt|drrt|j|SdS)zB Returns the content of the footer, if specified. r bound_columntableN render_footerr#)r5r(r rr<)rr:r;Z footer_kwargsrrrr8s  z Column.footercCs|S)a Returns the content for a specific cell. This method can be overridden by :ref:`table.render_FOO` methods on the table or by subclassing `.Column`. If the value for this cell is in `.empty_values`, this method is skipped and an appropriate default value is rendered instead. Subclasses should set `.empty_values` to ``()`` if they want to handle all values in `.render`. r)rvaluerrrrenders z Column.rendercKst|j|}|S)a Returns the content for a specific cell similarly to `.render` however without any html content. This can be used to get the data in the formatted as it is presented but in a form that could be added to a csv file. The default implementation just calls the `render` function but any subclasses where `render` returns html content should override this method. See `LinkColumn` for an example. )r r>)rkwargsr=rrrr=s z Column.valuecCs |dfS)a- Returns the queryset of the table. This method can be overridden by :ref:`table.order_FOO` methods on the table or by subclassing `.Column`; but only overrides if second element in return tuple is True. returns: Tuple (queryset, boolean) Fr)rZqueryset is_descendingrrrorders z Column.ordercCsY|tkrUt|dr-|jj}nt|d|j}|dt|SdS)a  Return a specialised column for the model field or `None`. Arguments: field (Model Field instance): the field that needs a suitable column Returns: `.Column` object or `None` If the column isn't specialised for the given model field, it should return `None`. This gives other columns the opportunity to do better. If the column is specialised, it should return an instance of itself that's configured appropriately for the field. get_related_fieldr-N)r"rrBr-r0namer)clsrr-rrrrs  zColumn.from_field)Nr#)rrr r!r4r2Z _explicitrpropertyr7r9r8r>r=rA classmethodrrrrrr"6s 3       r"c@s6eZdZdZddZddZeddZedd Zd d Z d d Z ddZ eddZ eddZ eddZddZeddZeddZeddZeddZed d!Zed"d#Zed$d%Zd&S)' BoundColumna A *run-time* version of `.Column`. The difference between `.BoundColumn` and `.Column`, is that `.BoundColumn` objects include the relationship between a `.Column` and a `.Table`. In practice, this means that a `.BoundColumn` knows the *"variable name"* given to the `.Column` when it was declared on the `.Table`. arguments: table (`~.Table`): The table in which this column exists column (`~.Column`): The type of column name (str): The variable name of the column used when defining the `.Table`. In this example the name is ``age``:: class SimpleTable(tables.Table): age = tables.Column() cCs(||_||_||_d|_dS)N)_tablerrC current_value)rr;rrCrrrrs   zBoundColumn.__init__cCstj|jS)N)rZ text_typer9)rrrr__str__ szBoundColumn.__str__cCs|jjpt|jS)zh Returns the string used to access data for this column out of the data source. )rr+r rC)rrrrr+#szBoundColumn.accessorcCsi|jd6|d6}t|ddr_t|ddr_|ji|jd6|jd6nt|jj}|jt|jj|jdi}t |jd |d ||d bs z.BoundColumn._get_cell_class.. )rSsetsplitrHZget_column_class_names)rr$classesrrr_get_cell_class\s1zBoundColumn._get_cell_classcCsdjt|j|S)zQ Returns the HTML class attribute for a data cell in this column rY)joinsortedr])rZtd_attrsrrrrUfszBoundColumn.get_td_classcCs|j|}|jdi}|jrF|j|jddn|jr|j|jjrs|jddn|jddndjt|S)zS Returns the HTML class attribute for a header cell in this column Z _orderingr/Z descendingdescZ ascendingZascrY) r]rSr/add is_orderedorder_by_aliasr@r^r_)rZth_attrsr\Zordering_classrrrrTls  zBoundColumn.get_th_classcCs+|jj}|dkr'|jj}n|S)z< Returns the default value for this column. N)rr7rH)rr=rrrr7}s  zBoundColumn.defaultcCs|jj}|r|S|jS)zS The value that should be used in the header cell for this column. )rr9r-)rZ column_headerrrrr9s zBoundColumn.headercCs$t|jji|d6|jd6S)Nr:r;)r rr8rH)rrrrr8szBoundColumn.footercCs"|jjdk p!t|jdS)Nr<)rr5r)rrrr has_footerszBoundColumn.has_footercCsJ|jjdk r!|jj}nt|jf}|jjrF|jS|S)z Returns an `.OrderByTuple` of appropriately prefixed data source keys used to sort this column. See `.order_by_alias` for details. N)rr1r r+rcr@opposite)rr1rrrr1szBoundColumn.order_bycCsIt|jjpij|j|j}|jr<|jn||_|S)a Returns an `OrderBy` describing the current state of ordering for this column. The following attempts to explain the difference between `order_by` and `.order_by_alias`. `.order_by_alias` returns and `.OrderBy` instance that's based on the *name* of the column, rather than the keys used to order the table data. Understanding the difference is essential. Having an alias *and* a keys version is necessary because an N-tuple (of data source keys) can be used by the column to order the data, and it's ambiguous when mapping from N-tuple to column (since multiple columns could use the same N-tuple). The solution is to use order by *aliases* (which are really just prefixed column names) that describe the ordering *state* of the column, rather than the specific keys in the data source should be ordered. e.g.:: >>> class SimpleTable(tables.Table): ... name = tables.Column(order_by=('firstname', 'last_name')) ... >>> table = SimpleTable([], order_by=('-name', )) >>> table.columns['name'].order_by_alias '-name' >>> table.columns['name'].order_by ('-first_name', '-last_name') The `OrderBy` returned has been patched to include an extra attribute ``next``, which returns a version of the alias that would be transitioned to if the user toggles sorting on this column, e.g.:: not sorted -> ascending ascending -> descending descending -> ascending This is useful otherwise in templates you'd need something like:: {% if column.is_ordered %} {% querystring table.prefixed_order_by_field=column.order_by_alias.opposite %} {% else %} {% querystring table.prefixed_order_by_field=column.order_by_alias %} {% endif %} )r rHr1rSrCrbrenext)rr1rrrrcs3*zBoundColumn.order_by_aliascCs|j|jjpfkS)N)rCrHr1)rrrrrbszBoundColumn.is_orderedcCs&|jjdk r|jjS|jjS)zU Return a `bool` depending on whether this column supports ordering. N)rr/rH)rrrrr/s zBoundColumn.orderablecCs|jjdk r|jjS|jjdd}|jjj}|rt|jj |}|rt |dr|j j}qt |d|j}nt |tr|Snt|S)a Return the verbose name for this column. In order of preference, this will return: 1) The column's explicitly defined `verbose_name` 2) The titlised model's `verbose_name` (if applicable) 3) Fallback to the titlised column name. Any `verbose_name` that was not passed explicitly in the column definition is returned titlised in keeping with the Django convention of `verbose_name` being defined in lowercase and uppercased/titlised as needed by the application. If the table is using queryset data, then use the corresponding model field's `~.db.Field.verbose_name`. If it's traversing a relationship, then get the last field in the accessor (i.e. stop when the relationship turns from ORM relationships to object attributes [e.g. person.upper should stop at person]). N_rYrr-)rr-rCreplacerHdataZ get_modelr r+ get_fieldrrr0r&rr)rrCZmodelrrrrr-s zBoundColumn.verbose_namecCs |jjS)zO Returns a `bool` depending on whether this column is visible. )rr.)rrrrr.szBoundColumn.visiblecCs |jjS)zW Returns `True`, `False` or `None` as described in ``Column.localize`` )rr3)rrrrr3$szBoundColumn.localizeN)rrr r!rrJrEr+r$r]rUrTr7r9r8rdr1rcrbr/r-r.r3rrrrrGs&   1     7 -rGc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$S)% BoundColumnsa Container for spawning `.BoundColumn` objects. This is bound to a table and provides its `.Table.columns` property. It provides access to those columns in different ways (iterator, item-based, filtered and unfiltered etc), stuff that would not be possible with a simple iterator in the table class. A `BoundColumns` object is a container for holding `BoundColumn` objects. It provides methods that make accessing columns easier than if they were stored in a `list` or `dict`. `Columns` has a similar API to a `dict` (it actually uses a `~collections.OrderedDict` interally). At the moment you'll only come across this class when you access a `.Table.columns` property. Arguments: table (`.Table`): the table containing the columns cCs||_t|_xtj|D]\}}t||||j|<}t|d||j|_t|d|t|d||j|_t|d||j |_ q%WdS)NZrender_Zvalue_Zorder_) rHrrr iteritemsrGr0r>r=rA)rr;Z base_columnsrCrZbcrrrr@s  ,zBoundColumns.__init__cCsdd|jDS)Ncss|]\}}|VqdS)Nr)rVrCrrrr Ksz)BoundColumns.iternames..)rl)rrrr iternamesJszBoundColumns.iternamescCst|jS)N)listrn)rrrrnamesMszBoundColumns.namescCsdd|jDS)z} Return an iterator that exposes all `.BoundColumn` objects, regardless of visiblity or sortability. css|]\}}|VqdS)Nr)rVrCrrrrrmUsz'BoundColumns.iterall..)rl)rrrriterallPszBoundColumns.iterallcCst|jS)N)rorq)rrrrallWszBoundColumns.allccsBx;|jjD]-}||jjkr ||j|fVq q WdS)aU Return an iterator of ``(name, column)`` pairs (where ``column`` is a `BoundColumn`). This method is the mechanism for retrieving columns that takes into consideration all of the ordering and filtering modifiers that a table supports (e.g. `~Table.Meta.exclude` and `~Table.Meta.sequence`). N)rHsequenceexcluder)rrCrrrrlZs zBoundColumns.iteritemscCst|jS)N)rorl)rrrritemshszBoundColumns.itemscCsdd|jDS)a_ Same as `BoundColumns.all` but only returns orderable columns. This is useful in templates, where iterating over the full set and checking ``{% if column.ordarable %}`` can be problematic in conjunction with e.g. ``{{ forloop.last }}`` (the last column might not be the actual last that is rendered). css|]}|jr|VqdS)N)r/)rVxrrrrmtsz-BoundColumns.iterorderable..)rq)rrrr iterorderableks zBoundColumns.iterorderablecCst|jS)N)rorw)rrrrr/vszBoundColumns.orderablecCsdd|jDS)z Same as `.iterorderable` but only returns visible `.BoundColumn` objects. This is geared towards table rendering. css|]}|jr|VqdS)N)r.)rVrvrrrrmsz+BoundColumns.itervisible..)rq)rrrr itervisibleyszBoundColumns.itervisiblecCst|jS)N)rorx)rrrrr.szBoundColumns.visiblecCsd|j|j_dS)z^ Hide a column. Arguments: name(str): name of the column FN)rrr.)rrCrrrhideszBoundColumns.hidecCsd|j|j_dS)zo Show a column otherwise hidden. Arguments: name(str): name of the column TN)rrr.)rrCrrrshowszBoundColumns.showcCs |jS)z; Convenience API, alias of `.itervisible`. )rx)rrrr__iter__szBoundColumns.__iter__cCs6t|tjr"||jkS||jkSdS)z Check if a column is contained within a `BoundColumns` object. *item* can either be a `~.BoundColumn` object, or the name of a column. N)r&rr'rnrq)ritemrrr __contains__szBoundColumns.__contains__cCst|jS)z^ Return how many `~.BoundColumn` objects are contained (and visible). )lenr.)rrrr__len__szBoundColumns.__len__c Cst|trQy$tt|j||dSWqtk rMtYqXntt|tjrx'|jD]}|j |krp|SqpWt d||j fnt dt |jdS)a! Retrieve a specific `~.BoundColumn` object. *index* can either be 0-indexed or the name of a column .. code-block:: python columns['speed'] # returns a bound column with name 'speed' columns[0] # returns the first column r%z5Column with name '%s' does not exist; choices are: %sz.Column indices must be integers or str, not %sN)r&intrfrrq StopIteration IndexErrorrr'rCKeyErrorrpr)r*r)rindexrrrr __getitem__s $ zBoundColumns.__getitem__N)rrr r!rrnrprqrrrlrurwr/rxr.ryrzr{r}rrrrrrrk,s$           rkN) __future__rr collectionsr itertoolsrZ django.utilsrZdjango.utils.safestringrZ*django_tables2.templatetags.django_tables2rZdjango_tables2.utilsr r r r r robjectrZlibraryrr"Zpython_2_unicode_compatiblerGrkrrrrs.%   &