linkml.generators package

Submodules

linkml.generators.csvgen module

Generate CSVs

class linkml.generators.csvgen.CsvGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **kwargs)[source]

Bases: linkml.utils.generator.Generator

generate_header()[source]
generatorname: str = 'csvgen.py'
generatorversion: str = '0.1.1'
valid_formats: List[str] = ['csv', 'tsv']
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_schema(classes: Optional[List[linkml_runtime.linkml_model.meta.ClassDefinitionName]] = None, **_) None[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

linkml.generators.dotgen module

Generate dotfiles

class linkml.generators.dotgen.DotGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **kwargs)[source]

Bases: linkml.utils.generator.Generator

directory_output: bool = True
edge(*args, **kwargs) None[source]
end_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) None[source]

Visited after visit_class_slots (if visit_class returned true)

@param cls: class being visited

end_schema(**_) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generatorname: str = 'dotgen.py'
generatorversion: str = '0.1.1'
node(*args, **kwargs) None[source]
valid_formats: List[str] = ['png', 'bmp', 'canon', 'cgimage', 'cmap', 'cmapx', 'cmapx_np', 'dot', 'dot_json', 'eps', 'exr', 'fig', 'gd', 'gd2', 'gif', 'gtk', 'gv', 'ico', 'imap', 'imap_np', 'ismap', 'jp2', 'jpe', 'jpeg', 'jpg', 'json', 'json0', 'pct', 'pdf', 'pic', 'pict', 'plain', 'plain-ext', 'png', 'pov', 'ps', 'ps2', 'psd', 'sgi', 'svg', 'svgz', 'tga', 'tif', 'tiff', 'tk', 'vml', 'vmlz', 'vrml', 'wbmp', 'webp', 'x11', 'xdot', 'xdot1.2', 'xdot1.4', 'xdot_json', 'xlib']
visit_all_class_slots: bool = True
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition)[source]

Visited for each slot in a class. If class level visit_all_slots is true, this is visited once for any class that is inherited (class itself, is_a, mixin, apply_to). Otherwise just the own slots.

@param cls: containing class @param aliased_slot_name: Aliased slot name. May not be unique across all class slots @param slot: slot being visited

visit_schema(classname: Optional[List[str]] = None, directory: Optional[str] = None, filename: Optional[str] = None, **_) None[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

linkml.generators.excelgen module

class linkml.generators.excelgen.ExcelGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], output: Optional[str] = None, **kwargs)[source]

Bases: linkml.utils.generator.Generator

This class is a blueprint for the generator module that is responsible for automatically creating Excel spreadsheets from the LinkML schema.

Parameters
  • schema (class:SchemaDefinition) – LinkML schema object

  • output (str) – LinkML schema specification in YAML format

generator_name = 'excelgen'
generator_version = '0.0.1'
sheet_name_cols = []
valid_formats: List[str] = ['xlsx']
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Overridden method to intercept classes from generator framework.

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Overridden method to intercept classes and associated slots from generator framework.

visit_enum(enum: linkml_runtime.linkml_model.meta.EnumDefinition) bool[source]

Overridden method to intercept enums from generator framework.

linkml.generators.flattener module

linkml.generators.golrgen module

Generate GOlr YAML schema definitions.

These can be converted to solr schema-xml, and used in amigo-bbop tools

See the golr-views directory in this repo for examples

class linkml.generators.golrgen.GOLRClass(id: str, schema_generating: bool, description: str, display_name: str, document_category: str, weight: int, fields: List[linkml.generators.golrgen.GOLRField] = <factory>, **_kwargs)[source]

Bases: linkml_runtime.utils.yamlutils.YAMLRoot

description: str
display_name: str
document_category: str
fields: List[linkml.generators.golrgen.GOLRField]
id: str
schema_generating: bool
weight: int
class linkml.generators.golrgen.GOLRField(id: str, description: str, display_name: str, property: List = <factory>, cardinality: Optional[str] = None, **_kwargs)[source]

Bases: linkml_runtime.utils.yamlutils.YAMLRoot

cardinality: Optional[str] = None
description: str
display_name: str
id: str
property: List
class linkml.generators.golrgen.GolrSchemaGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], directory: Optional[str] = None, **kwargs)[source]

Bases: linkml.utils.generator.Generator

directory_output: bool = True
end_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) None[source]

Visited after visit_class_slots (if visit_class returned true)

@param cls: class being visited

generate_header()[source]
generatorname: str = 'golrgen.py'
generatorversion: str = '0.1.1'
valid_formats: List[str] = ['golr']
visit_all_class_slots: bool = True
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited for each slot in a class. If class level visit_all_slots is true, this is visited once for any class that is inherited (class itself, is_a, mixin, apply_to). Otherwise just the own slots.

@param cls: containing class @param aliased_slot_name: Aliased slot name. May not be unique across all class slots @param slot: slot being visited

visit_schema(directory: str, **_) None[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

linkml.generators.graphqlgen module

class linkml.generators.graphqlgen.GraphqlGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **kwargs)[source]

Bases: linkml.utils.generator.Generator

end_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) None[source]

Visited after visit_class_slots (if visit_class returned true)

@param cls: class being visited

generate_header()[source]
generatorname: str = 'graphqlgen.py'
generatorversion: str = '0.1.1'
valid_formats: List[str] = ['graphql']
visit_all_class_slots: bool = True
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited for each slot in a class. If class level visit_all_slots is true, this is visited once for any class that is inherited (class itself, is_a, mixin, apply_to). Otherwise just the own slots.

@param cls: containing class @param aliased_slot_name: Aliased slot name. May not be unique across all class slots @param slot: slot being visited

linkml.generators.infer_model module

Infer a schema from a TSV

class linkml.generators.infer_model.Hit(term_id: str, name: str, score: float)[source]

Bases: object

