Struct biodivine_sketchbook::sketchbook::_sketch::Sketch

pub struct Sketch {
    pub model: ModelState,
    pub observations: ObservationManager,
    pub properties: PropertyManager,
    pub annotation: String,
}

Object encompassing all of the individual modules of the Boolean network sketch.

Most of the actual functionality is implemented by the modules themselves, Sketch currently only distributes events and handles situations when cooperation between modules is needed.

Fields

model: ModelState

observations: ObservationManager

properties: PropertyManager

annotation: String

Implementations

impl Sketch

Utilities to perform consistency checks.

pub fn assert_consistency(&self) -> Result<(), String>

Assert that the sketch is consistent, return error otherwise. See Self::run_consistency_check for details on which criteria are checked.

pub fn run_consistency_check(&self) -> (bool, String)

General check that all components of the sketch are consistent together.

Note that most of the general consistency (syntax of formulas, check validity and uniqueness of IDs, ..) is enforced automatically when editing the sketch. However, some more complex details are left to be checked (either explicitely or automatically before the inference is started).

This should include:

• check that model is not empty
• check that dataset variables are valid network variables
• check that various template properties reference valid variables and data
• check that HCTL formulas only use valid variables as atomic propositions
• check that FOL formulas only use valid function symbols

fn check_model(&self) -> (bool, String)

Part of the consistency check responsible for the ‘model’ component. Returns bool (whether a model is consistent) and formated message with issues.

fn check_datasets(&self) -> (bool, String)

Part of the consistency check responsible for the ‘observations’ (datasets) component. Returns bool (whether a datasets are consistent) and formated message with issues.

fn check_static(&self) -> (bool, String)

Part of the consistency check responsible for the ‘static properties’ component. Returns bool (whether a static properties are consistent) and formated message with issues.

fn check_dynamic(&self) -> (bool, String)

Part of the consistency check responsible for the ‘dynamic properties’ component. Returns bool (whether a dynamic properties are consistent) and formated message with issues.

fn assert_static_prop_valid(&self, prop: &StatProperty) -> Result<(), String>

Check if all fields of the static property are filled and have valid values. If not, return appropriate message.

fn assert_dynamic_prop_valid(&self, prop: &DynProperty) -> Result<(), String>

Check if all fields of the dynamic property are filled and have valid values. If not, return appropriate message.

fn assert_var_valid(&self, var_id: &VarId) -> Result<(), String>

Check that variable is valid in a model. If not, return error with a proper message.

fn assert_fn_valid(&self, fn_id: &UninterpretedFnId) -> Result<(), String>

Check that function is valid in a model. If not, return error with a proper message.

fn assert_index_valid( &self, index: usize, fn_id: &UninterpretedFnId, ) -> Result<(), String>

Check that input index of uninterpreted function is in range (smaller than the arity). If not, return error with a proper message.

fn assert_context_valid_or_none( &self, context: Option<&String>, ) -> Result<(), String>

Check that context formula is valid. If not, return error with a proper message.

The context can also be None, which is valid.

fn assert_dataset_valid(&self, dataset_id: &DatasetId) -> Result<(), String>

Check that dataset is valid. If not, return error with a proper message.

fn assert_obs_valid_or_none( &self, dataset_id: &DatasetId, obs_id: Option<&ObservationId>, ) -> Result<(), String>

Check whether observation is valid in a dataset. If not, return error with a proper message. If observation is None, that is also fine.

impl Sketch

pub fn to_custom_json(&self) -> String

Convert the sketch instance into a custom (pretty) JSON string.

See SketchData::to_pretty_json_str for details on the actual conversion to JSON.

pub fn export_to_custom_json(&self, filepath: &str) -> Result<(), String>

Export the sketch instance into a custom JSON model format.

See SketchData::to_pretty_json_str for details on the actual conversion to JSON.

impl Sketch

pub fn to_aeon(&self) -> String

Convert the sketch instance into a customized version of AEON model format.

This format includes the standard AEON format for PSBN and layout. This format is compatible with other biodivine tools, but might not cover all parts of the sketch.

Apart from that, most remaining details of the sketch are given via model annotations. Currently the annotations are given simpy as #!entity_type: ID: #json_string# These entities can be variables, functions, static/dynamic properties, and datasets.

pub fn export_to_aeon(&self, filepath: &str) -> Result<(), String>

Export the sketch instance into a customized version of AEON model format.

See Sketch::to_aeon for details on the actual conversion.

impl Sketch

pub fn from_aeon(aeon_str: &str) -> Result<Sketch, String>

Create sketch instance from a customized version of AEON model format. The original part of the AEON format (compatible with other biodivine tools) includes:

• variable IDs
• regulations (and corresponding automatically generated static properties)
• update functions and function symbols
• layout information

The custom extension covers most remaining parts of the sketch via model annotations. Currently the annotations are given simpy as #!entity_type: ID: #json_string# These annotations either cover additional information (complementing variables and functions), or completely new components like static/dynamic properties and datasets.

We allow a special case for writing HCTL and FOL properties, compatible with the original BN sketches prototype format: #!static_property: ID: #fol_formula_string# #!dynamic_property: ID: #hctl_formula_string#

pub fn from_sbml(sbml_str: &str) -> Result<Sketch, String>

Create sketch instance from a SBML model format. This variant includes:

• variables
• regulations (and corresponding automatically generated static properties)
• update functions and function symbols
• layout information

pub fn from_boolean_network(bn: &BooleanNetwork) -> Result<Sketch, String>

Create sketch instance from a BooleanNetwork instance of lib-param-bn. This includes processing:

• variables
• regulations (and corresponding automatically generated static properties)
• update functions and function symbols

fn extract_aeon_layout_info(aeon_str: &str) -> Vec<(String, f32, f32)>

Extract positions of nodes from the aeon model string. Positions are expect as lines in forllowing format: #position:NODE_ID:X,Y

This funtction returns a list of triplets <node_id, x, y>.

fn extract_entities( annotations: &ModelAnnotation, entity_type: &str, ) -> Result<Vec<(String, String)>, String>

Extract list of named entities (tuples with id/content) from an .aeon model annotation object.

The entities are expected to appear as: #!entity_type: ID: #CONTENT# So, for example: #!variable:ANT:#{"id":"ANT","name":"ANT","annotation":"","update_fn":""}#

Each list is returned in alphabetic order w.r.t. the entity name.

fn process_entity_node( enitity_node: &ModelAnnotation, enitity_type: &str, ) -> Result<Vec<(String, String)>, String>

Given a ModelAnnotation node corresponding to a particular entity type (like ‘variable’), collect all entities of given type from the child nodes.

This is general for all entity types as annotations share common structure. #!entity_type: ID: #CONTENT#

List is returned in alphabetic order w.r.t. the property name.

impl Sketch

pub fn from_custom_json(json_str: &str) -> Result<Sketch, String>

Create sketch instance from a custom JSON model format.

See SketchData::from_json_str for details on the actual parsing.

impl Sketch

Utility functions for creating or modifying sketch instances.

pub fn components_from_sketch_data( sketch_data: &SketchData, ) -> Result<(ModelState, ObservationManager, PropertyManager), String>

Parse and validate all components of Sketch from a corresponding SketchData instance.

pub fn new_from_sketch_data(sketch_data: &SketchData) -> Result<Sketch, String>

Create a new Sketch instance given a corresponding SketchData object.

pub fn modify_from_sketch_data( &mut self, sketch_data: &SketchData, ) -> Result<(), String>

Modify this Sketch instance by loading all its components from a corresponding SketchData instance. The original sketch information is forgotten.

pub fn modify_from_sketch(&mut self, other_sketch: &Sketch)

Modify this Sketch instance by loading all its components from a different Sketch instance. The original sketch information is forgotten.

pub fn set_to_empty(&mut self)

Modify this Sketch instance to a default (empty) settings.

pub fn get_annotation(&self) -> &str

Get annotation string.

pub fn set_annotation(&mut self, annotation: &str)

Set annotation string.

Trait Implementations

impl Clone for Sketch

fn clone(&self) -> Sketch

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Sketch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Sketch

fn default() -> Sketch

Default empty sketch.

impl Manager for Sketch

fn generate_id<T>( &self, ideal_id: &str, is_taken: &dyn Fn(&Self, &T) -> bool, num_indices: usize, start_index: Option<usize>, ) -> T

where T: FromStr, <T as FromStr>::Err: Debug,

Generate an ID of type T for a certain component of a manager (e.g., generate a VariableId for a Variable in a ModelState).

fn assert_ids_unique_and_used<T>( &self, id_list: &Vec<&str>, assert_id_is_managed: &dyn Fn(&Self, &T) -> Result<(), String>, ) -> Result<(), String>

where T: Eq + Hash + Debug + FromStr, <T as FromStr>::Err: Debug,

Check that the list of (typesafe or string) IDs contains only unique IDs (no duplicates), and check that all of the IDs are already managed by the manager instance (this is important, for instance, when we need to change already existing elements).

fn assert_ids_unique_and_new<T>( &self, id_list: &Vec<&str>, assert_id_is_new: &dyn Fn(&Self, &T) -> Result<(), String>, ) -> Result<(), String>

where T: Eq + Hash + Debug + FromStr, <T as FromStr>::Err: Debug,

Check that the list of (typesafe or string) IDs contains only unique IDs (no duplicates), and check that all of the IDs are NOT yet managed by the manager instance, i.e., they are fresh new values (this is important, for instance, when we need to add several new elements).

impl PartialEq for Sketch

fn eq(&self, other: &Sketch) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SessionHelper for Sketch

fn starts_with<'a, 'b>( prefix: &str, at_path: &'a [&'b str], ) -> Option<&'a [&'b str]>

A utility function which checks if at_path starts with a specific first segment. If yes, returns the remaining part of the path.

fn matches(expected: &[&str], at_path: &[&str]) -> bool

A utility function which checks if at_path is exactly

fn invalid_path_error_generic<T>(at_path: &[&str]) -> Result<T, DynError>

A utility function which emits a generic “invalid path” error.

fn invalid_path_error_specific<T>( path: &[&str], component: &str, ) -> Result<T, DynError>

A utility function which emits a “invalid path” error mentioning specific state’s component.

fn clone_payload_str(event: &Event, component: &str) -> Result<String, DynError>

A utility function to get and clone a payload of an event. Errors if payload is empty.

fn assert_path_length( path: &[&str], length: usize, component: &str, ) -> Result<(), DynError>

A utility function to assert that path has a given length, or emit a DynError otherwise.

fn assert_payload_empty(event: &Event, component: &str) -> Result<(), DynError>

A utility function to assert that payload is empty - otherwise, DynError is emitted.

impl SessionState for Sketch

fn perform_event( &mut self, event: &Event, at_path: &[&str], ) -> Result<Consumed, DynError>

Modify the session state using the provided event. The possible outcomes are described by Consumed.

fn refresh( &self, full_path: &[String], at_path: &[&str], ) -> Result<Event, DynError>

“Read” session state into an event without modifying it.

impl StructuralPartialEq for Sketch