horned-functional

An OWL2 Functional-style Syntax parser for horned-owl.

🗺️ Overview

This library provides extensions to the horned-owl crate to work with the OWL Functional-Style syntax. It provides a parser written with pest and a serializer.

🔌 Usage

Add the latest versions of horned-owl and horned-functional to the [dependencies] sections of your Cargo.toml manifest:

[dependencies]
horned-owl = "0.11.0"
horned-functional = "0.4.0"

🔍 Parser

To easily read an entire OWL document, including prefixes, use the horned_functional::to_string function:

use horned_owl::ontology::set::SetOntology;

let s = std::fs::read_to_string("tests/data/ms.obo.ofn")
    .expect("failed to read OWL file");
let (ontology, prefixes) = horned_functional::from_str::<SetOntology, _>(&s)
    .expect("failed to parse OWL file");

All OWL elements can be parsed from functional syntax as well, using the FromFunctional trait to read a from a serialized string with the from_ofn method:

use horned_owl::model::Axiom;
use horned_functional::FromFunctional;

let axiom = Axiom::from_ofn("Declaration(Class(<http://purl.obolibrary.org/obo/MS_1000031>))")
    .expect("failed to parse axiom");

If the serialized version contains abbreviated IRIs, you can pass a custom prefix mapping to the from_ofn_ctx method:

use horned_owl::model::Axiom;
use horned_functional::FromFunctional;

let mut mapping = curie::PrefixMapping::default();
mapping.add_prefix("obo", "http://purl.obolibrary.org/obo/").ok();

let ctx = horned_functional::Context::from(&mapping);
let axiom = Axiom::from_ofn_ctx("Declaration(Class(obo:MS_1000031))", &ctx)
    .expect("failed to parse axiom");

✏️ Serializer

To easily serialize an entire OWL document, including prefixes, use the horned_functional::to_string function:

let mut file = std::fs::File::open("tests/data/ms.owx")
    .map(std::io::BufReader::new)
    .expect("failed to open OWL file");
let (ontology, prefixes) = horned_owl::io::owx::reader::read(&mut file)
    .expect("failed to read OWL file");

// `horned_functional::to_string` needs an AxiomMappedOntology
let axiom_mapped = ontology.into();

// serialize using the same prefixes as the input OWL/XML file
let ofn = horned_functional::to_string(&axiom_mapped, &prefixes);

// serialize without abbreviated IRIs
let ofn = horned_functional::to_string(&axiom_mapped, None);

All OWL elements can be displayed in functional syntax as well, using a custom Display implementation, allowing the functional syntax in format!, println! or write! macros. Just add the AsFunctional trait to the scope, and use the as_ofn method to get a displayable type for any supported element:

use horned_owl::model::*;
use horned_functional::AsFunctional;

let build = Build::new();

// build a Declaration(ObjectProperty(<http://purl.obolibrary.org/obo/RO_0002175>))
let op = build.object_property("http://purl.obolibrary.org/obo/RO_0002175");
let axiom = Axiom::from(DeclareObjectProperty(op));

println!("Axiom: {}", axiom.as_ofn());

💭 Feedback

⚠️ Issue Tracker

Found a bug ? Have an enhancement request ? Head over to the GitHub issue tracker of the project if you need to report or ask something. If you are filling in on a bug, please include as much information as you can about the issue, and try to recreate the same bug in a simple, easily reproducible situation.

📋 Changelog

This project adheres to Semantic Versioning and provides a changelog in the Keep a Changelog format.

📜 License

This library is provided under the open-source MIT license.

📰 Citation

This project was developed by Martin Larralde as part of a Master's Degree internship in the BBOP team of the Lawrence Berkeley National Laboratory, under the supervision of Chris Mungall. Cite this project as:

Larralde M. Developing Python and Rust libraries to improve the ontology ecosystem [version 1; not peer reviewed]. F1000Research 2019, 8(ISCB Comm J):1500 (poster) (https://doi.org/10.7490/f1000research.1117405.1)