Advanced features

The following language features are experimental, behavior is not guaranteed to stay consistent

LinkML Any type

Most of the time in LinkML, the ranges of slots are “committed” to being one of the following:

  • a class

  • a type

  • an enum

Note that even if you don’t explicitly declare a range, the default_range is used, (and the default value of default_range is string, reflecting the most common use case).

In some cases you want to make slots more flexible, for example to allow for arbitrary objects.

The linkml:Any states that the range of a slot can be any object. This isn’t a builtin type, but any class in the schema can take on this roll be being declared as linkml:Any using class_uri:

classes:

  Any:
    class_uri: linkml:Any

  ...

  Person:
   attributes:
     id:
     metadata:
       range: Any

This means all the following are valid:

name: person with string metadata
metadata: a string

name: person with an object as metadata
metadata:
  name: a string
  age: an integer

name: person with an integer
metadata: 42

Boolean constraints

The following LinkML constructs can be used to express boolean constraints:

These can be applied at the class or slot level. The range of each of these is an array of expressions.

Unions as ranges

any_of can be used to express that a range must satisfy any of a set of ranges.

One way this can be used is to compose enums together, for example if we have a vital_status enum
that can take on any a set of enums from VitalStatus OR a missing value with the type of missing value defined by an enum:

slots:
  vital_status:
    required: true
    range: Any
    any_of:
      - range: MissingValueEnum
      - range: VitalStatusEnum
enums:
  MissingValueEnum:
    permissible_values:
      INAPPLICABLE:
      NOT_COLLECTED:
      RESTRICTED:
      OTHER:
  VitalStatusEnum:
    permissible_values:
      LIVING:
      DEAD:
      UNDEAD:

Note that the range of vital_status is declared as Any, which is further constrained by the any_of expression.

Currently, it is important to always have a range declaration (even if it is Any), because LinkML constraint semantics are monotonic (i.e. new constraints can be specified but existing ones cannot be overridden - see slots for more on this). If this range declaration were not explicitly stated, then the default_range of string would be applied.

In future, LinkML may allow limited forms of non-monotonicity around default ranges, see:

https://github.com/linkml/linkml/issues/1483

Rules

Any class can have a rules block, consisting of (optional) preconditions and postconditions. This can express basic if-then logic:

classes:
  Address:
    slots:
      - street_address
      - country
    rules:
      - preconditions:
          slot_conditions:
            country:
              any_of:
                - equals_string: USA
                - equals_string: USA_territory
        postconditions:
          slot_conditions:
            postal_code:
              pattern: "[0-9]{5}(-[0-9]{4})?"
            telephone:
              pattern: "^\\+1 "
        description: USA and territories must have a specific regex pattern for postal codes and phone numbers

See above for implementation status

Defining slots

A subset of slots for a class can be declared as defining slots, indicating that membership of the class can be inferred based on ranges of those slots

classes:

  Interaction:
    slots:
      - subject
      - object

  ProteinProteinInteraction:
    is_a: Interaction
    slot_usage:
      subject:
        range: Protein
      object:
        range: Protein
    defining_slots:
      - subject
      - object

This indicates that if we have an interaction object I, and the subject and object slot values for I are both of type Protein, then I can be inferred to be of type ProteinProteinInteraction

When translating to OWL, this will make an equilance axiom:

ProteinProteinInteraction = Interaction and subject some Protein and object some Protein

And using an OWL reasoner will give the intended inferences.

This feature is experimental, and may be replaced by a more general rules mechanism in future.

equals_expression

equals_expression can be used to specify that the value of a slot should be equal to an evaluable expression, where that expression can contain other slot values as terms.

For example, a schema may allow two separate age slots for specifying age in years or in months. equals_expression is used to specify one in terns of another:

slots:
  ...
  age_in_years:
    range: decimal
    minimum_value: 0
    maximum_value: 999
    equals_expression: "{age_in_months} / 12"
  age_in_months:
    range: decimal
    equals_expression: "{age_in_years} * 12"
  is_juvenile:
    range: boolean
    equals_expression: "{age_in_years} < 18"

The expression is specified using a simple subset of Python. Slot names may be enclosed in curly braces - if any of the slot values is None then the entire expression evaluates to None.

You can insert missing values by using the --infer option when running linkml-convert.

Documentation of the expression language is available here.

See the developer documentation on inference for details of how to use this in code.

URI or CURIE as a range

In some cases, you may want to use a URI or CURIE as a range. To do this, create a class with class_uri set to the URI or CURIE and use that class as the range.