name: str
score: float
term_id: str
linkml.generators.infer_model.convert_range(k: str, dt: str) str[source]
linkml.generators.infer_model.get_db(id: str) str[source]
linkml.generators.infer_model.get_pv_element(v: str, zooma_confidence: str, cache: dict = {}) linkml.generators.infer_model.Hit[source]

uses ZOOMA to guess a meaning of an enum permissible value

Parameters
  • v

  • zooma_confidence

  • cache

Returns

linkml.generators.infer_model.infer_enum_meanings(schema: dict, zooma_confidence: str = 'MEDIUM', cache={}) None[source]
linkml.generators.infer_model.infer_model(tsvfile: str, sep='\t', class_name='example', schema_name: str = 'example', enum_columns=[], enum_threshold=0.1, max_enum_size=50) dict[source]
linkml.generators.infer_model.infer_range(slot: dict, vals: set, types: dict) str[source]
linkml.generators.infer_model.is_date(string, fuzzy=False)[source]

Return whether the string can be interpreted as a date.

Parameters
  • string – str, string to check for date

  • fuzzy – bool, ignore unknown tokens in string if True

linkml.generators.javagen module

class linkml.generators.javagen.JavaGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], package: Optional[str] = None, template_file: Optional[str] = None, format: str = 'java', genmeta: bool = False, gen_classvars: bool = True, gen_slots: bool = True, **kwargs)[source]

Bases: linkml.generators.oocodegen.OOCodeGenerator

generatorname: str = 'javagen.py'
generatorversion: str = '0.9.0'
map_type(t: linkml_runtime.linkml_model.meta.TypeDefinition) str[source]
serialize(directory: str, **kwargs) None[source]

Generate output in the required format

Parameters

kwargs – Generater specific parameters

Returns

Generated output

valid_formats: List[str] = ['java']
visit_all_class_slots: bool = False

linkml.generators.jsonldcontextgen module

Generate JSON-LD contexts

class linkml.generators.jsonldcontextgen.ContextGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **kwargs)[source]

Bases: linkml.utils.generator.Generator

end_schema(base: Optional[str] = None, output: Optional[str] = None, prefixes: Optional[bool] = True, flatprefixes: Optional[bool] = False, model: Optional[bool] = True, **_) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generatorname: str = 'jsonldcontextgen.py'
generatorversion: str = '0.1.1'
valid_formats: List[str] = ['context', 'json']
visit_all_class_slots: bool = False
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_schema(base: Optional[str] = None, output: Optional[str] = None, **_)[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

visit_slot(aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited once for every slot definition in the schema.

@param aliased_slot_name: Aliased name of the slot. May not be unique @param slot: visited slot

linkml.generators.jsonldgen module

Generate JSONld

class linkml.generators.jsonldgen.JSONLDGenerator(*args, **kwargs)[source]

Bases: linkml.utils.generator.Generator

adjust_slot(slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]
end_schema(context: Optional[str] = None, **_) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generatorname: str = 'jsonldgen.py'
generatorversion: str = '0.0.2'
valid_formats: List[str] = ['jsonld', 'json']
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_slot(aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited once for every slot definition in the schema.

@param aliased_slot_name: Aliased name of the slot. May not be unique @param slot: visited slot

visit_subset(ss: linkml_runtime.linkml_model.meta.SubsetDefinition) None[source]

Visited once for every subset definition in the schema

#param subset: Subset definition

visit_type(typ: linkml_runtime.linkml_model.meta.TypeDefinition) None[source]

Visited once for every type definition in the schema

@param typ: Type definition

linkml.generators.jsonschemagen module

class linkml.generators.jsonschemagen.JsonSchemaGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], top_class: Optional[str] = None, **kwargs)[source]

Bases: linkml.utils.generator.Generator

Generates JSONSchema documents from a LinkML SchemaDefinition

  • Each linkml class generates a schema

  • inheritance hierarchies are rolled-down from ancestors

  • Composition not yet implemented

  • Enumerations treated as strings

  • Foreign key references are treated as semantics-free strings

end_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) None[source]

Visited after visit_class_slots (if visit_class returned true)

@param cls: class being visited

end_schema(**_) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generatorname: str = 'jsonschemagen.py'
generatorversion: str = '0.0.2'
get_ref_for_descendants(descendants: List)[source]
valid_formats: List[str] = ['json']
visit_all_class_slots: bool = True
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited for each slot in a class. If class level visit_all_slots is true, this is visited once for any class that is inherited (class itself, is_a, mixin, apply_to). Otherwise just the own slots.

@param cls: containing class @param aliased_slot_name: Aliased slot name. May not be unique across all class slots @param slot: slot being visited

visit_enum(enum: linkml_runtime.linkml_model.meta.EnumDefinition) bool[source]

Visited once for every enum definition in the schema

@param enum: Enum definition

visit_schema(inline: bool = False, not_closed=True, **kwargs) None[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

linkml.generators.lpgen module

linkml.generators.markdowngen module

class linkml.generators.markdowngen.MarkdownGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], no_types_dir: bool = False, noyuml: bool = False, warn_on_exist: bool = False, **kwargs)[source]

Bases: linkml.utils.generator.Generator

Generates markdown documentation for a LinkML schema

Each schema element (class, slot, type, enum) is translated into its own markdown file; additionally, an index.md is generated that links everything together.

The markdown is suitable for deployment as a MkDocs or Sphinx site

static anchor(id_: str) None[source]
static anchorend() None[source]
bbin(obj: linkml_runtime.linkml_model.meta.Element) str[source]

Boldify built in types

@param obj: object name or id @return:

static bullet(txt: str, level=0) None[source]
class_hier(cls: linkml_runtime.linkml_model.meta.ClassDefinition, level=0) None[source]
desc_for(obj: linkml_runtime.linkml_model.meta.Element, doing_descs: bool) str[source]

