sbmlutils.factory

Factory for creating SBML objects.

This module provides definitions of helper functions for the creation of SBML objects. These are the low level helpers to create models from scratch and are used in the higher level SBML factories.

The general workflow to create new SBML models isto create a lists/iterables of SBMLObjects by using the respective classes in this module, e.g. Compartment, Parameter, Species.

The actual SBase objects are than created in the SBMLDocument/Model by calling

create_objects(model, objects)

These functions DO NOT take care of the order of the creation, but the order must be correct in the model definition files. To create complete models one should use the modelcreator functionality, which takes care of the order of object creation.

Module Contents

Classes

ReactionEquation	Representation of stoichiometric equations with modifiers.
ValidationOptions	Options for SBML validator.
ModelUnits	Class for storing model units information.
KeyValuePair	KeyValuePair.
UnitDefinition	Unit.
Units	Base class for unit definitions.
Function	SBML FunctionDefinitions.
Parameter	Parameter.
Compartment	Compartment.
Species	Species.
InitialAssignment	InitialAssignments.
AssignmentRule	AssignmentRule.
RateRule	RateRule.
AlgebraicRule	AlgebraicRule.
Reaction	Reaction.
Event	Event.
Constraint	Constraint.
UncertParameter	UncertParameter.
UncertSpan	UncertSpan.
Uncertainty	Uncertainty.
ExchangeReaction	Exchange reactions define substances which can be exchanged.
GeneProduct	GeneProduct.
UserDefinedConstraintComponent	UserDefinedConstraintComponent.
UserDefinedConstraint	UserDefinedConstraint.
FluxObjective	FluxObjective.
Objective	Objective.
ModelDefinition	ModelDefinition.
ExternalModelDefinition	ExternalModelDefinition.
Submodel	Submodel.
ReplacedElement	ReplacedElement.
ReplacedBy	ReplacedBy.
Deletion	Deletion.
PortType	Supported port types.
Port	Port.
Package	Supported/tested packages.
ModelDict	ModelDict.
Model	Model.
Document	Document.
FactoryResult	Data structure for model creation.

Functions

create_model(model, filepath[, sbml_level, ...])

Create SBML model from models.

Attributes

SBML_LEVEL
SBML_VERSION
PORT_SUFFIX
PORT_UNIT_SUFFIX
UnitType
Formula

class sbmlutils.factory.ReactionEquation(reactants=None, products=None, modifiers=None, reversible=True)

Representation of stoichiometric equations with modifiers.

Parameters

• reactants (Optional[List[EquationPart]]) –

• products (Optional[List[EquationPart]]) –

• modifiers (Optional[List[str]]) –

• reversible (bool) –

static from_str(equation_str)

Parse components of equation string.

Parameters

equation_str (str) –

Return type

ReactionEquation

_parse_equation(equation_str)

Parameters

equation_str (str) –

Return type

None

_parse_modifiers(s)

Parameters

s (str) –

Return type

None

_parse_half_equation(string)

Parse half-equation.

Only ‘+ supported in equation !, do not use negative stoichiometries.

Parameters

string (str) –

Return type

List[EquationPart]

static _parse_reactant(item)

Parse stoichiometry, species, sid information.

Parameters

item (str) –

Return type

EquationPart

static _to_string_side(items)

Parameters

items (Iterable[EquationPart]) –

Return type

str

_to_string_modifiers()

Return type

str

to_string(modifiers=False)

Get string representation of equation.

Parameters

modifiers (bool) –

Return type

str

info()

Print overview of parsed equation.

Return type

None

static help()

Get help information string.

Return type

str

class sbmlutils.factory.ValidationOptions

Options for SBML validator.

Controls the consistency checks that are performed when SBMLDocument.checkConsistency() is called.

• general_consistency: Correctness and consistency of

specific SBML language constructs. Performing this set of checks is highly recommended. With respect to the SBML specification, these concern failures in applying the validation rules numbered 2xxxx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.

• ìdentifier_consistency: Correctness and consistency of

identifiers used for model entities. An example of inconsistency would be using a species identifier in a reaction rate formula without first having declared the species. With respect to the SBML specification, these concern failures in applying the validation rules numbered 103xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.

• units_consistency: Consistency of measurement units

associated with quantities in a model. With respect to the SBML specification, these concern failures in applying the validation rules numbered 105xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.

• mathml_consistency: Syntax of MathML constructs. With

respect to the SBML specification, these concern failures in applying the validation rules numbered 102xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.

• sbo_consistency: Consistency and validity of SBO

