linkml_renderer.renderers package

Submodules

linkml_renderer.renderers.html_renderer module

Rendering of LinkML instances as HTML.

class linkml_renderer.renderers.html_renderer.HTMLRenderer(style_engine=None)

Bases: Renderer

A renderer that generates HTML.

To generate HTML for a YAMLRoot object, use the render() method:

>>> from linkml_renderer.renderers.html_renderer import HTMLRenderer
>>> from linkml_runtime import SchemaView
>>> import yaml
>>> sv = SchemaView('my-schema.yaml')
>>> renderer = HTMLRenderer()
>>> with open('my-instance.yaml') as f:
>>>     instance = yaml.load(f)
>>>     print(renderer.render(instance, sv))

This method can be configured using a Configuration object

>>> from linkml_renderer.style.style_engine import StyleEngine
>>> se = StyleEngine(sv, configuration = my_config)
>>> renderer.style_engine = se
anchor_id(context, index)
Return type

str

elements_to_description_lists(indexed_elements, context)

Generate description lists for a list of objects.

Parameters
Return type

None

Returns

elements_to_table(indexed_elements, context)

Generate HTML table for a list of objects.

Parameters
Return type

None

Returns

elements_to_tuples(indexed_elements, context)

Generate simple tuples for a list of objects.

When writing tuples, the attributes/keys are omitted, as the position of the value is intended to be sufficient to identify it.

Parameters
Return type

None

Returns

elements_to_unordered_list(indexed_elements, context)

Generate HTML for a list of objects.

Parameters

  • indexed_elements (List[Tuple[Any, Any]]) –

  • context (HTMLContext) –

Return type

None

Returns

generate(element, context)

Generate HTML for a YAMLRoot object.

May be top level, in which case head/body tags are generated.

Parameters

  • element (Union[YAMLRoot, BaseModel]) –

  • context (HTMLContext) –

Return type

None

Returns

generate_atom(element, context)

Generate HTML for an atom.

Parameters

  • element (Union[str, int, float, bool]) –

  • context (HTMLContext) –

Return type

None

Returns

generate_document(element, context)

Generate HTML top level document for a YAMLRoot object.

Parameters

  • element (Union[YAMLRoot, BaseModel]) –

  • context (HTMLContext) –

Return type

None

Returns

generate_object(element, context)

Generate HTML for an inner YAMLRoot object.

Not top level, so no head/body tags are generated.

Parameters

  • element (Union[YAMLRoot, dict]) –

  • context (HTMLContext) –

Return type

None

Returns

generate_reference(element, context)

Generate HTML for a reference.

Parameters
Return type

None

Returns

generate_tuple(element, context)
Return type

None

render(element, schemaview, source_element_name=None, **kwargs)

Dump a YAMLRoot object to HTML.

The input may be a YAMLRoot object, a pydantic BaseModel, or a dict. It must conform to the LinkML schema provided via the schemaview argument.

Passing in a source_element_name is optional if this can be inferred from the schema.

Parameters

  • element (Union[YAMLRoot, BaseModel, Dict[str, Any]]) – instance to render

  • schemaview (SchemaView) – describes the structure of the instance to render

  • source_element_name (Optional[str]) – name of the element type the instance instantiates.

  • kwargs –

Return type

str

Returns

HTML string

linkml_renderer.renderers.markdown_renderer module

class linkml_renderer.renderers.markdown_renderer.MarkdownContext(schemaview=None, source_path=None, target_path=<factory>, markdown_writer=<factory>)

Bases: Context

markdown_writer: MarkdownWriter
class linkml_renderer.renderers.markdown_renderer.MarkdownRenderer(style_engine=None)

Bases: Renderer

A renderer that generates Markdown.

To generate Markdown for a LinkML object, use the render() method:

>>> from linkml_renderer.renderers.html_renderer import HTMLRenderer
>>> from linkml_runtime import SchemaView
>>> import yaml
>>> sv = SchemaView('my-schema.yaml')
>>> renderer = MarkdownRenderer()
>>> with open('my-instance.yaml') as f:
>>>     instance = yaml.load(f)
>>>     print(renderer.render(instance, sv))
elements_to_description_lists(indexed_elements, context)
Return type

None

elements_to_table(indexed_elements, context)

Generate markdown table for a list of objects.

Parameters
Return type

None

Returns

elements_to_tuples(indexed_elements, context)

Generate simple tuples for a list of objects.

When writing tuples, the attributes/keys are omitted, as the position of the value is intended to be sufficient to identify it.

Parameters
Return type

None

Returns

elements_to_unordered_list(indexed_elements, context)

Generate Markdown for a list of objects.

Parameters

  • indexed_elements (List[Tuple[Any, Any]]) –

  • context (MarkdownContext) –

Return type

None

Returns

generate(element, context)

Generate markdown for a YAMLRoot object.

May be top level, in which case head/body tags are generated.

Parameters
Return type

None

Returns

generate_atom(element, context)

Generate HTML for an atom.

Parameters
Return type

None

Returns

generate_document(element, context)

Generate markdown top level document for a YAMLRoot object.