Return a description for object if it is unique (different than its parent)

@param obj: object to be described @param doing_descs: If false, always return an empty string @return: text or empty string

dir_path(obj: Union[linkml_runtime.linkml_model.meta.ClassDefinition, linkml_runtime.linkml_model.meta.SlotDefinition, linkml_runtime.linkml_model.meta.TypeDefinition, linkml_runtime.linkml_model.meta.EnumDefinition]) str[source]
directory_output: bool = True
element_header(obj: linkml_runtime.linkml_model.meta.Element, name: str, curie: str, uri: str) None[source]
element_properties(obj: linkml_runtime.linkml_model.meta.Element) None[source]
enum_hier(enum: linkml_runtime.linkml_model.meta.EnumDefinition, level=0) None[source]
exist_warning(*fpath: str) str[source]

Create a file name out of fpath and check whether it already exists

frontmatter(thingtype: str, layout='default') None[source]
generatorname: str = 'markdowngen.py'
generatorversion: str = '0.2.1'
header(level: int, txt: str) None[source]
static id_to_url(id_: str) str[source]
is_secondary_ref(en: str) bool[source]

Determine whether ‘en’ is the name of something in the neighborhood of the requested classes

@param en: element name @return: True if ‘en’ is the name of a slot, class or type in the immediate neighborhood of of what we are building

mappings(obj: [<class 'linkml_runtime.linkml_model.meta.SlotDefinition'>, <class 'linkml_runtime.linkml_model.meta.ClassDefinition'>]) None[source]
static para(txt: str) None[source]
pred_hier(slot: linkml_runtime.linkml_model.meta.SlotDefinition, level=0) None[source]
static predicate_cardinality(slot: linkml_runtime.linkml_model.meta.SlotDefinition) str[source]

Emit cardinality for a suffix on a predicate

static range_cardinality(slot: linkml_runtime.linkml_model.meta.SlotDefinition) str[source]

Emits cardinality decorator at end of type

slot_field(cls: linkml_runtime.linkml_model.meta.ClassDefinition, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]
to_uri(uri_or_curie: str) str[source]

Return the URI for the slot if known

valid_formats: List[str] = ['md']
visit_all_class_slots: bool = False
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_enum(enum: linkml_runtime.linkml_model.meta.EnumDefinition) None[source]

Visited once for every enum definition in the schema

@param enum: Enum definition

visit_schema(directory: Optional[str] = None, classes: Optional[Set[linkml_runtime.linkml_model.meta.ClassDefinitionName]] = None, image_dir: bool = False, index_file: str = 'index.md', noimages: bool = False, **_) None[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

visit_slot(aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited once for every slot definition in the schema.

@param aliased_slot_name: Aliased name of the slot. May not be unique @param slot: visited slot

visit_subset(subset: linkml_runtime.linkml_model.meta.SubsetDefinition) None[source]

Visited once for every subset definition in the schema

#param subset: Subset definition

visit_type(typ: linkml_runtime.linkml_model.meta.TypeDefinition) None[source]

Visited once for every type definition in the schema

@param typ: Type definition

linkml.generators.namespacegen module

class linkml.generators.namespacegen.NamespaceGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], format: str = 'py', genmeta: bool = False, gen_classvars: bool = True, gen_slots: bool = True, **kwargs)[source]

Bases: linkml.generators.pythongen.PythonGenerator

gen_namespaces() str[source]
gen_schema() str[source]
generatorname: str = 'namespacegen.py'
generatorversion: str = '0.9.0'
valid_formats: List[str] = ['py']
visit_all_class_slots: bool = False

linkml.generators.oocodegen module

class linkml.generators.oocodegen.OOClass(name: str, is_a: typing.Optional[str] = None, abstract: typing.Optional[bool] = None, mixins: typing.List[str] = <factory>, fields: typing.List[linkml.generators.oocodegen.OOField] = <factory>, all_fields: typing.List[linkml.generators.oocodegen.OOField] = <factory>, annotations: typing.List[str] = <factory>, package: typing.Optional[str] = None, source_class: typing.Optional[linkml_runtime.linkml_model.meta.ClassDefinition] = None)[source]

Bases: object

An object-oriented class

abstract: Optional[bool] = None
all_fields: List[linkml.generators.oocodegen.OOField]
annotations: List[str]
fields: List[linkml.generators.oocodegen.OOField]
is_a: Optional[str] = None
mixins: List[str]
name: str
package: str = None
source_class: linkml_runtime.linkml_model.meta.ClassDefinition = None
class linkml.generators.oocodegen.OOCodeGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition, linkml.utils.generator.Generator], format: Optional[str] = None, metadata: bool = True, useuris: Optional[bool] = None, importmap: Optional[str] = None, log_level: int = 30, mergeimports: Optional[bool] = True, source_file_date: Optional[str] = None, source_file_size: Optional[int] = None, logger: Optional[logging.Logger] = None, **kwargs)[source]

Bases: linkml.utils.generator.Generator

create_documents() List[linkml.generators.oocodegen.OODocument][source]

Currently hardcoded for java-style :return:

generate_enum_label(value: str) str[source]
get_class_name(cn)[source]
get_slot_name(sn)[source]
java_style = True
make_multivalued(range: str) str[source]
map_type(t: linkml_runtime.linkml_model.meta.TypeDefinition) str[source]
package: str = 'example'
replace_invalid_identifier_character(char: str) str[source]
abstract serialize(directory: str) None[source]

Generate output in the required format

Parameters

kwargs – Generater specific parameters

Returns

Generated output

class linkml.generators.oocodegen.OODocument(name: str, package: typing.Optional[str] = None, source_schema: typing.Optional[linkml_runtime.linkml_model.meta.SchemaDefinition] = None, classes: typing.List[linkml.generators.oocodegen.OOClass] = <factory>, imports: typing.List[str] = <factory>)[source]