identifiers (if any) used in the model. With respect to the SBML specification, these concern failures in applying the validation rules numbered 107xx in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.

• overdetermined_model: Static analysis of whether the

system of equations implied by a model is mathematically overdetermined. With respect to the SBML specification, this is validation rule #10601 in the Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications.

• modeling_practise: Additional checks for recommended

good modeling practice. (These are tests performed by libSBML and do not have equivalent SBML validation rules.) By default, all validation checks are applied to the model in an SBMLDocument object unless SBMLDocument.setConsistencyChecks() is called to indicate that only a subset should be applied. Further, this default (i.e., performing all checks) applies separately to each new SBMLDocument object created. In other words, each time a model is read using SBMLReader.readSBML(), SBMLReader.readSBMLFromString(), or the global functions readSBML() and readSBMLFromString(), a new SBMLDocument is created and for that document, a call to SBMLDocument.checkConsistency() will default to applying all possible checks. Calling programs must invoke SBMLDocument.setConsistencyChecks() for each such new model if they wish to change the consistency checks applied.

• internal_consistency: Additional checks that model is consistent XML.

• log_errors Boolean flag to log errors.

log_errors :bool = True

internal_consistency :bool = True

general_consistency :bool = True

identifier_consistency :bool = True

mathml_consistency :bool = True

units_consistency :bool = True

sbo_consistency :bool = True

overdetermined_model :bool = True

modeling_practice :bool = True

sbmlutils.factory.SBML_LEVEL = 3

sbmlutils.factory.SBML_VERSION = 1

sbmlutils.factory.PORT_SUFFIX = _port

sbmlutils.factory.PORT_UNIT_SUFFIX = _unit_port

sbmlutils.factory.UnitType

class sbmlutils.factory.ModelUnits(time=None, extent=None, substance=None, length=None, area=None, volume=None)

Class for storing model units information.

The ModelUnits define globally the units for time, extent, substance, length, area and volume.

The following SBML Level 3 base units can be used.

ampere farad joule lux radian volt avogadro gram katal metre second watt becquerel gray kelvin mole siemens weber candela henry kilogram newton sievert coulomb hertz litre ohm steradian dimensionless item lumen pascal tesla

Parameters

• time (UnitType) –

• extent (UnitType) –

• substance (UnitType) –

• length (UnitType) –

• area (UnitType) –

• volume (UnitType) –

static set_model_units(model, model_units)

Set the main units in model from dictionary.

Setting the model units is important for understanding the model dynamics. Allowed keys are:

time extent substance length area volume

Parameters

• model (libsbml.Model) – SBMLModel

• model_units (ModelUnits) – dict of units

Returns

Return type

None

