def render_comment(self, row: Row):
"""Render description column."""
comment = row.get('comment', '') or ''
if comment:
yield raw(comment)
if row['prov_value'] is None:
return
see_also_links = list(
map(
operator.itemgetter('link'),
self.query(
'''
SELECT ?link WHERE {
$node rdfs:seeAlso ?link .
OPTIONAL {
$node octa:position ?position .
}
}
ORDER BY ?position
''',
node=row['prov_value'],
),
), )
if see_also_links:
yield ul(
li(render(
node=link,
octiron=self.octiron,
), ) for link in see_also_links)
def render(self):
"""Print unique values for a column."""
rows: List[Row] = self.query(
query_text=self.legend_query,
column=self.iri,
)
table_rows = [
tr(
td(
raw(
render(
node=row['prov_value'],
octiron=self.octiron,
environments=[
TABLE.td,
IOLANTA.html,
],
) if row['prov_value'] is not None else '', ), ),
td(*self.render_comment(row)),
td(row['count']),
) for row in rows
]
return table(
thead(
tr(
# These are hard coded, and I cannot change that. See the
# docstring for details.
th('Value'),
th('Description'),
th('Count'),
), ),
tbody(*table_rows),
)
def render(self):
"""Render the column."""
return render(
node=self.iri,
octiron=self.octiron,
environments=[TABLE.th],
)
def render(self):
"""Call rendering for the underlying class of the table."""
if self.environment is None:
raise ValueError(
f'Facet {self} was called with no environment specified.', )
rows = self.query(
query_text='''
SELECT * WHERE {
$table table:class ?cls .
}
''',
table=self.environment,
)
try:
instance_class = first(rows)['cls']
except ValueError as err:
raise MissingTableInstanceClass(
table_iri=self.environment, ) from err
return render(
node=instance_class,
octiron=self.octiron,
environments=[TABLE.th],
)
def link(reference: Union[str, rdflib.URIRef], octiron: Octiron) -> str:
"""Render link to the object."""
if isinstance(reference, str):
if ':' in reference:
reference = rdflib.URIRef(reference)
else:
reference = LOCAL.term(reference)
return render(
node=reference,
octiron=octiron,
environments=[OCTA.link],
)
def construct_headers(
octiron: Octiron,
table_iri: URIRef,
columns: List[URIRef],
) -> Iterable[th]:
"""Construct table headers."""
return (
th(
render(
node=column,
octiron=octiron,
environments=[table_iri, TABLE.thead, HTML],
),
) for column in columns
)
def render_property_values(
property_values: List[Node],
octiron: Octiron,
) -> str:
rendered_values = [
render(
node=property_value,
octiron=octiron,
environments=[ADR.term('sidebar-property-value')],
) for property_value in property_values
]
if len(rendered_values) == 1:
return rendered_values[0]
return ul(*map(li, rendered_values))
class ProvEntity(Facet):
"""Render a node with prov:value defined."""
def render(self):
"""Render value and link to it."""
rows = self.query(
'''
SELECT * WHERE {
$node prov:value ?value .
OPTIONAL {
$node prov:wasDerivedFrom ?source .
}
OPTIONAL {
$node rdfs:comment ?comment .
}
}
''',
node=self.iri,
)
try:
row = first(rows)
except ValueError as err:
raise ValueError(
f'No `prov:value` was found for the node.') from err
kwargs = {}
if comment := row.get('comment'):
kwargs.update(title=comment)
rendered_value = render(
node=row['value'],
octiron=self.octiron,
)
if row.get('source'):
return a(
rendered_value,
href=row['source'],
target='_blank',
**kwargs,
)
return rendered_value
def render_properties_and_values(
properties_and_values: Dict[URIRef, List[Node]],
octiron: Octiron,
) -> Iterable[li]:
for property_iri, property_values in properties_and_values.items():
rendered_property = render(
node=property_iri,
octiron=octiron,
environments=[ADR.term('sidebar-property')],
)
rendered_values = render_property_values(
property_values=property_values,
octiron=octiron,
)
yield li(
rendered_property,
rendered_values,
cls='md-nav__item md-nav__link',
)
def render_row(
row: Row,
columns: List[URIRef],
octiron: Octiron,
) -> Iterable[td]:
"""Compile a sequence of table cells for a row."""
for column in columns:
try:
cell_value = row[column]
except KeyError:
yield td()
continue
cell_content = str(
render(
node=cell_value,
octiron=octiron,
environments=[column, TABLE.td, HTML],
),
)
yield td(raw(cell_content))
def default_property_facet(
octiron: Octiron,
property_iri: URIRef,
property_values: List[Node],
) -> Optional[str]:
"""Default facet to render a property with its values."""
label = first(
map(
operator.itemgetter('label'),
octiron.query(
'''
SELECT ?label WHERE {
?property rdfs:label ?label .
} ORDER BY ?label LIMIT 1
''',
property=property_iri,
),
),
None,
)
if label is None:
return
if len(property_values) > 1:
raise Exception('Too many values')
property_value = property_values[0]
if isinstance(property_value, Literal):
return f'<strong>{label}</strong>: {property_value}'
rendered_value = render(
octiron=octiron,
node=property_value,
)
return f'<strong>{label}</strong>: {rendered_value}'