Bases: object

A collection of one or more OO classes

classes: List[linkml.generators.oocodegen.OOClass]
imports: List[str]
name: str
package: str = None
source_schema: linkml_runtime.linkml_model.meta.SchemaDefinition = None
class linkml.generators.oocodegen.OOField(name: str, range: typing.Optional[str] = None, default_value: typing.Optional[str] = None, annotations: typing.List[str] = <factory>, source_slot: linkml_runtime.linkml_model.meta.SlotDefinition = <factory>)[source]

Bases: object

A field belonging to an OO class that corresponds to a LinkML class slot

annotations: List[str]
default_value: str = None
name: str
range: str = None
source_slot: linkml_runtime.linkml_model.meta.SlotDefinition

linkml.generators.owlgen module

Generate OWL ontology corresponding to information model

model classes are translated to OWL classes, slots to OWL properties.

class linkml.generators.owlgen.ElementDefinition[source]

Bases: object

class linkml.generators.owlgen.MetadataProfile(value)[source]

Bases: enum.Enum

An enumeration of the different kinds of profiles used for metadata of generated OWL elements

linkml = 'linkml'
static list()[source]
rdfs = 'rdfs'
class linkml.generators.owlgen.OwlSchemaGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], ontology_uri_suffix: Optional[str] = None, type_objects=True, metaclasses=True, metadata_profile: Optional[linkml.generators.owlgen.MetadataProfile] = None, add_ols_annotations=True, **kwargs)[source]

Bases: linkml.utils.generator.Generator

Generates a schema-oriented OWL representation of a LinkML model

OWL Generator Docs

Attributes:

type_objects if True, represent TypeDefinitions as objects; if False, as literals metaclasses if True, include OWL representations of ClassDefinition, SlotDefinition, etc. Introduces punning

add_metadata(e: linkml_runtime.linkml_model.meta.Definition, uri: rdflib.term.URIRef) None[source]

Add generic annotation properties

Parameters
  • e – schema element

  • uri – URI representation of schema element

Returns

end_schema(output: Optional[str] = None, **_) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generatorname: str = 'owlgen.py'
generatorversion: str = '0.1.1'
is_slot_object_property(slot: linkml_runtime.linkml_model.meta.SlotDefinition) bool[source]
metadata_profile: linkml.generators.owlgen.MetadataProfile = None
slot_owl_type(slot: linkml_runtime.linkml_model.meta.SlotDefinition) rdflib.term.URIRef[source]
valid_formats: List[str] = ['owl', 'ttl', 'json-ld', 'xml', 'n3', 'turtle', 'ttl', 'ntriples', 'nt', 'nt11', 'nquads', 'trix', 'trig', 'hext']
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Each ClassDefinition is represented as an OWL class

  • the OWL Class will instantiate ClassDefinition, if schema.metaclasses is true

  • the OWL Class will be annotated using the same properties as the source ClassDefinition

  • induced slots and their ranges added as OWL restrictions; note this will be under the Open World Assumption

Parameters

cls

Returns

visit_enum(e: linkml_runtime.linkml_model.meta.EnumDefinition) None[source]

Visited once for every enum definition in the schema

@param enum: Enum definition

visit_schema(output: Optional[str] = None, **_)[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

visit_slot(slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Add a slot definition per slot

Note: visit_slot may be called multiple times for the same slot_uri, as the same slot_uri can be used: * when the schema declares attributes * when slot_usage induces additional slots

@param slot_name: @param slot: @return:

visit_type(typ: linkml_runtime.linkml_model.meta.TypeDefinition) None[source]

Visited once for every type definition in the schema

@param typ: Type definition

visits_are_sorted: bool = True

linkml.generators.prefixmapgen module

Generate JSON-LD contexts

class linkml.generators.prefixmapgen.PrefixGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **kwargs)[source]

Bases: linkml.utils.generator.Generator

end_schema(base: Optional[str] = None, output: Optional[str] = None, **_) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generatorname: str = 'prefixmapgen.py'
generatorversion: str = '0.1.1'
valid_formats: List[str] = ['json', 'tsv']
visit_all_class_slots: bool = False
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_schema(base: Optional[str] = None, output: Optional[str] = None, **_)[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

visit_slot(aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited once for every slot definition in the schema.

@param aliased_slot_name: Aliased name of the slot. May not be unique @param slot: visited slot

linkml.generators.projectgen module

class linkml.generators.projectgen.ProjectConfiguration(directory: str = 'tmp', generator_args: typing.Dict[str, typing.Dict[str, typing.Any]] = <factory>, includes: typing.Optional[typing.List[str]] = None, excludes: typing.Optional[typing.List[str]] = None, mergeimports: typing.Optional[bool] = None)[source]

Bases: object

Global project configuration, and per-generator configurations

directory: str = 'tmp'
excludes: List[str] = None
generator_args: Dict[str, Dict[str, Any]]
includes: List[str] = None
mergeimports: bool = None
class linkml.generators.projectgen.ProjectGenerator[source]

Bases: object

Generates complete project folders

generate(schema_path: str, config: linkml.generators.projectgen.ProjectConfiguration = ProjectConfiguration(directory='tmp', generator_args=defaultdict(<class 'dict'>, {}), includes=None, excludes=None, mergeimports=None))[source]
linkml.generators.projectgen.get_local_imports(schema_path: str, dir: str)[source]

linkml.generators.protogen module

class linkml.generators.protogen.ProtoGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **kwargs)[source]

Bases: linkml.utils.generator.Generator

A Generator for creating Protobuf schemas from a linkml schema.

end_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) None[source]

Visited after visit_class_slots (if visit_class returned true)

@param cls: class being visited

generate_header()[source]
generatorname: str = 'protogen.py'
generatorversion: str = '0.1.1'
valid_formats: List[str] = ['proto']
visit_all_class_slots: bool = True
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited for each slot in a class. If class level visit_all_slots is true, this is visited once for any class that is inherited (class itself, is_a, mixin, apply_to). Otherwise just the own slots.

@param cls: containing class @param aliased_slot_name: Aliased slot name. May not be unique across all class slots @param slot: slot being visited

linkml.generators.pydanticgen module

class linkml.generators.pydanticgen.PydanticGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], template_file: Optional[str] = None, allow_extra=False, format: str = 'pydantic', genmeta: bool = False, gen_classvars: bool = True, gen_slots: bool = True, gen_mixin_inheritance: bool = True, **kwargs)[source]