Parameters
Return type

None

Returns

generate_object(element, context)

Generate markdown for an inner YAMLRoot object.

Not top level, so no head/body tags are generated.

Parameters
Return type

None

Returns

generate_reference(element, context)

Generate Markdown for a reference.

Parameters
Return type

None

Returns

generate_tuple(element, context)
Return type

None

render(element, schemaview, source_element_name=None, **kwargs)

Dump a YAMLRoot object to markdown.

To generate HTML for a YAMLRoot object, use the render() method:

>>> from linkml_renderer.renderers.html_renderer import MarkdownRenderer
>>> from linkml_runtime import SchemaView
>>> import yaml
>>> sv = SchemaView('my-schema.yaml')
>>> renderer = MarkdownRenderer()
>>> with open('my-instance.yaml') as f:
>>>     instance = yaml.load(f)
>>>     print(renderer.render(instance, sv))
Parameters

  • element (Union[YAMLRoot, BaseModel]) – LinkML instance to render

  • schemaview (SchemaView) – SchemaView which the element conforms to

  • source_element_name (Optional[str]) – Root element name, inferred from tree_root if not present

  • kwargs – additional args

Return type

str

Returns

Markdown string

class linkml_renderer.renderers.markdown_renderer.MarkdownWriter(s=<factory>)

Bases: object

block(text)
h(level, text)
h1(text)
h2(text)
h3(text)
line(text)
s: StringIO
table_header(cols)
table_row(vals)
w(text)

linkml_renderer.renderers.mermaid_renderer module

class linkml_renderer.renderers.mermaid_renderer.MermaidContext(schemaview=None, source_path=None, target_path=<factory>, mermaid_writer=<factory>)

Bases: Context

mermaid_writer: MermaidWriter
class linkml_renderer.renderers.mermaid_renderer.MermaidRenderer(style_engine=None, element_to_id=<factory>, last_id=<factory>)

Bases: Renderer

A renderer that generates mermaid.

element_to_id: Dict[str, str]
generate(element, context)

Generate mermaid for a YAMLRoot object.

May be top level, in which case head/body tags are generated.

Parameters

  • element (Union[YAMLRoot, BaseModel]) –

  • context (MermaidContext) –

Return type

None

Returns

generate_document(element, context)

Generate mermaid top level document for a YAMLRoot object.

Parameters

  • element (Union[YAMLRoot, BaseModel]) –

  • context (MermaidContext) –

Return type

None

Returns

generate_node(element, context)

Generate mermaid for an inner YAMLRoot object.

Not top level, so no head/body tags are generated.

Parameters
Return type

Optional[str]

Returns

last_id: int
render(element, schemaview, source_element_name=None, **kwargs)

Dump a YAMLRoot object to mermaid.

To generate HTML for a YAMLRoot object, use the render() method:

>>> from linkml_renderer.renderers.html_renderer import MarkdownRenderer
>>> from linkml_runtime import SchemaView
>>> import yaml
>>> sv = SchemaView('my-schema.yaml')
>>> renderer = MermaidRenderer()
>>> with open('my-instance.yaml') as f:
>>>     instance = yaml.load(f)
>>>     print(renderer.render(instance, sv))
Parameters

  • element (Union[YAMLRoot, BaseModel, Dict[str, Any]]) – LinkML instance to render

  • schemaview (SchemaView) – SchemaView which the element conforms to

  • source_element_name (Optional[str]) – Root element name, inferred from tree_root if not present

  • kwargs – additional args

Return type

str

Returns

mermaid serialization of the element as a string

class linkml_renderer.renderers.mermaid_renderer.MermaidWriter(s=<factory>)

Bases: object

edge(id, rel, obj, style=None)
entity(id, text=None, shape=None, right_side_shape=None)
header(text)
line(text)
s: StringIO

linkml_renderer.renderers.renderer module

Base class for renderers that render LinkML instances to a format such as HTML, Markdown, etc.

class linkml_renderer.renderers.renderer.AttributeBlock(name, attributes, title=None)

Bases: object

A block of attributes

attributes: List[SlotDefinition]

Ordering of attributes within a block.

name: str

Name of the block. This may be the name of the slot group.

title: Optional[str] = None

Display title for the block.

class linkml_renderer.renderers.renderer.Renderer(style_engine=None)

Bases: ABC

Base class for engines that render LinkML instances to a format such as HTML, Markdown, etc.

attribute_blocks(context)
Return type

List[AttributeBlock]

ordered_slots(context)
Return type

List[SlotDefinition]

abstract render(element, schemaview, source_element_name=None, **kwargs)

Render an element and all its children.

Parameters

  • element (Union[YAMLRoot, BaseModel, Dict[str, Any]]) – LinkML instance to render

  • schemaview (SchemaView) – SchemaView which the element conforms to

  • source_element_name (Optional[str]) – Root element name, inferred from tree_root if not present

  • kwargs – additional args

Return type

str

Returns

rendering as a string

slots(context)
Return type

List[SlotDefinition]

style_engine: Optional[StyleEngine] = None

Configuration for mappings between schema elements and render engine elements.

Module contents