def from_field(cls, field):
if isinstance(field, models.NullBooleanField):
return cls(verbose_name=title(field.verbose_name), null=True)
if isinstance(field, models.BooleanField):
null = getattr(field, 'null', False)
return cls(verbose_name=title(field.verbose_name), null=null)
def verbose_name(self):
"""
Return the verbose name for this column, or fallback to the titlised
column name.
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]).
"""
# Favor an explicit defined verbose_name
if self.column.verbose_name is not None:
return self.column.verbose_name
# This is our reasonable fallback, should the next section not result
# in anything useful.
name = title(self.name.replace('_', ' '))
# Try to use a model field's verbose_name
if hasattr(self.table.data, 'queryset') and hasattr(self.table.data.queryset, 'model'):
model = self.table.data.queryset.model
field = Accessor(self.accessor).get_field(model)
if field:
if hasattr(field, 'field'):
name = field.field.verbose_name
else:
name = getattr(field, 'verbose_name', field.name)
return name
def header(self):
"""
The value used for the column heading (e.g. inside the ``<th>`` tag).
By default this titlises the `~.Column.verbose_name`. If
`~.Column.verbose_name` is an instance of `~.safestring.SafeData`, it's
used unmodified.
: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.
"""
if self.verbose_name:
if isinstance(self.verbose_name, SafeData):
# If the author has used mark_safe, we're going to assume the
# author wants the value used verbatim.
return self.verbose_name
return title(self.verbose_name)
def verbose_name(self):
"""
Return the verbose name for this column, or fallback to the titlised
column name.
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]).
"""
# Favor an explicit defined verbose_name
if self.column.verbose_name is not None:
return self.column.verbose_name
# This is our reasonable fallback, should the next section not result
# in anything useful.
name = title(self.name.replace('_', ' '))
# Try to use a model field's verbose_name
if hasattr(self.table.data, 'queryset') and hasattr(
self.table.data.queryset, 'model'):
model = self.table.data.queryset.model
field = Accessor(self.accessor).get_field(model)
if field:
if hasattr(field, 'field'):
name = field.field.verbose_name
else:
name = getattr(field, 'verbose_name', field.name)
return name
def verbose_name(self):
"""
Return the verbose name for this column, or fallback to the titlised
column name.
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]).
"""
# Favor an explicit defined verbose_name
if self.column.verbose_name is not None:
return self.column.verbose_name
name = None
# Try to use a model field's verbose_name
table_data = self.table.data
internal_data = table_data.data
type_, supported_data_type = table_data.internal_data_type, table_data.supported_data_type
if type_ is supported_data_type.QUERYSET and hasattr(internal_data, 'model'):
model = internal_data.model
field = Accessor(self.accessor).get_field(model)
if field:
if hasattr(field, 'field'):
name = field.field.verbose_name
else:
name = getattr(field, 'verbose_name', field.name)
# if above section didn't get a field verbose_name, fallback to
# titlecase
return name or title(self.name.replace('_', ' '))
def header(self):
"""
The value used for the column heading (e.g. inside the ``<th>`` tag).
By default this titlises the `~.Column.verbose_name`. If
`~.Column.verbose_name` is an instance of `~.safestring.SafeData`, it's
used unmodified.
: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.
"""
if self.verbose_name:
if isinstance(self.verbose_name, SafeData):
# If the author has used mark_safe, we're going to assume the
# author wants the value used verbatim.
return self.verbose_name
return title(self.verbose_name)
def header(self):
"""
The value that should be used in the header cell for this column.
"""
# favour Column.header
column_header = self.column.header
if column_header:
return column_header
# fall back to automatic best guess
verbose_name = self.verbose_name # avoid calculating multiple times
if isinstance(verbose_name, SafeData):
# If the verbose_name has come from a model field, it's possible
# that the author used mark_safe to include HTML in the value. If
# this is the case, we leave it verbatim.
return verbose_name
return title(verbose_name)
def header(self):
"""
The value that should be used in the header cell for this column.
"""
# favour Column.header
column_header = self.column.header
if column_header:
return column_header
# fall back to automatic best guess
verbose_name = self.verbose_name # avoid calculating multiple times
if isinstance(verbose_name, SafeData):
# If the verbose_name has come from a model field, it's possible
# that the author used mark_safe to include HTML in the value. If
# this is the case, we leave it verbatim.
return verbose_name
return title(verbose_name)
def verbose_name(self):
"""
Return the verbose name for this column, or fallback to the titlised
column name.
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]).
"""
# Favor an explicit defined verbose_name
if self.column.verbose_name is not None:
return self.column.verbose_name
# This is our reasonable fallback, should the next section not result
# in anything useful.
name = title(self.name.replace('_', ' '))
# Try to use a model field's verbose_name
if hasattr(self.table.data, 'queryset') and hasattr(
self.table.data.queryset, 'model'):
model = self.table.data.queryset.model
parts = self.accessor.split('.')
field = None
for part in parts:
try:
if django_version < (1, 8, 0):
field, _, _, _ = model._meta.get_field_by_name(part)
else:
field = model._meta.get_field(part)
except FieldDoesNotExist:
break
if hasattr(field, 'rel') and hasattr(field.rel, 'to'):
model = field.rel.to
continue
break
if field:
if hasattr(field, 'field'):
name = field.field.verbose_name
else:
name = getattr(field, 'verbose_name', field.name)
return name
def verbose_name(self):
'''
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]).
'''
# Favor an explicit defined verbose_name
if self.column.verbose_name is not None:
return self.column.verbose_name
# This is our reasonable fallback, should the next section not result
# in anything useful.
name = self.name.replace('_', ' ')
# Try to use a model field's verbose_name
if hasattr(self.table.data, 'queryset') and hasattr(
self.table.data.queryset, 'model'):
model = self.table.data.queryset.model
field = Accessor(self.accessor).get_field(model)
if field:
if hasattr(field, 'field'):
name = field.field.verbose_name
else:
name = getattr(field, 'verbose_name', field.name)
# If verbose_name was mark_safe()'d, return intact to keep safety
if isinstance(name, SafeData):
return name
return title(name)
def verbose_name(self):
"""
Return the verbose name for this column, or fallback to the titlised
column name.
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]).
"""
# Favor an explicit defined verbose_name
if self.column.verbose_name is not None:
return self.column.verbose_name
# This is our reasonable fallback, should the next section not result
# in anything useful.
name = title(self.name.replace('_', ' '))
# Try to use a model field's verbose_name
if hasattr(self.table.data, 'queryset') and hasattr(self.table.data.queryset, 'model'):
model = self.table.data.queryset.model
parts = self.accessor.split('.')
field = None
for part in parts:
try:
if django_version < (1, 8, 0):
field, _, _, _ = model._meta.get_field_by_name(part)
else:
field = model._meta.get_field(part)
except FieldDoesNotExist:
break
if hasattr(field, 'rel') and hasattr(field.rel, 'to'):
model = field.rel.to
continue
break
if field:
if hasattr(field, 'field'):
name = field.field.verbose_name
else:
name = getattr(field, 'verbose_name', field.name)
return name
def verbose_name(self):
'''
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]).
'''
# Favor an explicit defined verbose_name
if self.column.verbose_name is not None:
return self.column.verbose_name
# This is our reasonable fallback, should the next section not result
# in anything useful.
name = self.name.replace('_', ' ')
# Try to use a model field's verbose_name
model = self.table.data.get_model()
if model:
field = Accessor(self.accessor).get_field(model)
if field:
if hasattr(field, 'field'):
name = field.field.verbose_name
else:
name = getattr(field, 'verbose_name', field.name)
# If verbose_name was mark_safe()'d, return intact to keep safety
if isinstance(name, SafeData):
return name
return title(name)
def from_field(cls, field):
'''
Return a specialised column for the model field or `None`.
:param field: the field that needs a suitable column
:type field: model field instance
: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.
'''
# Since this method is inherited by every subclass, only provide a
# column if this class was asked directly.
if cls is Column:
if hasattr(field, 'get_related_field'):
verbose_name = field.get_related_field().verbose_name
else:
verbose_name = getattr(field, 'verbose_name', field.name)
return cls(verbose_name=title(verbose_name))
def from_field(cls, field):
'''
Return a specialised column for the model field or `None`.
:param field: the field that needs a suitable column
:type field: model field instance
: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.
'''
# Since this method is inherited by every subclass, only provide a
# column if this class was asked directly.
if cls is Column:
if hasattr(field, 'get_related_field'):
verbose_name = field.get_related_field().verbose_name
else:
verbose_name = getattr(field, 'verbose_name', field.name)
return cls(verbose_name=title(verbose_name))
def from_field(cls, field):
if isinstance(field, models.BooleanField):
return cls(verbose_name=title(field.verbose_name), null=False)
if isinstance(field, models.NullBooleanField):
return cls(verbose_name=title(field.verbose_name), null=True)
def from_field(cls, field):
if isinstance(field, models.TimeField):
return cls(verbose_name=title(field.verbose_name))
def from_field(cls, field):
if POSTGRES_AVAILABLE:
if isinstance(field, JSONField) or isinstance(field, HStoreField):
return cls(verbose_name=title(field.verbose_name))
def from_field(cls, field):
if isinstance(field, models.URLField):
return cls(verbose_name=title(field.verbose_name))
def header(self):
if self.verbose_name:
if isinstance(self.verbose_name, SafeData):
return self.verbose_name
return title(self.verbose_name)