Bases: linkml.generators.oocodegen.OOCodeGenerator

generate_enums(all_enums: Dict[linkml_runtime.linkml_model.meta.EnumDefinitionName, linkml_runtime.linkml_model.meta.EnumDefinition]) Dict[str, dict][source]
generatorname: str = 'pydanticgen.py'
generatorversion: str = '0.0.1'
get_class_isa_plus_mixins() Dict[str, List[str]][source]

Generate the inheritance list for each class from is_a plus mixins :return:

get_class_slot_range(slot)[source]
get_mixin_identifier_range(mixin) str[source]
get_predefined_slot_values() Dict[str, Dict[str, str]][source]
Returns

Dictionary of dictionaries with predefined slot values for each class

serialize() str[source]

Generate output in the required format

Parameters

kwargs – Generater specific parameters

Returns

Generated output

sort_classes(clist: List[linkml_runtime.linkml_model.meta.ClassDefinition]) List[linkml_runtime.linkml_model.meta.ClassDefinition][source]

sort classes such that if C is a child of P then C appears after P in the list

Overridden method include mixin classes

TODO: This should move to SchemaView

valid_formats: List[str] = ['pydantic']
visit_all_class_slots: bool = False

linkml.generators.pythongen module

class linkml.generators.pythongen.PythonGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], format: str = 'py', genmeta: bool = False, gen_classvars: bool = True, gen_slots: bool = True, **kwargs)[source]

Bases: linkml.utils.generator.Generator

Generates Python dataclasses from a LinkML model

class_reference_type(slot: linkml_runtime.linkml_model.meta.SlotDefinition, cls: Optional[linkml_runtime.linkml_model.meta.ClassDefinition]) Tuple[str, str, str][source]

Return the type of a slot referencing a class

Parameters
  • slot – slot to be typed

  • cls – owning class. Used for generating key references

Returns

Python class reference type, most proximal type, most proximal type name

compile_module(**kwargs) module[source]

Compiles generated python code to a module :return:

