o
˷ew, @ s d dl mZ d dlmZ ddlmZ ddlmZ ddlm Z m
Z
m Z m Z G dd dZ
G d d
d
ZG d d d eZG d
d dZdS ) )FieldDoesNotExist)models )BaseLinkColumn)ManyToManyColumn)A
AttributeDictcall_with_appropriatecomputed_valuesc @ s( e Zd ZdZdd Zdd Zdd ZdS ) CellAccessorzI
Allows accessing cell contents on a row object (see `BoundRow`)
c C s
|| _ d S N)row)selfr
r J/var/www/ideatree/venv/lib/python3.10/site-packages/django_tables2/rows.py__init__ s
zCellAccessor.__init__c C | j |S r r
get_cellr keyr r r __getitem__ zCellAccessor.__getitem__c C r r r r namer r r __getattr__ r zCellAccessor.__getattr__N)__name__
__module__ __qualname____doc__r r r r r r r r s
r c @ s e Zd ZdZdd Zedd Zdd Zedd Zed
d Z d d
Z
dd Z dd Z dd Z
d ddZdd Zd ddZdd Zd d ZdS ) BoundRoway
Represents a *specific* row in a table.
`.BoundRow` objects are a container that make it easy to access the
final 'rendered' values for cells in a row. You can simply iterate over a
`.BoundRow` object and it will take care to return values rendered
using the correct method (e.g. :ref:`table.render_FOO`)
To access the rendered value of each cell in a row, just iterate over it::
>>> import django_tables2 as tables
>>> class SimpleTable(tables.Table):
... a = tables.Column()
... b = tables.CheckBoxColumn(attrs={'name': 'my_chkbox'})
...
>>> table = SimpleTable([{'a': 1, 'b': 2}])
>>> row = table.rows[0] # we only have one row, so let's use it
>>> for cell in row:
... print(cell)
...
1
Alternatively you can use row.cells[0] to retrieve a specific cell::
>>> row.cells[0]
1
>>> row.cells[1]
''
>>> row.cells[2]
...
IndexError: list index out of range
Finally you can also use the column names to retrieve a specific cell::
>>> row.cells.a
1
>>> row.cells.b
''
>>> row.cells.c
...
KeyError: "Column with name 'c' does not exist; choices are: ['a', 'b']"
If you have the column name in a variable, you can also treat the `cells`
property like a `dict`::
>>> key = 'a'
>>> row.cells[key]
1
Arguments:
table: The `.Table` in which this row exists.
record: a single record from the :term:`table data` that is used to
populate the row. A record could be a `~django.db.Model` object, a
`dict`, or something else.
c C s& || _ || _t|j| _t| | _d S r )_record_tablenext_counter row_counterr cells)r recordtabler r r r S s zBoundRow.__init__c C | j S )z!The `.Table` this row is part of.)r" r r r r r( \ zBoundRow.tablec C s | j d rdS dS )z
Return css class, alternating for odd and even records.
Return:
string: `even` for even records, `odd` otherwise.
oddeven)r% r* r r r get_even_odd_css_classa s z BoundRow.get_even_odd_css_classc C s` | }t| jjt| j| jdd}d|v r(|d r(|d d| 7 < t|S ||d< t|S )z(Return the attributes for a certain row.)r( r' kwargsclass )r/ r
r" row_attrsdictr! r )r cssClassr4 r r r attrsj s zBoundRow.attrsc C r) )zRThe data record from the data source which is used to populate this row with data.)r! r* r r r r' z r+ zBoundRow.recordc c s | D ]\}}|V qdS )z
Iterate over the rendered values for cells in the row.
Under the hood this method just makes a call to
`.BoundRow.__getitem__` for each cell.
N)items)r columnvaluer r r __iter__ s zBoundRow.__iter__c C s d }t |j}|j}|| j\}}t|tjr?z || j} t |d| d }
t | ddr4|
r4|
}d }W n t
y> Y nw |rcz| | j}W n t yb t|t
r`|jd ur`|| Y S Y nw t|t} ||jv ss| ru| su|S |||S )Nzget_%s_displaychoicesr )r accessorr9 penultimater'
isinstancer Model get_fieldgetattrr resolve Exceptionr textr empty_valuesexists) r bound_column render_funcdefaultr: r= r9 r> remainderfield
display_fnis_manytomanycolumnr r r _get_and_render_with s6
z BoundRow._get_and_render_withc C s || j |j|| | jdS )z
Defines the arguments that will optionally be passed while calling the
cell's rendering or value getter if that function has one of these as a
keyword argument.
)r: r' r9 rH bound_rowr( )r' r9 r" r rH r: r r r _optional_cell_arguments s z!BoundRow._optional_cell_argumentsc C s | j j| }| j|| j|jdS )zl
Returns the final rendered html for a cell in the row, given the name
of a column.
rI rJ )r( columnsrO _call_renderrJ )r r rH r r r r s
zBoundRow.get_cellNc C s4 | ||}t|j|}|jr|j|fi |S |S )zI
Call the column's render method with appropriate kwargs
)rR r renderlink)r rH r:
render_kwargscontentr r r rU s zBoundRow._call_renderc C s | j | jj| | jddS )z
Returns the final rendered value (excluding any html) for a cell in the
row, given the name of a column.
NrS )rO r( rT _call_valuer r r r get_cell_value s zBoundRow.get_cell_valuec C s t |j| ||S )zH
Call the column's value method with appropriate kwargs
)r r: rR rQ r r r rZ s zBoundRow._call_valuec C s |t |tr | jjv S | v S )z;
Check by both row object and column name.
)r? strr( rT )r itemr r r __contains__ s zBoundRow.__contains__c c s6 | j jD ]}| |j|_| j|_||jfV qdS )z
Returns iterator yielding ``(bound_column, cell)`` pairs.
*cell* is ``row[name]`` -- the rendered unicode value that should be
``rendered within ``
``.
N)r( rT r r
current_valuer' current_record)r r9 r r r r8 s zBoundRow.itemsr )r r r r r propertyr( r/ r7 r' r; rO rR r rU r[ rZ r^ r8 r r r r r s& :
$
r c @ s e Zd ZdZedd ZdS )BoundPinnedRowz/
Represents a *pinned* row in a table.
c C sB t | jjd| jid}d| d|ddg}||d< t|S )z
Return the attributes for a certain pinned row.
Add CSS classes `pinned-row` and `odd` or `even` to `class` attribute.
Return:
AttributeDict: Attributes for pinned rows.
r' r0 r3 z
pinned-rowr2 )r
r" pinned_row_attrsr! joinr/ getr )r r4 css_classr r r r7 s zBoundPinnedRow.attrsN)r r r r ra r7 r r r r rb s rb c @ s: e Zd ZdZd
ddZdd Zdd Zd d
Zd d ZdS ) BoundRowsa
Container for spawning `.BoundRow` objects.
Arguments:
data: iterable of records
table: the `~.Table` in which the rows exist
pinned_data: dictionary with iterable of records for top and/or
bottom pinned rows.
Example:
>>> pinned_data = {
... 'top': iterable, # or None value
... 'bottom': iterable, # or None value
... }
This is used for `~.Table.rows`.
Nc C s || _ || _|p i | _d S r datar( pinned_data)r rj r( rk r r r r " s zBoundRows.__init__c c sB |dur t |ddu rtd|D ] }t|| jdV qdS dS )a
Top and bottom pinned rows generator.
Arguments:
data: Iterable data for all records for top or bottom pinned rows.
Yields:
BoundPinnedRow: Top or bottom `BoundPinnedRow` object for single pinned record.
Nr; Fz)The data for pinned rows must be iterabler( )hasattr
ValueErrorrb r( )r rj
pinned_recordr r r generator_pinned_row' s
z BoundRows.generator_pinned_rowc c s^ | | jdD ]}|V q
| jD ]
}t|| jdV q| | jdD ]}|V q'd S )Ntoprl bottom)rp rk rf rj r r( )r ro r' r r r r; 8 s
zBoundRows.__iter__c C s\ t | j}| jd}| jd}||d u rdnt |7 }||d u r'd7 }|S t |7 }|S )Nrq rr r )lenrj rk rf )r length
pinned_top
pinned_bottomr r r __len__D s
zBoundRows.__len__c C s6 t |trt| j| | j| jdS t| j| | jdS )zx
Slicing returns a new `~.BoundRows` instance, indexing returns a single
`~.BoundRow` instance.
ri )r' r( )r? slicerh rj r( rk r r r r r r L s
zBoundRows.__getitem__r ) r r r r r rp r; rw r r r r r rh s
rh N)django.core.exceptionsr django.dbr columns.linkcolumnr columns.manytomanycolumnr utilsr r r r
r r rb rh r r r r s b