class sbmlutils.factory.KeyValuePair(key, value, uri, sid=None, name=None, sboTerm=None, metaId=None, notes=None, annotations=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

KeyValuePair.

Parameters

• key (str) –

• value (Optional[str]) –

• uri (Optional[str]) –

• sid (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• notes (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(sbase)

Create KeyValuePair on object.

Parameters

sbase (libsbml.SBase) –

Return type

libsbml.KeyValuePair

class sbmlutils.factory.UnitDefinition(sid, definition=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, replacedBy=None)

Bases: Sbase

Unit.

Corresponds to the information in the libsbml.UnitDefinition.

Parameters

• sid (str) –

• definition (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• replacedBy (Optional[Any]) –

class Config

Pydantic configuration.

arbitrary_types_allowed = True

_pint2sbml

_prefixes

create_sbml(model)

Create libsbml.UnitDefinition.

Parameters

model (libsbml.Model) –

Return type

Optional[libsbml.UnitDefinition]

_set_fields(sbase, model)

Set fields on libsbml.UnitDefinition.

Parameters

• sbase (libsbml.UnitDefinition) –

• model (libsbml.Model) –

Return type

None

static _create_unit(udef, kind, exponent, scale=0, multiplier=1.0)

Create libsbml.Unit.

Parameters

• udef (libsbml.UnitDefinition) –

• kind (str) –

• exponent (float) –

• scale (int) –

• multiplier (float) –

Return type

libsbml.Unit

static get_uid_for_unit(unit)

Get unit id for given definition string.

Parameters

unit (Union[UnitDefinition, str]) –

Return type

Optional[str]

class sbmlutils.factory.Units

Base class for unit definitions.

dimensionless

ampere

becquerel

candela

degree_Celsius

coulomb

farad

gram

gray

hertz

item

kelvin

kilogram

liter

litre

meter

metre

mole

newton

ohm

second

volt

classmethod attributes()

Get the attributes list.

Return type

List[Tuple[str, Union[str, UnitDefinition]]]

classmethod create_unit_definitions(model)

Create the libsbml.UnitDefinitions in the model.

Parameters

model (libsbml.Model) –

Return type

None

class sbmlutils.factory.Function(sid, value, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

SBML FunctionDefinitions.

FunctionDefinitions consist of a lambda expression in the value field, e.g.,

lambda(x,y, piecewise(x,gt(x,y),y) ) # definition of minimum function lambda(x, sin(x) )

Parameters

• sid (str) –

• value (str) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create FunctionDefinition SBML in model.

Parameters

model (libsbml.Model) –

Return type

libsbml.FunctionDefinition

_set_fields(sbase, model)

Parameters

• sbase (libsbml.FunctionDefinition) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.Parameter(sid, value=None, unit=None, constant=True, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: ValueWithUnit

Parameter.

Parameters

• sid (str) –

• value (Optional[Union[str, float]]) –

• unit (UnitType) –

• constant (bool) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create Parameter SBML in model.

Parameters

model (libsbml.Model) –

Return type

libsbml.Parameter

_set_fields(sbase, model)

Set fields.

Parameters

• sbase (libsbml.Parameter) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.Compartment(sid, value, unit=None, constant=True, spatialDimensions=3, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: ValueWithUnit

Compartment.

Parameters

• sid (str) –

• value (Union[str, float]) –

• unit (UnitType) –

• constant (bool) –

• spatialDimensions (float) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create Compartment SBML in model.

Parameters

model (libsbml.Model) –

Return type

libsbml.Compartment

_set_fields(sbase, model)

Set fields on Compartment.

Parameters

• sbase (libsbml.Compartment) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.Species(sid, compartment, initialAmount=None, initialConcentration=None, substanceUnit=None, hasOnlySubstanceUnits=False, constant=False, boundaryCondition=False, charge=None, chemicalFormula=None, conversionFactor=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

Species.

Parameters

• sid (str) –

• compartment (str) –

• initialAmount (Optional[float]) –

• initialConcentration (Optional[float]) –

• substanceUnit (UnitType) –

• hasOnlySubstanceUnits (bool) –

• constant (bool) –

• boundaryCondition (bool) –

• charge (Optional[float]) –

• chemicalFormula (Optional[str]) –

• conversionFactor (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create Species SBML in model.

Parameters

model (libsbml.Model) –

Return type

libsbml.Species

_set_fields(sbase, model)

Set fields on libsbml.Species.

Parameters

• sbase (libsbml.Species) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.InitialAssignment(symbol, value, unit=Units.dimensionless, sid=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Value

InitialAssignments.

The unit attribute is only for the case where a parameter must be created (which has the unit). In case of an initialAssignment of a value the units have to be defined in the math.

Parameters

• symbol (str) –

• value (Union[str, float]) –

• unit (UnitType) –

• sid (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create InitialAssignment.

Creates a required parameter if the symbol for the initial assignment does not exist in the model.

Parameters

model (libsbml.Model) –

Return type

libsbml.InitialAssignment

class sbmlutils.factory.AssignmentRule(variable, value, unit=Units.dimensionless, sid=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: ValueWithUnit, RuleWithVariable

AssignmentRule.

The unit attribute is only for the case where a parameter must be created (which has the unit). In case of an initialAssignment of a value the units have to be defined in the math.

Parameters

• variable (str) –

• value (Union[str, float]) –

• unit (UnitType) –

• sid (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

__repr__()

Get string representation.

Return type

str

create_sbml(model)

Create AssignmentRule.

Parameters

model (libsbml.Model) –

Return type

libsbml.AssignmentRule

class sbmlutils.factory.RateRule(variable, value, unit=Units.dimensionless, sid=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: ValueWithUnit, RuleWithVariable

RateRule.

Parameters

• variable (str) –

• value (Union[str, float]) –

• unit (UnitType) –

• sid (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

__repr__()

Get string representation.

Return type

str

create_sbml(model)

Create RateRule.

Parameters

model (libsbml.Model) –

Return type

libsbml.RateRule

class sbmlutils.factory.AlgebraicRule(sid, value, unit=Units.dimensionless, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: ValueWithUnit, RuleWithVariable

AlgebraicRule.

Parameters

• sid (str) –

• value (Union[str, float]) –

• unit (UnitType) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

__repr__()

Get string representation.

Return type

str

create_sbml(model)

Create AlgebraicRule.

Parameters

model (libsbml.Model) –

Return type

libsbml.AlgebraicRule

sbmlutils.factory.Formula

class sbmlutils.factory.Reaction(sid, equation, formula=None, pars=None, rules=None, compartment=None, fast=False, reversible=None, lowerFluxBound=None, upperFluxBound=None, geneProductAssociation=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

Reaction.

Class for creating libsbml.Reaction.

Equations are of the form ‘1.0 S1 + 2 S2 => 2.0 P1 + 2 P2 [M1, M2]’

The equation consists of - substrates concatenated via ‘+’ on the left side

(with optional stoichiometric coefficients)

• separation characters separating the left and right equation sides: ‘<=>’ or ‘<->’ for reversible reactions, ‘=>’ or ‘->’ for irreversible reactions (irreversible reactions are written from left to right)

• products concatenated via ‘+’ on the right side (with optional stoichiometric coefficients)

• optional list of modifiers within brackets [] separated by ‘,’

Examples of valid equations are:

‘1.0 S1 + 2 S2 => 2.0 P1 + 2 P2 [M1, M2]’, ‘c__gal1p => c__gal + c__phos’, ‘e__h2oM <-> c__h2oM’, ‘3 atp + 2.0 phos + ki <-> 16.98 tet’, ‘c__gal1p => c__gal + c__phos [c__udp, c__utp]’, ‘A_ext => A []’, ‘=> cit’, ‘acoa =>’,

Parameters

• sid (str) –

• equation (Union[sbmlutils.reaction_equation.ReactionEquation, str]) –

• formula (Optional[Union[Formula, Tuple[str, UnitType], str]]) –

• pars (Optional[List[Parameter]]) –

• rules (Optional[List[AssignmentRule]]) –

• compartment (Optional[str]) –

• fast (bool) –

• reversible (Optional[bool]) –

• lowerFluxBound (Optional[str]) –

• upperFluxBound (Optional[str]) –

• geneProductAssociation (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

static _process_equation(equation)

Process reaction equation.

Parameters

equation (Union[sbmlutils.reaction_equation.ReactionEquation, str]) –

Return type

sbmlutils.reaction_equation.ReactionEquation

static _process_formula(formula)

Process reaction formula (kinetic law).

Parameters

formula (Optional[Union[Formula, Tuple[str, UnitType], str]]) –

Return type

Optional[Formula]

create_sbml(model)

Create Reaction SBML in model.

Parameters

model (libsbml.Model) –

Return type

libsbml.Reaction

_set_fields(sbase, model)

Set fields in libsbml.Reaction.

Parameters

• sbase (libsbml.Reaction) –

• model (libsbml.Model) –

Return type

None

static set_kinetic_law(model, reaction, formula)

Set the kinetic law in reaction based on given formula.

Parameters

• model (libsbml.Model) –

• reaction (libsbml.Reaction) –

• formula (str) –

Return type

libsbml.KineticLaw

class sbmlutils.factory.Event(sid, trigger, assignments=None, trigger_persistent=True, trigger_initialValue=False, useValuesFromTriggerTime=True, priority=None, delay=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

Event.

Trigger have the format of a logical expression:

time%200 == 0

Assignments have the format

sid = value

Parameters

• sid (str) –

• trigger (str) –

• assignments (Optional[Dict[str, Union[str, float]]]) –

• trigger_persistent (bool) –

• trigger_initialValue (bool) –

• useValuesFromTriggerTime (bool) –

• priority (Optional[str]) –

• delay (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create Event SBML in model.

Parameters

model (libsbml.Model) –

Return type

libsbml.Event

_set_fields(sbase, model)

Set fields in libsbml.Event.

Parameters

• sbase (libsbml.Event) –

• model (libsbml.Model) –

Return type

None

static _trigger_from_time(t)

Create trigger from given time point.

Parameters

t (float) –

Return type

str

static _assignments_dict(species, values)

Parameters

• species (List[str]) –

• values (List[str]) –

Return type

Dict[str, str]

class sbmlutils.factory.Constraint(sid, math, message=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

Constraint.

The Constraint object is a mechanism for stating the assumptions under which a model is designed to operate. The constraints are statements about permissible values of different quantities in a model.

The message must be well formated XHTML, e.g.,

message=’<body xmlns=”http://www.w3.org/1999/xhtml”>ATP must be non-negative</body>’

Parameters

• sid (str) –

• math (str) –

• message (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create Constraint SBML in model.

Parameters

model (libsbml.Model) –

Return type

libsbml.Constraint

_set_fields(sbase, model)

Set fields on libsbml.Constraint.

Parameters

• sbase (libsbml.Constraint) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.UncertParameter(type, value=None, var=None, unit=None)

UncertParameter.

FIXME: This is an SBase!

Parameters

• type (str) –

• value (Optional[float]) –

• var (Optional[str]) –

• unit (UnitType) –

class sbmlutils.factory.UncertSpan(type, valueLower=None, varLower=None, valueUpper=None, varUpper=None, unit=None)

UncertSpan.

FIXME: This is an SBase!

Parameters

• type (str) –

• valueLower (Optional[float]) –

• varLower (Optional[str]) –

• valueUpper (Optional[float]) –

• varUpper (Optional[str]) –

• unit (UnitType) –

class sbmlutils.factory.Uncertainty(sid=None, formula=None, uncertParameters=None, uncertSpans=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, replacedBy=None)

Bases: Sbase

Uncertainty.

Uncertainty information for Sbase.

Parameters

• sid (Optional[str]) –

• formula (Optional[str]) –

• uncertParameters (Optional[List[UncertParameter]]) –

• uncertSpans (Optional[List[UncertSpan]]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• replacedBy (Optional[Any]) –

create_sbml(sbase, model)

Create libsbml Uncertainty.

Parameters

• sbase (libsbml.SBase) –

• model (libsbml.Model) –

Returns

Return type

libsbml.Uncertainty

class sbmlutils.factory.ExchangeReaction(species_id, compartment=None, fast=False, reversible=True, lowerFluxBound=None, upperFluxBound=None, geneProductAssociation=None, name=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Reaction

Exchange reactions define substances which can be exchanged.

This is important for FBC models.

EXCHANGE_IMPORT (-INF, 0): is defined as negative flux through the exchange reaction, i.e. the upper bound must be 0, the lower bound some negative value,

e.g. -INF

EXCHANGE_EXPORT (0, INF): is defined as positive flux through the exchange reaction,

i.e. the lower bound must be 0, the upper bound some positive value, e.g. INF

Parameters

• species_id (str) –

• compartment (Optional[str]) –

• fast (bool) –

• reversible (bool) –

• lowerFluxBound (Optional[str]) –

• upperFluxBound (Optional[str]) –

• geneProductAssociation (Optional[str]) –

• name (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

PREFIX = EX_

class sbmlutils.factory.GeneProduct(sid, label, associatedSpecies=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

GeneProduct.

GeneProduct is a new FBC class derived from SBML SBase that inherits metaid and sboTerm, as well as the subcomponents for Annotation and Notes. The purpose of this class is to define a single gene product. It implements two required attributes id and label as well as two optional attributes name and associatedSpecies.

Parameters

• sid (str) –

• label (str) –

• associatedSpecies (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create GeneProduct.

Parameters

model (libsbml.Model) –

Return type

libsbml.GeneProduct

class sbmlutils.factory.UserDefinedConstraintComponent(coefficient, variable, variableType=None, sid=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

UserDefinedConstraintComponent.

Parameters

• coefficient (float) –

• variable (str) –

• variableType (Optional[str]) –

• sid (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(constraint)

Create Objective.

Parameters

constraint (libsbml.UserDefinedConstraint) –

Return type

libsbml.UserDefinedConstraintComponent

class sbmlutils.factory.UserDefinedConstraint(lowerBound, upperBound, components=None, variableType=libsbml.FBC_VARIABLE_TYPE_LINEAR, sid=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

UserDefinedConstraint.

The FBC UserDefinedConstraint class is derived from SBML SBase and inherits metaid and sboTerm, as well as the subcomponents for Annotation and Notes. It’s purpose is to define non-stoichiometric constraints, that is constraints that are not necessarily defined by the stoichiometrically coupled reaction network. In order to achieve, we defined a new type of linear constraint, the UserDefinedConstraint

Parameters

• lowerBound (str) –

• upperBound (str) –

• components (Optional[Union[List[UserDefinedConstraintComponent], Dict[str, float]]]) –

• variableType (str) –

• sid (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

create_sbml(model)

Create UserDefinedConstraint.

Parameters

model (libsbml.Model) –

Return type

libsbml.UserDefinedConstraint

class sbmlutils.factory.FluxObjective(reaction, coefficient, variableType, sid=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

FluxObjective.

Parameters

• reaction (str) –

• coefficient (float) –

• variableType (str) –

• sid (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

fbc_variable_types :Set[str]

classmethod normalize_variable_type(variable_type)

Normalize variable type.

Parameters

variable_type (str) –

Return type

str

create_sbml(objective)

Create Objective.

Parameters

objective (libsbml.Objective) –

Return type

libsbml.FluxObjective

class sbmlutils.factory.Objective(sid, objectiveType=libsbml.OBJECTIVE_TYPE_MAXIMIZE, active=True, fluxObjectives=None, variableType=libsbml.FBC_VARIABLE_TYPE_LINEAR, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, port=None, uncertainties=None, replacedBy=None)

Bases: Sbase

Objective.

Parameters

• sid (str) –

• objectiveType (str) –

• active (bool) –

• fluxObjectives (Optional[Union[List[FluxObjective], Dict[str, float]]]) –

• variableType (str) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• port (Any) –

• uncertainties (Optional[List[Uncertainty]]) –

• replacedBy (Optional[Any]) –

objective_types :Set[str]

classmethod normalize_objective_type(objective_type)

Normalize objective type.

Parameters

objective_type (str) –

Return type

str

create_sbml(model)

Create Objective.

Parameters

model (libsbml.Model) –

Return type

libsbml.Objective

class sbmlutils.factory.ModelDefinition(sid, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, units=None, compartments=None, species=None)

Bases: Sbase

ModelDefinition.

Parameters

• sid (str) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• units (Optional[Type[Units]]) –

• compartments (Optional[List[Compartment]]) –

• species (Optional[List[Species]]) –

create_sbml(model)

Create ModelDefinition.

Parameters

model (libsbml.Model) –

Return type

libsbml.ModelDefinition

_set_fields(sbase, model)

Set fields on ModelDefinition.

Parameters

• sbase (libsbml.ModelDefinition) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.ExternalModelDefinition(sid, source, modelRef, md5=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None)

Bases: Sbase

ExternalModelDefinition.

Parameters

• sid (str) –

• source (str) –

• modelRef (str) –

• md5 (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

create_sbml(model)

Create ExternalModelDefinition.

Parameters

model (libsbml.Model) –

Return type

libsbml.ExternalModelDefinition

_set_fields(sbase, model)

Set fields on ExternalModelDefinition.

Parameters

• sbase (libsbml.ExternalModelDefinition) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.Submodel(sid, modelRef=None, timeConversionFactor=None, extentConversionFactor=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None)

Bases: Sbase

Submodel.

Parameters

• sid (str) –

• modelRef (Optional[str]) –

• timeConversionFactor (Optional[str]) –

• extentConversionFactor (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

create_sbml(model)

Create SBML Submodel.

Parameters

model (libsbml.Model) –

Return type

libsbml.Submodel

_set_fields(sbase, model)

Parameters

• sbase (libsbml.Submodel) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.ReplacedElement(sid, elementRef, submodelRef, deletion=None, conversionFactor=None, portRef=None, idRef=None, unitRef=None, metaIdRef=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None)

Bases: SbaseRef

ReplacedElement.

Parameters

• sid (str) –

• elementRef (str) –

• submodelRef (str) –

• deletion (Optional[str]) –

• conversionFactor (Optional[str]) –

• portRef (Optional[str]) –

• idRef (Optional[str]) –

• unitRef (Optional[str]) –

• metaIdRef (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

create_sbml(model)

Create SBML ReplacedElement.

Parameters

model (libsbml.Model) –

Return type

libsbml.ReplacedElement

_set_fields(sbase, model)

Parameters

• sbase (libsbml.ReplacedElement) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.ReplacedBy(sid, elementRef, submodelRef, portRef=None, idRef=None, unitRef=None, metaIdRef=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None)

Bases: SbaseRef

ReplacedBy.

Parameters

• sid (str) –

• elementRef (str) –

• submodelRef (str) –

• portRef (Optional[str]) –

• idRef (Optional[str]) –

• unitRef (Optional[str]) –

• metaIdRef (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

create_sbml(sbase, model)

Create SBML ReplacedBy.

Parameters

• sbase (libsbml.SBase) –

• model (libsbml.Model) –

Return type

libsbml.ReplacedBy

_set_fields(rby, model)

Set fields in ReplacedBy.

Parameters

• rby (libsbml.ReplacedBy) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.Deletion(sid, submodelRef, portRef=None, idRef=None, unitRef=None, metaIdRef=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None)

Bases: SbaseRef

Deletion.

Parameters

• sid (str) –

• submodelRef (str) –

• portRef (Optional[str]) –

• idRef (Optional[str]) –

• unitRef (Optional[str]) –

• metaIdRef (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

create_sbml(model)

Create SBML Deletion.

Parameters

model (libsbml.Model) –

Return type

libsbml.Deletion

_set_fields(sbase, model)

Set fields on Deletion.

Parameters

• sbase (libsbml.Deletion) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.PortType

Bases: str, enum.Enum

Supported port types.

PORT = port

INPUT_PORT = input port

OUTPUT_PORT = output port

class sbmlutils.factory.Port(sid, portRef=None, idRef=None, unitRef=None, metaIdRef=None, portType=PortType.PORT, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None)

Bases: SbaseRef

Port.

Ports are stored in an optional child ListOfPorts object, which, if present, must contain one or more Port objects. All of the Ports present in the ListOfPorts collectively define the ‘port interface’ of the Model.

Parameters

• sid (str) –

• portRef (Optional[str]) –

• idRef (Optional[str]) –

• unitRef (Optional[str]) –

• metaIdRef (Optional[str]) –

• portType (Optional[PortType]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

create_sbml(model)

Create SBML for Port.

Parameters

model (libsbml.Model) –

Return type

libsbml.Port

_set_fields(sbase, model)

Set fields on Port.

Parameters

• sbase (libsbml.Port) –

• model (libsbml.Model) –

Return type

None

class sbmlutils.factory.Package

Bases: str, enum.Enum

Supported/tested packages.

COMP = comp

COMP_V1 = comp-v1

DISTRIB = distrib

DISTRIB_V1 = distrib-v1

FBC = fbc

FBC_V2 = fbc-v2

FBC_V3 = fbc-v3

class sbmlutils.factory.ModelDict

Bases: TypedDict

ModelDict.

The ModelDict allows to define the Model as dictionary and then use:

md: ModelDict Model(**md)

For model construction. If possible use the Model object directly.

sid :str

name :Optional[str]

sboTerm :Optional[str]

metaId :Optional[str]

annotations :OptionalAnnotationsType

notes :Optional[str]

keyValuePairs :Optional[List[KeyValuePair]]

packages :Optional[List[Package]]

creators :Optional[List[pymetadata.core.creator.Creator]]

model_units :Optional[ModelUnits]

objects :Optional[List[Sbase]]

units :Optional[Type[Units]]

functions :Optional[List[Function]]

compartments :Optional[List[Compartment]]

species :Optional[List[Species]]

parameters :Optional[List[Parameter]]

assignments :Optional[List[InitialAssignment]]

rules :Optional[List[AssignmentRule]]

rate_rules :Optional[List[RateRule]]

algebraic_rules :Optional[List[AlgebraicRule]]

reactions :Optional[List[Reaction]]

events :Optional[List[Event]]

constraints :Optional[List[Constraint]]

external_model_definitions :Optional[List[ExternalModelDefinition]]

model_definitions :Optional[List[ModelDefinition]]

submodels :Optional[List[Submodel]]

ports :Optional[List[Port]]

replaced_elements :Optional[List[ReplacedElement]]

deletions :Optional[List[Deletion]]

user_defined_constraints :Optional[List[UserDefinedConstraint]]

objectives :Optional[List[Objective]]

gene_products :Optional[List[GeneProduct]]

layouts :Optional[List]

class sbmlutils.factory.Model(sid, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, packages=None, creators=None, model_units=None, units=None, objects=None, external_model_definitions=None, model_definitions=None, submodels=None, functions=None, compartments=None, species=None, parameters=None, assignments=None, rules=None, rate_rules=None, algebraic_rules=None, reactions=None, events=None, constraints=None, ports=None, replaced_elements=None, deletions=None, user_defined_constraints=None, objectives=None, gene_products=None, layouts=None)

Bases: Sbase, sbmlutils.utils.FrozenClass, pydantic.BaseModel

Model.

Parameters

• sid (str) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• packages (Optional[List[Package]]) –

• creators (Optional[List[pymetadata.core.creator.Creator]]) –

• model_units (Optional[ModelUnits]) –

• units (Optional[Type[Units]]) –

• objects (Optional[List[Sbase]]) –

• external_model_definitions (Optional[List[ExternalModelDefinition]]) –

• model_definitions (Optional[List[ModelDefinition]]) –

• submodels (Optional[List[Submodel]]) –

• functions (Optional[List[Function]]) –

• compartments (Optional[List[Compartment]]) –

• species (Optional[List[Species]]) –

• parameters (Optional[List[Parameter]]) –

• assignments (Optional[List[InitialAssignment]]) –

• rules (Optional[List[AssignmentRule]]) –

• rate_rules (Optional[List[RateRule]]) –

• algebraic_rules (Optional[List[AlgebraicRule]]) –

• reactions (Optional[List[Reaction]]) –

• events (Optional[List[Event]]) –

• constraints (Optional[List[Constraint]]) –

• ports (Optional[List[Port]]) –

• replaced_elements (Optional[List[ReplacedElement]]) –

• deletions (Optional[List[Deletion]]) –

• user_defined_constraints (Optional[List[UserDefinedConstraint]]) –

• objectives (Optional[List[Objective]]) –

• gene_products (Optional[List[GeneProduct]]) –

• layouts (Optional[List]) –

class Config

Pydantic configuration.

arbitrary_types_allowed = True

sid :str

name :Optional[str]

sboTerm :Optional[str]

metaId :Optional[str]

annotations :AnnotationsType

notes :Optional[str]

keyValuePairs :Optional[List[KeyValuePair]]

port :Optional[Any]

packages :List[Package]

creators :List[pymetadata.core.creator.Creator]

model_units :Optional[ModelUnits]

units :Optional[Type[Units]]

functions :List[Function]

compartments :List[Compartment]

species :List[Species]

parameters :List[Parameter]

assignments :List[InitialAssignment]

rules :List[AssignmentRule]

rate_rules :List[RateRule]

algebraic_rules :List[AlgebraicRule]

reactions :List[Reaction]

events :List[Event]

constraints :List[Constraint]

external_model_definitions :List[ExternalModelDefinition]

model_definitions :List[ModelDefinition]

submodels :List[Submodel]

ports :List[Port]

replaced_elements :List[ReplacedElement]

deletions :List[Deletion]

user_defined_constraints :List[UserDefinedConstraint]

objectives :List[Objective]

gene_products :List[GeneProduct]

layouts :Optional[List]

_keys

_supported_packages

__str__()

Get string.

Return type

str

create_sbml(doc)

Create Model.

To create the complete SBMLDocument with the model use:

doc = Document(model=model).create_sbml()

Parameters

doc (libsbml.SBMLDocument) –

Return type

libsbml.Model

get_sbml()

Create SBML model.

Return type

str

check_packages(packages)

Check that all provided packages are supported.

Parameters

packages (Optional[List[Package]]) –

Return type

List[Package]

static merge_models(models)

Merge information from multiple models.

Parameters

models (Iterable[Model]) –

Return type

Model

class sbmlutils.factory.Document(model, sid=None, name=None, sboTerm=None, metaId=None, annotations=None, notes=None, keyValuePairs=None, sbml_level=SBML_LEVEL, sbml_version=SBML_VERSION)

Bases: Sbase

Document.

Parameters

• model (Model) –

• sid (Optional[str]) –

• name (Optional[str]) –

• sboTerm (Optional[str]) –

• metaId (Optional[str]) –

• annotations (OptionalAnnotationsType) –

• notes (Optional[str]) –

• keyValuePairs (Optional[List[KeyValuePair]]) –

• sbml_level (int) –

• sbml_version (int) –

create_sbml()

Create SBML model.

Return type

libsbml.SBMLDocument

get_sbml()

Return SBML string of the model.

Returns

SBML string

Return type

str

get_json()

Get JSON representation.

Return type

str

class sbmlutils.factory.FactoryResult

Data structure for model creation.

model :Model

sbml_path :pathlib.Path

sbmlutils.factory.create_model(model, filepath, sbml_level=SBML_LEVEL, sbml_version=SBML_VERSION, validate=True, validation_options=None, show_sbml=False, annotations=None)

Create SBML model from models.

This is the entry point for creating models. If multiple models are provided these are merged in the process of model creation. See merge_models for more details.

Additional model annotations can be provided via a file.

Parameters

• model (Union[Model, Iterable[Model]]) – Model or iterable of Model instances which are merged in single model

• filepath (pathlib.Path) – Path to write the SBML model to

• sbml_level (int) – set SBML level for model generation

• sbml_version (int) – set SBML version for model generation

• validate (bool) – boolean flag to validate the SBML file

• validation_options (Optional[sbmlutils.validation.ValidationOptions]) – options for model validation

• show_sbml (bool) – boolean flag to show SBML

• annotations (Optional[pathlib.Path]) – Path to annotations file

Returns

FactoryResult

Return type

FactoryResult