end_schema(**_)[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

forward_reference(slot_range: str, owning_class: str) bool[source]

Determine whether slot_range is a forward reference

gen_class_meta(cls: linkml_runtime.linkml_model.meta.ClassDefinition) str[source]
static gen_class_reference(rangelist: List[str]) str[source]

Return a basic or a union type depending on the number of elements in range list

Parameters

rangelist – List of types from distal to proximal

Returns

gen_class_variable(cls: linkml_runtime.linkml_model.meta.ClassDefinition, slot: linkml_runtime.linkml_model.meta.SlotDefinition, can_be_positional: bool) str[source]

Generate a class variable declaration for the supplied slot. Note: the can_be_positional attribute works, but it makes tag/value lists unduly complex, as you can’t load them with tag=…, value=… – you HAVE to load positionally. We currently ignore this parameter, meaning that we have a tag/value option for any LinkML element

Parameters
  • cls – Owning class

  • slot – slot definition

  • can_be_positional – True means that positional parameters are allowed.

Returns

Initializer string

gen_class_variables(cls: linkml_runtime.linkml_model.meta.ClassDefinition) str[source]

Generate the variable declarations for a dataclass.

Parameters

cls – class containing variables to be rendered in inheritence hierarchy

Returns

variable declarations for target class and its ancestors

gen_classdef(cls: linkml_runtime.linkml_model.meta.ClassDefinition) str[source]

Generate python definition for class cls

gen_classdefs() str[source]

Create class definitions for all non-mixin classes in the model Note that apply_to classes are transformed to mixins

gen_enum(enum: linkml_runtime.linkml_model.meta.EnumDefinition) str[source]
gen_enum_comment(enum: linkml_runtime.linkml_model.meta.EnumDefinition) str[source]
gen_enum_definition(enum: linkml_runtime.linkml_model.meta.EnumDefinition, enum_name: str) str[source]
gen_enum_description(enum: linkml_runtime.linkml_model.meta.EnumDefinition, enum_name: str) str[source]
gen_enumerations() str[source]
gen_import_list() Dict[str, List[str]][source]

Generate a list of types to import

Returns

source file followed by elements to import

gen_imports() str[source]
gen_inherited_slots(cls: linkml_runtime.linkml_model.meta.ClassDefinition) str[source]
gen_namespaces() str[source]
gen_postinit(cls: linkml_runtime.linkml_model.meta.ClassDefinition, slot: linkml_runtime.linkml_model.meta.SlotDefinition) Optional[str][source]

Generate python post init rules for slot in class

gen_postinits(cls: linkml_runtime.linkml_model.meta.ClassDefinition) str[source]

Generate all the typing and existence checks post initialize

gen_pv_constructor(pv: linkml_runtime.linkml_model.meta.PermissibleValue, indent: int) List[str][source]

Generate a permissible value constructor @param pv: Value to be constructed @param indent: number of additional spaces to add on successive lines @return: Permissible value constructor

gen_pvs(enum: linkml_runtime.linkml_model.meta.EnumDefinition) str[source]

Generate the python compliant permissible value initializers as a set of class variables @param enum: @return:

gen_pvs2(enum: linkml_runtime.linkml_model.meta.EnumDefinition) str[source]

Generate the non-python compliant permissible value initializers as a set of setattr instructions @param enum: @return:

gen_pvs2_initializers(enum: linkml_runtime.linkml_model.meta.EnumDefinition) str[source]
gen_references() str[source]

Generate python type declarations for all identifiers (primary keys)

gen_schema() str[source]
gen_slot(slot: linkml_runtime.linkml_model.meta.SlotDefinition) str[source]
gen_slotdefs() str[source]
gen_type_meta(typ: linkml_runtime.linkml_model.meta.TypeDefinition) str[source]
gen_typedefs() str[source]

Generate python type declarations for all defined types

generatorname: str = 'pythongen.py'
generatorversion: str = '0.9.0'
is_key_value_class(range_name: linkml_runtime.linkml_model.meta.DefinitionName) bool[source]

Return True if range_name references a class with exactly one key and one value

Parameters

range_name – class definition (name)

Returns

True if meets the special case

key_name_for(class_name: linkml_runtime.linkml_model.meta.ClassDefinitionName) Optional[str][source]
primary_keys_for(cls: linkml_runtime.linkml_model.meta.ClassDefinition) List[linkml_runtime.linkml_model.meta.SlotDefinitionName][source]

Return the primary key for cls.

Note: At the moment we return at most one entry. At some point, keys will be expanded to support

composite keys.

@param cls: class to get keys for @return: List of primary keys or identifiers

python_uri_for(uriorcurie: Union[str, rdflib.term.URIRef]) Tuple[str, Optional[str]][source]

Return the python form of uriorcurie :param uriorcurie: :return: URI and CURIE form

range_cardinality(slot: linkml_runtime.linkml_model.meta.SlotDefinition, cls: Optional[linkml_runtime.linkml_model.meta.ClassDefinition], positional_allowed: bool) Tuple[str, Optional[str]][source]

Return the range type including initializers, etc. Generate a class variable declaration for the supplied slot. Note: the positional_allowed attribute works, but it makes tag/value lists unduly complex, as you can’t load them with tag=…, value=… – you HAVE to load positionally. We currently ignore this parameter, meaning that we have a tag/value option for any LinkML element

Parameters
  • slot – slot to generate type for

  • cls – containing class – used to render key slots correctly. If absent, slot is an add-in

  • positional_allowed – True Means that we are in the positional space and defaults are not supplied

Returns

python property name and initializer (if any)

range_type_name(slot: linkml_runtime.linkml_model.meta.SlotDefinition) str[source]

Generate the type name for the slot

valid_formats: List[str] = ['py']
visit_all_class_slots: bool = False
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_schema(**kwargs) None[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

visit_slot(aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited once for every slot definition in the schema.

@param aliased_slot_name: Aliased name of the slot. May not be unique @param slot: visited slot

visit_type(typ: linkml_runtime.linkml_model.meta.TypeDefinition) None[source]

Visited once for every type definition in the schema

@param typ: Type definition

linkml.generators.rdfgen module

YAML Schema to RDF Generator

Generate a JSON LD representation of the model

class linkml.generators.rdfgen.RDFGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **kwargs)[source]

Bases: linkml.utils.generator.Generator

end_schema(output: Optional[str] = None, context: Optional[str] = None, **_) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generatorname: str = 'rdfgen.py'
generatorversion: str = '0.1.1'
valid_formats: List[str] = ['ttl', 'hext', 'json-ld', 'n3', 'nquads', 'nt', 'nt11', 'ntriples', 'trig', 'trix', 'ttl', 'turtle', 'xml']
visit_all_class_slots: bool = False

linkml.generators.shaclgen module

class linkml.generators.shaclgen.ShaclGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], format: str = 'ttl', genmeta: bool = False, gen_classvars: bool = True, gen_slots: bool = True, **kwargs)[source]

Bases: linkml.utils.generator.Generator

as_graph() None[source]
generate_header()[source]
generatorname: str = 'shaclgen.py'
generatorversion: str = '0.0.1'
serialize(**args) None[source]

Generate output in the required format

Parameters

kwargs – Generater specific parameters

Returns

Generated output

valid_formats: List[str] = ['ttl']
visit_all_class_slots: bool = False

linkml.generators.shexgen module

Generate ShEx definition of a model

class linkml.generators.shexgen.ShExGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **args)[source]

Bases: linkml.utils.generator.Generator

end_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) None[source]

Visited after visit_class_slots (if visit_class returned true)

@param cls: class being visited

end_schema(output: Optional[str] = None, **_) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generate_header()[source]
generatorname: str = 'shexgen.py'
generatorversion: str = '0.0.2'
valid_formats: List[str] = ['shex', 'json', 'rdf']
visit_all_class_slots: bool = False
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: linkml_runtime.linkml_model.meta.SlotDefinitionName, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited for each slot in a class. If class level visit_all_slots is true, this is visited once for any class that is inherited (class itself, is_a, mixin, apply_to). Otherwise just the own slots.

@param cls: containing class @param aliased_slot_name: Aliased slot name. May not be unique across all class slots @param slot: slot being visited

visit_schema(**_)[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

linkml.generators.sparqlgen module

class linkml.generators.sparqlgen.SparqlGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], format: str = 'sparql', named_graphs: Optional[List[str]] = None, limit: Optional[int] = None, **kwargs)[source]

Bases: linkml.utils.generator.Generator

Generates SPARQL queries that can be used for delayed validation

generate_sparql(named_graphs=None, limit: Optional[int] = None)[source]
generatorname: str = 'sparqlgen.py'
serialize(directory=None) str[source]

Generate output in the required format

Parameters

kwargs – Generater specific parameters

Returns

Generated output

split_sparql(sparql: str) Dict[str, str][source]
valid_formats: List[str] = ['sparql']
visit_all_class_slots: bool = False
linkml.generators.sparqlgen.materialize_schema(schemaview: linkml_runtime.utils.schemaview.SchemaView)[source]

linkml.generators.sqlddlgen module

class linkml.generators.sqlddlgen.Backref(original_column: 'SQLColumn', backref_column: 'SQLColumn', order_by: str = None)[source]

Bases: object

backref_column: linkml.generators.sqlddlgen.SQLColumn
order_by: str = None
original_column: linkml.generators.sqlddlgen.SQLColumn
class linkml.generators.sqlddlgen.DDLEntity(description: Optional[str] = None)[source]

Bases: object

abstract grouping

description: str = None
class linkml.generators.sqlddlgen.SQLColumn(description: Optional[str] = None, name: Optional[str] = None, mapped_to: Optional[linkml_runtime.linkml_model.meta.SlotDefinition] = None, mapped_to_alias: Optional[str] = None, table: Optional[linkml.generators.sqlddlgen.SQLTable] = None, base_type: Optional[str] = None, is_singular_primary_key: bool = False, foreign_key: Optional[linkml.generators.sqlddlgen.SQLColumn] = None)[source]

Bases: linkml.generators.sqlddlgen.DDLEntity

represents a Relational Table Column

as_ddlstr()[source]
base_type: str = None
foreign_key: Optional[linkml.generators.sqlddlgen.SQLColumn] = None
is_primary_key()[source]
is_singular_primary_key: bool = False
mapped_to: linkml_runtime.linkml_model.meta.SlotDefinition = None
mapped_to_alias: str = None
name: str = None
table: linkml.generators.sqlddlgen.SQLTable = None
class linkml.generators.sqlddlgen.SQLDDLGenerator(*args, **kwargs)[source]

Bases: linkml.utils.generator.Generator

A Generator for creating SQL DDL

DEPRECATED: Use SQLTableGenerator instead

The basic algorithm for mapping a linkml schema S is as follows:

  • Each schema S corresponds to one database schema D (see SQLSchema)

  • Each Class C in S is mapped to a table T (see SQLTable)

  • Each slot S in each C is mapped to a column Col (see SQLColumn)

if the direct_mapping attribute is set to true, then no further transformations are applied. Note that this means:

  • inline objects are modeled as Text strings

  • multivalued fields are modeled as single Text strings

this direct mapping is useful for simple spreadsheet/denormalized representations of complex data. however, for other applications, additional transformations should occur. these are:

MULTIVALUED SLOTS

The relational model does not have direct representation of lists. These are normalized as follows.

If the range of the slot is a class, and there are no other slots whose range is this class, and the slot is for a class that has a singular primary key, then a backref is added.

E.g. if we have User 0..* Address, then add a field User_id to Address.

When SQLAlchemy bindings are created, a backref mapping is added

If the range of the slot is an enum or type, then a new linktable is created, and a backref added

E.g. if a class User has a multivalues slot alias whose range is a string, then create a table user_aliases, with two columns (1) alias [a string] and (2) a backref to user

Each mapped slot C.S has a range R

ranges that are types (literals):
  • If R is a type, and the slot is NOT multivalued, do a direct type conversion

  • If R is a type, and the slot is multivalued: * do not include the mapped column * create a new table T_S, with 2 columns: S, and a backref to T

ranges that are classes:

Ref = map_class_to_table(R) - if R is a class, and the slot is NOT multivalued, and Ref has a singular primary key:

  • Col.type = ForeignKey(Ref.PK)

  • if R is a class, and the slot is NOT multivalued, and Ref has NO singular primary key: * add a foreign key C.pk to Ref * add a backref C.S => Ref, C.pk * remove Col from T

  • If R is a class, and the slot IS multivalued

dialect: str
end_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) None[source]

Visited after visit_class_slots (if visit_class returned true)

@param cls: class being visited

end_schema(**kwargs) None[source]

Visited once at the end of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

generate_ddl() None[source]
generate_header()[source]
generatorname: str = 'sqlddlgen.py'
generatorversion: str = '0.1.1'
get_sql_range(slot: linkml_runtime.linkml_model.meta.SlotDefinition)[source]

returns a SQL Alchemy column type

inject_primary_keys: bool = True
sqlschema: linkml.generators.sqlddlgen.SQLSchema = SQLSchema(description=None, name=None, mapped_to=None, tables={})
use_inherits: bool = False
valid_formats: List[str] = ['sql']
visit_all_class_slots: bool = True
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited for each slot in a class. If class level visit_all_slots is true, this is visited once for any class that is inherited (class itself, is_a, mixin, apply_to). Otherwise just the own slots.

@param cls: containing class @param aliased_slot_name: Aliased slot name. May not be unique across all class slots @param slot: slot being visited

write_sqla_python_imperative(model_path: str) str[source]

imperative mapping: https://docs.sqlalchemy.org/en/14/orm/mapping_styles.html#imperative-mapping-with-dataclasses-and-attrs

maps to the python classes generated using PythonGenerator

``` output = StringIO() with redirect_stdout(output):

gen.write_sqla_python_imperative()

class linkml.generators.sqlddlgen.SQLSchema(description: typing.Optional[str] = None, name: typing.Optional[str] = None, mapped_to: typing.Optional[linkml_runtime.linkml_model.meta.SchemaDefinition] = None, tables: typing.Dict[str, linkml.generators.sqlddlgen.SQLTable] = <factory>)[source]

Bases: linkml.generators.sqlddlgen.DDLEntity

represents a Relational Schema

add_table(t: linkml.generators.sqlddlgen.SQLTable)[source]
all_columns() List[linkml.generators.sqlddlgen.SQLColumn][source]
get_table_by_class_name(cn: linkml_runtime.linkml_model.meta.ClassDefinitionName) Optional[linkml.generators.sqlddlgen.SQLTable][source]
mapped_to: linkml_runtime.linkml_model.meta.SchemaDefinition = None
name: str = None
tables: Dict[str, linkml.generators.sqlddlgen.SQLTable]
class linkml.generators.sqlddlgen.SQLTable(description: typing.Optional[str] = None, name: typing.Optional[str] = None, mapped_to: typing.Optional[linkml_runtime.linkml_model.meta.ClassDefinition] = None, columns: typing.Dict[str, linkml.generators.sqlddlgen.SQLColumn] = <factory>, in_schema: typing.Optional[linkml.generators.sqlddlgen.SQLSchema] = None, referenced_by: typing.List[linkml.generators.sqlddlgen.SQLColumn] = <factory>, primary_keys: typing.List[linkml.generators.sqlddlgen.SQLColumn] = <factory>, backrefs: typing.List[linkml.generators.sqlddlgen.Backref] = <factory>)[source]

Bases: linkml.generators.sqlddlgen.DDLEntity

represents a Relational Table

add_column(c: linkml.generators.sqlddlgen.SQLColumn)[source]
as_var() str[source]
backrefs: List[linkml.generators.sqlddlgen.Backref]
columns: Dict[str, linkml.generators.sqlddlgen.SQLColumn]
get_singular_primary_key() Optional[linkml.generators.sqlddlgen.SQLColumn][source]
in_schema: linkml.generators.sqlddlgen.SQLSchema = None
mapped_to: linkml_runtime.linkml_model.meta.ClassDefinition = None
name: str = None
primary_keys: List[linkml.generators.sqlddlgen.SQLColumn]
referenced_by: List[linkml.generators.sqlddlgen.SQLColumn]
remove_column(c)[source]

linkml.generators.summarygen module

Generate Summary Spreadsheets

class linkml.generators.summarygen.SummaryGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **args)[source]

Bases: linkml.utils.generator.Generator

generatorname: str = 'summarygen.py'
generatorversion: str = '0.1.1'
valid_formats: List[str] = ['tsv']
visit_class(cls: linkml_runtime.linkml_model.meta.ClassDefinition) bool[source]

Visited once per schema class

@param cls: class being visited @return: Visit slots and end class. False means skip and go on

visit_class_slot(cls: linkml_runtime.linkml_model.meta.ClassDefinition, aliased_slot_name: str, slot: linkml_runtime.linkml_model.meta.SlotDefinition) None[source]

Visited for each slot in a class. If class level visit_all_slots is true, this is visited once for any class that is inherited (class itself, is_a, mixin, apply_to). Otherwise just the own slots.

@param cls: containing class @param aliased_slot_name: Aliased slot name. May not be unique across all class slots @param slot: slot being visited

visit_schema(**_) None[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

linkml.generators.terminusdbgen module

linkml.generators.yamlgen module

Validate linkml input and optionally emit completely resolved biolink yaml output

class linkml.generators.yamlgen.YAMLGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **kwargs)[source]

Bases: linkml.utils.generator.Generator

A generator that produces a schema as a YAML Document

generatorname: str = 'yamlgen.py'
generatorversion: str = '0.1.0'
serialize(validateonly: bool = False, **kwargs) str[source]

Generate output in the required format

Parameters

kwargs – Generater specific parameters

Returns

Generated output

valid_formats: List[str] = ['yaml']

linkml.generators.yumlgen module

Generate yuml

https://yuml.me/diagram/scruffy/class/samples

class linkml.generators.yumlgen.YumlGenerator(schema: Union[str, TextIO, linkml_runtime.linkml_model.meta.SchemaDefinition], **args)[source]

Bases: linkml.utils.generator.Generator

static cardinality(slot: linkml_runtime.linkml_model.meta.SlotDefinition, is_attribute: bool = True) str[source]
class_associations(cn: linkml_runtime.linkml_model.meta.ClassDefinitionName, must_render: bool = False) str[source]

Emit all associations for a focus class. If none are specified, all classes are generated

@param cn: Name of class to be emitted @param must_render: True means render even if this is a target (class is specifically requested) @return: YUML representation of the association

class_box(cn: linkml_runtime.linkml_model.meta.ClassDefinitionName) str[source]

Generate a box for the class. Populate its interior only if (a) it hasn’t previously been generated and (b) it appears in the gen_classes list

@param cn: @return:

filtered_cls_slots(cn: linkml_runtime.linkml_model.meta.ClassDefinitionName, all_slots: bool = True, filtr: Optional[Callable[[linkml_runtime.linkml_model.meta.SlotDefinition], bool]] = None) List[linkml_runtime.linkml_model.meta.SlotDefinition][source]

Return the set of slots associated with the class that meet the filter criteria. Slots will be returned in defining order, with class slots returned last

@param cn: name of class to filter @param all_slots: True means include attributes @param filtr: Slot filter predicate @return: List of slot definitions

generatorname: str = 'yumlgen.py'
generatorversion: str = '0.1.1'
prop_modifier(cls: linkml_runtime.linkml_model.meta.ClassDefinition, slot: linkml_runtime.linkml_model.meta.SlotDefinition) str[source]
Return the modifiers for the slot:

(i) - inherited (m) - inherited through mixin (a) - injected (pk) - primary ckey

@param cls: @param slot: @return:

valid_formats: List[str] = ['yuml', 'png', 'pdf', 'jpg', 'json', 'svg']
visit_all_class_slots: bool = False
visit_schema(classes: Optional[Set[linkml_runtime.linkml_model.meta.ClassDefinitionName]] = None, directory: Optional[str] = None, load_image: bool = True, **_) None[source]

Visited once at the beginning of generation

@param kwargs: Arguments passed through from CLI – implementation dependent

Module contents

Generators translate between a SchemaDefinition and an alternative representation such as JsonSchema